Staking Contracts

// Stake tokens to become a validator
function stake(
    uint256 amount,
    uint256 heimdallFee,
    bool acceptDelegation,
    bytes calldata signerPubkey
) external;

// Unstake tokens (starts unbonding period)
function unstake(uint256 validatorId) external;

// Claim staked tokens after unbonding
function unstakeClaim(uint256 validatorId) external;

// Restake rewards
function restake(uint256 validatorId, uint256 amount, bool restakeRewards) external;

// Withdraw rewards
function withdrawRewards(uint256 validatorId) external;

// Update commission rate
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external;

// Update signer address
function updateSigner(uint256 validatorId, bytes calldata signerPubkey) external;

// Get validator info
function validators(uint256 validatorId) external view returns (
    uint256 amount,
    uint256 reward,
    uint256 activationEpoch,
    uint256 deactivationEpoch,
    uint256 jailEndEpoch,
    address signer,
    address contractAddress,
    uint256 commissionRate,
    uint256 lastCommissionUpdate,
    uint256 delegatorsReward,
    uint256 delegatedAmount,
    uint256 initialRewardPerStake
);

// Get total staked
function totalStaked() external view returns (uint256);

// Get current epoch
function currentEpoch() external view returns (uint256);

// Check if validator is active
function isActiveValidator(uint256 validatorId) external view returns (bool);

// Buy voucher (delegate)
function buyVoucher(uint256 _amount, uint256 _minSharesToMint) external returns (uint256);

// Sell voucher (request unbond)
function sellVoucher_new(uint256 claimAmount, uint256 maximumSharesToBurn) external;

// Unstake claim (withdraw after unbonding)
function unstakeClaimTokens_new(uint256 unbondNonce) external returns (uint256);

// Withdraw rewards
function withdrawRewards() external;

// Restake rewards
function restake() external returns (uint256, uint256);

// Get liquid rewards
function getLiquidRewards(address user) external view returns (uint256);

// Get total stake
function getTotalStake(address user) external view returns (uint256, uint256);

import { 
  STAKE_MANAGER_ABI,
  VALIDATOR_SHARE_ABI,
  STAKING_INFO_ABI,
  SLASHING_MANAGER_ABI
} from '@ramestta/contracts';

// Or import from JSON
import StakeManagerABI from '@ramestta/contracts/abis/StakeManager.json';
import ValidatorShareABI from '@ramestta/contracts/abis/ValidatorShare.json';

import { ethers } from 'ethers';
import { STAKE_MANAGER_ABI, CONTRACT_ADDRESSES } from '@ramestta/contracts';

const provider = new ethers.JsonRpcProvider('https://polygon-rpc.com');

const stakeManager = new ethers.Contract(
  CONTRACT_ADDRESSES.polygon.STAKE_MANAGER,
  STAKE_MANAGER_ABI,
  provider
);

// Get validator info
const validatorId = 1;
const validator = await stakeManager.validators(validatorId);

console.log('Validator Info:', {
  stakedAmount: ethers.formatEther(validator.amount),
  pendingRewards: ethers.formatEther(validator.reward),
  commissionRate: validator.commissionRate.toString() + '%',
  signer: validator.signer,
  delegatedAmount: ethers.formatEther(validator.delegatedAmount),
  isActive: validator.deactivationEpoch.toString() === '0'
});

import { ethers } from 'ethers';
import { 
  VALIDATOR_SHARE_ABI, 
  ERC20_ABI,
  CONTRACT_ADDRESSES 
} from '@ramestta/contracts';

async function delegateToValidator(
  signer: ethers.Signer,
  validatorShareAddress: string,
  amount: bigint
) {
  // First approve RAMA tokens
  const ramaToken = new ethers.Contract(
    CONTRACT_ADDRESSES.polygon.RAMA_TOKEN,
    ERC20_ABI,
    signer
  );
  
  const approveTx = await ramaToken.approve(validatorShareAddress, amount);
  await approveTx.wait();
  console.log('Approved RAMA tokens');
  
  // Buy voucher (delegate)
  const validatorShare = new ethers.Contract(
    validatorShareAddress,
    VALIDATOR_SHARE_ABI,
    signer
  );
  
  const minShares = 1; // Minimum shares to receive
  const delegateTx = await validatorShare.buyVoucher(amount, minShares);
  const receipt = await delegateTx.wait();
  
  console.log('Delegated successfully:', receipt.hash);
  return receipt;
}

// Usage
const amount = ethers.parseEther('1000'); // 1000 RAMA
await delegateToValidator(signer, '0x...validatorShareAddress', amount);

async function claimDelegationRewards(
  signer: ethers.Signer,
  validatorShareAddress: string
) {
  const validatorShare = new ethers.Contract(
    validatorShareAddress,
    VALIDATOR_SHARE_ABI,
    signer
  );
  
  // Check pending rewards
  const userAddress = await signer.getAddress();
  const rewards = await validatorShare.getLiquidRewards(userAddress);
  console.log('Pending rewards:', ethers.formatEther(rewards), 'RAMA');
  
  if (rewards > 0n) {
    const tx = await validatorShare.withdrawRewards();
    const receipt = await tx.wait();
    console.log('Rewards claimed:', receipt.hash);
    return receipt;
  }
  
  console.log('No rewards to claim');
  return null;
}

async function unbondDelegation(
  signer: ethers.Signer,
  validatorShareAddress: string,
  amount: bigint
) {
  const validatorShare = new ethers.Contract(
    validatorShareAddress,
    VALIDATOR_SHARE_ABI,
    signer
  );
  
  // Get current shares
  const userAddress = await signer.getAddress();
  const [totalStake, shares] = await validatorShare.getTotalStake(userAddress);
  
  // Calculate shares to burn
  const sharesToBurn = (shares * amount) / totalStake;
  
  // Request unbond (starts 21-day unbonding period)
  const tx = await validatorShare.sellVoucher_new(amount, sharesToBurn);
  const receipt = await tx.wait();
  
  console.log('Unbonding started:', receipt.hash);
  console.log('Tokens available after ~21 days');
  
  return receipt;
}

// After unbonding period, claim tokens
async function claimUnbondedTokens(
  signer: ethers.Signer,
  validatorShareAddress: string,
  unbondNonce: number
) {
  const validatorShare = new ethers.Contract(
    validatorShareAddress,
    VALIDATOR_SHARE_ABI,
    signer
  );
  
  const tx = await validatorShare.unstakeClaimTokens_new(unbondNonce);
  const receipt = await tx.wait();
  
  console.log('Tokens claimed:', receipt.hash);
  return receipt;
}