Distribution Precompile

interface IDistr {
    // Events
    event WithdrawAddressSet(address indexed delegator, address withdrawAddr);
    event DelegationRewardsWithdrawn(address indexed delegator, string validator, uint256 amount);
    event MultipleDelegationRewardsWithdrawn(address indexed delegator, string[] validators, uint256[] amounts);
    event ValidatorCommissionWithdrawn(string indexed validator, uint256 amount);

    // Transaction Methods
    function setWithdrawAddress(address withdrawAddr) external returns (bool);
    function withdrawDelegationRewards(string memory validator) external returns (bool);
    function withdrawMultipleDelegationRewards(string[] memory validators) external returns (bool);
    function withdrawValidatorCommission() external returns (bool);

    // Query Methods
    function rewards(address delegatorAddress) external view returns (Rewards);
}

event WithdrawAddressSet(address indexed delegator, address withdrawAddr);

// Listen for withdrawal address changes
distrContract.on('WithdrawAddressSet', (delegator, withdrawAddr) => {
  console.log(`${delegator} set withdrawal address to ${withdrawAddr}`);
});

event DelegationRewardsWithdrawn(address indexed delegator, string validator, uint256 amount);

// Track individual reward withdrawals
distrContract.on('DelegationRewardsWithdrawn', (delegator, validator, amount) => {
  const seiAmount = Number(amount) / 1e6;
  console.log(`${delegator} withdrew ${seiAmount} SEI from ${validator}`);
});

event MultipleDelegationRewardsWithdrawn(address indexed delegator, string[] validators, uint256[] amounts);

// Track batch reward withdrawals
distrContract.on('MultipleDelegationRewardsWithdrawn', (delegator, validators, amounts) => {
  for (let i = 0; i < validators.length; i++) {
    const seiAmount = Number(amounts[i]) / 1e6;
    console.log(`${delegator} withdrew ${seiAmount} SEI from ${validators[i]}`);
  }
});

event ValidatorCommissionWithdrawn(string indexed validator, uint256 amount);

// Track validator commission withdrawals
distrContract.on('ValidatorCommissionWithdrawn', (validator, amount) => {
  const seiAmount = Number(amount) / 1e6;
  console.log(`Validator ${validator} withdrew ${seiAmount} SEI commission`);
});

function setWithdrawAddress(address withdrawAddr) external returns (bool success);

// Set rewards to go to a treasury contract
bool success = DISTR_CONTRACT.setWithdrawAddress(0x742d35Cc6634C0532925a3b8D4C9db96590c6C8C);
require(success, "Failed to set withdraw address");

function withdrawDelegationRewards(string memory validator) external returns (bool success);

string memory validator = "seivaloper1xyz...";
bool success = DISTR_CONTRACT.withdrawDelegationRewards(validator);
require(success, "Failed to withdraw rewards");

function withdrawMultipleDelegationRewards(string[] memory validators) external returns (bool success);

string[] memory validators = new string[](3);
validators[0] = "seivaloper1abc...";
validators[1] = "seivaloper1def...";
validators[2] = "seivaloper1ghi...";

bool success = DISTR_CONTRACT.withdrawMultipleDelegationRewards(validators);
require(success, "Failed to withdraw multiple rewards");

function withdrawValidatorCommission() external returns (bool success);

// Only works if caller is the validator operator
bool success = DISTR_CONTRACT.withdrawValidatorCommission();
require(success, "Failed to withdraw commission");

function rewards(address delegatorAddress) external view returns (Rewards rewards);

struct Coin {
    uint256 amount;    // Token amount in 18 decimal precision (DecCoins)
    uint256 decimals;  // Always 18 - decimal precision for the amount
    string denom;      // Token denomination (e.g., "usei")
}

struct Reward {
    Coin[] coins;              // Reward coins from this validator
    string validator_address;  // Validator's Sei address
}

struct Rewards {
    Reward[] rewards;  // Per-validator breakdown
    Coin[] total;      // Total rewards across all validators
}

Rewards memory userRewards = DISTR_CONTRACT.rewards(msg.sender);

// Check total rewards - uses 18 decimal precision
for (uint i = 0; i < userRewards.total.length; i++) {
    Coin memory coin = userRewards.total[i];
    // coin.decimals is always 18 for rewards
    uint256 displayAmount = coin.amount / (10 ** coin.decimals);
    // Process reward amount for coin.denom
}

// Check per-validator rewards
for (uint i = 0; i < userRewards.rewards.length; i++) {
    Reward memory reward = userRewards.rewards[i];
    // Process rewards from reward.validator_address
}

// Convert pending rewards (18 decimals) to SEI
function pendingRewardsToSei(amount: bigint): number {
  return Number(amount) / 1e18;
}

// Convert withdrawn rewards (6 decimals) to SEI
function withdrawnRewardsToSei(amount: bigint): number {
  return Number(amount) / 1e6;
}

// Example usage
const pendingRewards = await distrContract.rewards(delegatorAddress);
const pendingSei = pendingRewardsToSei(pendingRewards.total[0].amount);
console.log(`Pending rewards: ${pendingSei} SEI`);

contract YieldAggregator {
    IDistr constant DISTR = IDistr(0x0000000000000000000000000000000000001007);

    mapping(address => string[]) public userValidators;

    function harvestRewards() external {
        string[] memory validators = userValidators[msg.sender];
        require(validators.length > 0, "No validators to harvest from");

        // Efficiently withdraw from all validators
        bool success = DISTR.withdrawMultipleDelegationRewards(validators);
        require(success, "Harvest failed");

        // Additional logic to compound or distribute rewards
    }

    function checkPendingRewards(address user) external view returns (uint256 totalSei) {
        Rewards memory rewards = DISTR.rewards(user);

        for (uint i = 0; i < rewards.total.length; i++) {
            if (keccak256(bytes(rewards.total[i].denom)) == keccak256(bytes("usei"))) {
                totalSei = rewards.total[i].amount;
                break;
            }
        }
    }
}

contract ValidatorManager {
    IDistr constant DISTR = IDistr(0x0000000000000000000000000000000000001007);

    address public treasury;

    constructor(address _treasury) {
        treasury = _treasury;

        // Set commission withdrawals to go to treasury
        DISTR.setWithdrawAddress(treasury);
    }

    // Only callable by the validator operator
    function withdrawCommission() external {
        bool success = DISTR.withdrawValidatorCommission();
        require(success, "Commission withdrawal failed");
    }
}

contract SafeDistribution {
    IDistr constant DISTR = IDistr(0x0000000000000000000000000000000000001007);

    function safeWithdrawRewards(string memory validator) external returns (bool) {
        // Check if there are rewards to withdraw first
        Rewards memory rewards = DISTR.rewards(msg.sender);

        bool hasRewards = false;
        for (uint i = 0; i < rewards.rewards.length; i++) {
            if (keccak256(bytes(rewards.rewards[i].validator_address)) ==
                keccak256(bytes(validator))) {
                hasRewards = rewards.rewards[i].coins.length > 0;
                break;
            }
        }

        if (!hasRewards) {
            return false; // No rewards to withdraw
        }

        try DISTR.withdrawDelegationRewards(validator) returns (bool success) {
            return success;
        } catch {
            return false; // Handle withdrawal failure gracefully
        }
    }
}

// Automatically reinvest rewards back into staking
function autoCompound() external {
    // 1. Withdraw rewards
    DISTR.withdrawMultipleDelegationRewards(getMyValidators());

    // 2. Use staking precompile to re-delegate
    // (Implementation depends on staking precompile integration)
}

// Route all rewards to a DAO treasury
function setupTreasuryWithdrawals(address treasury) external onlyOwner {
    DISTR.setWithdrawAddress(treasury);
}