eth_* Methods

Overview

Fenines Network supports all standard Ethereum JSON-RPC methods. This page focuses on using eth_call to query the FenineSystem smart contract.

For complete Ethereum JSON-RPC documentation, see the Ethereum JSON-RPC Specification.

System Contract Queries

The FenineSystem contract at 0x0000000000000000000000000000000000001000 exposes view functions that can be queried using eth_call.

Query Pattern

All queries follow this pattern:

curl -X POST https://rpc.fene.app \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [{
      "to": "0x0000000000000000000000000000000000001000",
      "data": "<FUNCTION_SELECTOR><ENCODED_PARAMS>"
    }, "latest"],
    "id": 1
  }'

Validator Queries

getActiveValidators()

Get the list of currently active validators.

string

Function selector: 0x9de70258 (no parameters)

curl -X POST https://rpc.fene.app \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [{
      "to": "0x0000000000000000000000000000000000001000",
      "data": "0x9de70258"
    }, "latest"],
    "id": 1
  }'

const Web3 = require('web3');
const web3 = new Web3('https://rpc.fene.app');

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: '0x9de70258'
}, 'latest');

// Decode result (array of addresses)
const validators = web3.eth.abi.decodeParameter('address[]', result);
console.log('Active validators:', validators);

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://rpc.fene.app'))

result = w3.eth.call({
    'to': '0x0000000000000000000000000000000000001000',
    'data': '0x9de70258'
}, 'latest')

# Decode result
validators = w3.codec.decode(['address[]'], result)[0]
print('Active validators:', validators)

bytes

ABI-encoded array of validator addresses. Decode as address[].

getValidatorInfo(address)

Get detailed information about a specific validator.

string

0xb5d89627

address

required

Validator address (32-byte padded)

# Replace <VALIDATOR_ADDRESS> with actual address (without 0x)
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
  }'

const validatorAddress = '0x1234567890123456789012345678901234567890';

// Encode function call
const data = web3.eth.abi.encodeFunctionCall({
  name: 'getValidatorInfo',
  type: 'function',
  inputs: [{
    type: 'address',
    name: 'vaAddr'
  }]
}, [validatorAddress]);

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: data
}, 'latest');

// Decode result
const decoded = web3.eth.abi.decodeParameters([
  'uint8',   // status
  'uint256', // selfStake
  'uint256', // totalStake
  'uint256', // commissionRate
  'uint256', // claimableReward
  'uint256'  // stakerCount
], result);

console.log({
  status: decoded[0],        // 0=NOT_EXIST, 1=CREATED, 2=STAKED, 3=VALIDATED, 4=UNSTAKED
  selfStake: decoded[1],
  totalStake: decoded[2],
  commissionRate: decoded[3],
  claimableReward: decoded[4],
  stakerCount: decoded[5]
});

tuple

Returns:

Show Response Fields

uint8

0: NOT_EXIST
1: CREATED (registered)
2: STAKED
3: VALIDATED (active)
4: UNSTAKED

uint256

Validator’s self-stake amount in wei

uint256

Total stake (self + delegated) in wei

uint256

Commission rate in basis points (e.g., 500 = 5%)

uint256

Pending rewards available to claim in wei

uint256

Number of delegators staked to this validator

getValidatorStakers(address)

Get the list of delegators staked to a validator (in proximity order).

string

Function selector for getValidatorStakers(address)

const validatorAddress = '0x1234567890123456789012345678901234567890';

const data = web3.eth.abi.encodeFunctionCall({
  name: 'getValidatorStakers',
  type: 'function',
  inputs: [{ type: 'address', name: 'vaAddr' }]
}, [validatorAddress]);

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: data
}, 'latest');

const stakers = web3.eth.abi.decodeParameter('address[]', result);
console.log('Delegators (proximity order):', stakers);

address[]

Array of delegator addresses in proximity order (first staker = deepest in chain)

The order matters for proximity rewards. Earlier addresses in the array are deeper in the referral chain.

Delegator Queries

getDelegatorInfo(address delegator, address validator)

Get information about a delegator’s stake with a specific validator.

string

0xa993683f

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

const delegatorAddress = '0x1111...';
const validatorAddress = '0x2222...';

const data = web3.eth.abi.encodeFunctionCall({
  name: 'getDelegatorInfo',
  type: 'function',
  inputs: [
    { type: 'address', name: 'dcAddr' },
    { type: 'address', name: 'vaAddr' }
  ]
}, [delegatorAddress, validatorAddress]);

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: data
}, 'latest');

const decoded = web3.eth.abi.decodeParameters([
  'uint8',   // status
  'uint256', // stakeAmount
  'uint256', // pendingRewards
  'uint256', // joinedAt
  'uint256'  // stakerIndex
], result);

console.log({
  status: decoded[0],        // 0=NOT_EXIST, 1=ACTIVE, 2=UNSTAKING
  stakeAmount: decoded[1],
  pendingRewards: decoded[2],
  joinedAt: decoded[3],
  stakerIndex: decoded[4]
});

tuple

Show Response Fields

uint8

0: NOT_EXIST
1: ACTIVE
2: UNSTAKING

uint256

Delegator’s stake amount in wei

uint256

Accumulated pending rewards in wei

uint256

Block number when delegator first staked

uint256

Position in proximity chain (0-based)

getEstimatedDelegatorReward(address delegator, address validator)

Calculate estimated rewards for a delegator (including proximity and tax effects).

const data = web3.eth.abi.encodeFunctionCall({
  name: 'getEstimatedDelegatorReward',
  type: 'function',
  inputs: [
    { type: 'address', name: 'dcAddr' },
    { type: 'address', name: 'vaAddr' }
  ]
}, [delegatorAddress, validatorAddress]);

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: data
}, 'latest');

const [pending, afterProximity, afterTax] = web3.eth.abi.decodeParameters([
  'uint256',
  'uint256',
  'uint256'
], result);

console.log('Pending rewards:', web3.utils.fromWei(pending, 'ether'));
console.log('After proximity:', web3.utils.fromWei(afterProximity, 'ether'));
console.log('After tax:', web3.utils.fromWei(afterTax, 'ether'));

tuple

uint256

Raw pending rewards before any deductions

uint256

Rewards after proximity distribution (may include bonus)

uint256

Final amount delegator will receive after tax

Network State Queries

totalNetworkStake()

Get the total amount of FEN staked across all validators.

string

0x635c8637

curl -X POST https://rpc.fene.app \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [{
      "to": "0x0000000000000000000000000000000000001000",
      "data": "0x635c8637"
    }, "latest"],
    "id": 1
  }'

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: '0x635c8637'
}, 'latest');

const totalStake = web3.eth.abi.decodeParameter('uint256', result);
console.log('Total network stake:', web3.utils.fromWei(totalStake, 'ether'), 'FEN');

uint256

Total staked amount in wei

getCurrentEpoch()

Get the current epoch number.

const data = web3.eth.abi.encodeFunctionSignature('getCurrentEpoch()');

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: data
}, 'latest');

const epoch = web3.eth.abi.decodeParameter('uint256', result);
console.log('Current epoch:', epoch);

getNextEpochReward()

Get the contract balance (reward pool for next epoch distribution).

const balance = await web3.eth.getBalance(
  '0x0000000000000000000000000000000000001000'
);

console.log('Next epoch reward pool:', web3.utils.fromWei(balance, 'ether'), 'FEN');

You can also query this via the contract’s getNextEpochReward() view function.

Proximity Configuration

getProximityConfig()

Get the current proximity reward distribution configuration.

const data = web3.eth.abi.encodeFunctionSignature('getProximityConfig()');

const result = await web3.eth.call({
  to: '0x0000000000000000000000000000000000001000',
  data: data
}, 'latest');

const [totalBps, depth, rewardBps] = web3.eth.abi.decodeParameters([
  'uint16',
  'uint8',
  'uint16[8]'
], result);

console.log('Total proximity allocation:', totalBps / 100, '%');
console.log('Depth levels:', depth);
console.log('Per-level BPS:', rewardBps.map(bps => bps / 100 + '%'));

tuple

uint16

Total proximity allocation in basis points (e.g., 3000 = 30%)

uint8

Number of proximity levels (8)

uint16[8]

Per-level distribution in basis points

Using Web3 Libraries

ethers.js
viem

const { ethers } = require('ethers');

const provider = new ethers.JsonRpcProvider('https://rpc.fene.app');

// Get ABI (once)
const abiResponse = await provider.send('fenine_getSystemContractABI', []);
const abi = JSON.parse(abiResponse);

// Create contract instance
const systemContract = new ethers.Contract(
  '0x0000000000000000000000000000000000001000',
  abi,
  provider
);

// Query methods
const validators = await systemContract.getActiveValidators();
const totalStake = await systemContract.totalNetworkStake();
const epoch = await systemContract.getCurrentEpoch();

console.log('Active validators:', validators.length);
console.log('Total stake:', ethers.formatEther(totalStake), 'FEN');
console.log('Current epoch:', epoch.toString());

import { createPublicClient, http } from 'viem';
import { fenineNetwork } from './chains'; // Define your chain

const client = createPublicClient({
  chain: fenineNetwork,
  transport: http('https://rpc.fene.app')
});

// Read from contract
const validators = await client.readContract({
  address: '0x0000000000000000000000000000000000001000',
  abi: systemContractABI,
  functionName: 'getActiveValidators'
});

const totalStake = await client.readContract({
  address: '0x0000000000000000000000000000000000001000',
  abi: systemContractABI,
  functionName: 'totalNetworkStake'
});

Function Selectors Reference

Function	Selector	Parameters
`getActiveValidators()`	`0x9de70258`	None
`getValidatorInfo(address)`	`0xb5d89627`	address
`getDelegatorInfo(address,address)`	`0xa993683f`	address, address
`totalNetworkStake()`	`0x635c8637`	None
`getCurrentEpoch()`	-	None
`getProximityConfig()`	-	None

For a complete list of function selectors, see the Quick Reference page.

Next Steps

Smart Contract Reference

Full FenineSystem contract documentation

Quick Reference

Common queries and selectors

Overview

RPC Endpoints

Smart Contracts

Overview

System Contract Queries

Query Pattern

Validator Queries

getActiveValidators()

getValidatorInfo(address)

getValidatorStakers(address)

Delegator Queries

getDelegatorInfo(address delegator, address validator)

getEstimatedDelegatorReward(address delegator, address validator)

Network State Queries

totalNetworkStake()

getCurrentEpoch()

getNextEpochReward()

Proximity Configuration

getProximityConfig()

Using Web3 Libraries

Function Selectors Reference

Next Steps

Smart Contract Reference

Quick Reference

​Overview

​System Contract Queries

​Query Pattern

​Validator Queries

​getActiveValidators()

​getValidatorInfo(address)

​getValidatorStakers(address)

​Delegator Queries

​getDelegatorInfo(address delegator, address validator)

​getEstimatedDelegatorReward(address delegator, address validator)

​Network State Queries

​totalNetworkStake()

​getCurrentEpoch()

​getNextEpochReward()

​Proximity Configuration

​getProximityConfig()

​Using Web3 Libraries

​Function Selectors Reference

​Next Steps

Smart Contract Reference

Quick Reference

Overview

System Contract Queries

Query Pattern

Validator Queries

getActiveValidators()

getValidatorInfo(address)

getValidatorStakers(address)

Delegator Queries

getDelegatorInfo(address delegator, address validator)

getEstimatedDelegatorReward(address delegator, address validator)

Network State Queries

totalNetworkStake()

getCurrentEpoch()

getNextEpochReward()

Proximity Configuration

getProximityConfig()

Using Web3 Libraries

Function Selectors Reference

Next Steps