Skip to main content
POST
eth_call
getValidatorInfo
curl --request POST \
  --url https://api.example.com/eth_call
{
  "status": {},
  "selfStake": {},
  "totalStake": {},
  "commissionRate": {},
  "claimableReward": {},
  "stakerCount": {}
}

​
Overview

Queries the FenineSystem contract to get comprehensive information about a specific validator including status, stakes, commission, and rewards.

​
Contract Call Details

​
to
address
required
0x0000000000000000000000000000000000001000 (FenineSystem)
​
data
bytes
required
Function selector: 0xb5d89627 + ABI-encoded validator address
​
validator
address
required
The validator address to query

​
Response

​
status
uint8
Validator status:
  • 0: NOT_EXIST (never registered)
  • 1: CREATED (registered, not staked)
  • 2: STAKED (staked, waiting activation)
  • 3: VALIDATED (active, earning rewards)
  • 4: UNSTAKED (unstaking in progress)
​
selfStake
uint256
Validator’s self-stake amount in wei
​
totalStake
uint256
Total stake (self + delegated) in wei
​
commissionRate
uint256
Commission rate in basis points (e.g., 500 = 5%)
​
claimableReward
uint256
Pending rewards available to claim in wei
​
stakerCount
uint256
Number of delegators staked to this validator

​
Examples

# Replace <VALIDATOR_ADDRESS> with actual address (without 0x prefix)
curl -X POST https://rpc.fene.app \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [{
      "to": "0x0000000000000000000000000000000000001000",
      "data": "0xb5d89627000000000000000000000000<VALIDATOR_ADDRESS>"
    }, "latest"],
    "id": 1
  }'

​
Use Cases

async function getValidatorDashboard(address) {
  const info = await contract.methods.getValidatorInfo(address).call();
  
  // Calculate delegation ratio
  const delegatedStake = BigInt(info.totalStake) - BigInt(info.selfStake);
  const delegationRatio = Number(delegatedStake * 100n / BigInt(info.totalStake));
  
  return {
    status: STATUS_NAMES[info.status],
    isActive: info.status == 3,
    selfStake: web3.utils.fromWei(info.selfStake, 'ether'),
    delegatedStake: web3.utils.fromWei(delegatedStake.toString(), 'ether'),
    totalStake: web3.utils.fromWei(info.totalStake, 'ether'),
    delegationRatio: delegationRatio.toFixed(1) + '%',
    commission: (info.commissionRate / 100) + '%',
    pendingRewards: web3.utils.fromWei(info.claimableReward, 'ether'),
    delegatorCount: info.stakerCount
  };
}

async function compareValidators(addresses) {
  const comparisons = await Promise.all(
    addresses.map(async (addr) => {
      const info = await contract.methods.getValidatorInfo(addr).call();
      return {
        address: addr,
        totalStake: web3.utils.fromWei(info.totalStake, 'ether'),
        commission: info.commissionRate / 100,
        delegators: parseInt(info.stakerCount),
        isActive: info.status == 3
      };
    })
  );
  
  // Sort by total stake
  comparisons.sort((a, b) => parseFloat(b.totalStake) - parseFloat(a.totalStake));
  
  console.table(comparisons);
  return comparisons;
}

async function canStakeToValidator(validatorAddress) {
  const info = await contract.methods.getValidatorInfo(validatorAddress).call();
  
  if (info.status != 3) {
    return { canStake: false, reason: 'Validator not active' };
  }
  
  // Check if accepting delegators (optional business logic)
  const constants = await web3.getContractConstants();
  if (info.commissionRate > constants.maxCommission) {
    return { canStake: false, reason: 'Commission too high' };
  }
  
  return {
    canStake: true,
    validatorInfo: {
      totalStake: web3.utils.fromWei(info.totalStake, 'ether'),
      commission: (info.commissionRate / 100) + '%',
      delegators: info.stakerCount
    }
  };
}

​
Status Lifecycle

NOT_EXIST (0)
    ↓ registerValidator()
CREATED (1)
    ↓ stakeValidator()
STAKED (2)
    ↓ [Epoch activation]
VALIDATED (3) ← Active, earning rewards
    ↓ unstakeValidator()
UNSTAKED (4)
    ↓ withdrawValidatorStake()
CREATED (1) ← Can re-stake

getActiveValidators

Get all active validators

getValidatorStakers

Get validator’s delegators

getDelegatorInfo

Get delegator stake info