Verifier Rewards

Verifiers are responsible for securing transactions with chains connected to the Axelar Network via the Axelar Amplifier. Verifiers vote on the truthfulness of transactions posted to the network and create signatures for outgoing messages. In compensation for these activities and the associated decentralized node running costs, verifiers earn rewards provided by each chain integrator.

Rewards are calculated based on counted contributions. A contribution is counted whenever a poll ends based on the verifiers who voted, and when a verifier signs an event. Contributions are tracked in the verifier rewards contract.

Contributions are assessed per epoch (a length of time configured by governance). At the conclusion of an epoch, a message can be sent to the rewards contract to process rewards for the most recent window. Rewards are calculated based on a percentage of all traffic for a given chain and paid in AXL.

Voting flow

1. The relayer picks up a callContract() event and calls verify_messages() on the Axelar gateway.
2. The Axelar gateway calls verify_messages() on the voting verifier, which begins the voting process with the verifier set.
3. Once enough votes have been cast for the message, a record_participation() event is emitted to the rewards contract.
4. The rewards contract keeps a tally of how many events each verifier correctly participated in.

Signing flow

The destination chain uses the prover rather than the voting verifier to pass the message.

1. The multisig prover gets the messages and their contents from the gateway and calls start_signing_session() on the multisig contract, which begins the signing process with the verifier set.
2. Registered chains, who have their own sets of verifiers, become aware that there is a signing session for the chain they support with their public keys and start signing.
3. Once enough signatures have been gathered, a signed batch will be created and eventually relayed back to the source chain.
4. If a verifier signed during a certain grace period, the multisig contract emits a record_participation() event to the rewards contract.
5. The rewards contract keeps a tally of how many events each verifier correctly participated in.

Reward pools

Each integrated chain has two pools that must be funded independently. There is one rewards pool for signing and one pool for voting.

Reward pools are not tied to an epoch. If earned rewards are not claimed, they will continue to grow. If rewards are being earned but the pool has not been sufficiently funded, these rewards can be funded and claimed at a later date. Integrators should ensure that pools always have enough funds so that verifiers can get their rewards quickly.

Rewards calculation

Rewards are calculated through the following parameters, which are first configured during contract instantiation. These parameters can be modified through governance:

• epoch_duration — How often rewards are calculated, specified in number of blocks. For example, an epoch_duration of 500 blocks will reward verifiers for their participation in each 500-block window.
• rewards_per_epoch — The total number of tokens distributed as rewards per epoch, split equally amongst all participating verifiers for a given epoch. The same for both signing and voting.
• participation_threshold — The participation threshold that verifiers must meet to receive given rewards in a given epoch, specified as a fraction between 0 (exclusive) and 1 (exclusive). Verifiers must participate in at least this fraction of all events in a given epoch to receive rewards. Participation is reset at the beginning of each epoch, so participation in previous epochs does not affect rewards for future epochs.

Check the funds in a pool

Use rewards_pool() to check the funds in a pool:

REWARDS_CONTRACT_ADDRESS="axelar1vaj9sfzc3z0gpel90wu4ljutncutv0wuhvvwfsh30rqxq422z89qnd989l"
export CHAIN_NAME="fantom" export
VOTING_VERIFIER_OR_MULTISIG_CONTRACT_ADDRESS="axelar1ty7mx0cllgz8xuvhn2j7e3qy8999ssgmjtktyqetl335em0g88lq6rjhl2"
# or "axelar1g6520uhs8u37el40wqngf60z06mjgk6z7nezytd2mxrmh7yesnmsyc0zjw"
export RPC="http://devnet-amplifier.axelar.dev:26657"

REWARDS_CONTRACT_ADDRESS="axelar1harq5xe68lzl2kx4e5ch4k8840cgqnry567g0fgw7vt2atcuugrqfa7j5z"
export CHAIN_NAME="test-avalanche" export
VOTING_VERIFIER_OR_MULTISIG_CONTRACT_ADDRESS="axelar1hupk5du59cgu4ps5s637rhakwsq0060ycdp57j2ccevna7wqqzrqnfrr0p"#
or "axelar1l5k8wlzmkmtnvjvs9x77wdcfweucwgums9e8fh0d8cy76ymqc5aqzguqnn"
export RPC="https://tm.axelar-testnet.lava.build:443"

axelard q wasm contract-state smart $REWARDS_CONTRACT_ADDRESS \
    '{
        "rewards_pool":
            {
                "pool_id":
                    {
                        "chain_name":"'"$CHAIN_NAME"'",
                        "contract":"'"$VOTING_VERIFIER_OR_MULTISIG_CONTRACT_ADDRESS"'"
                    }
            }
    }' \
    --node $RPC

Distribute rewards

Use distribute_rewards() to distribute rewards from a pool:

export REWARDS_CONTRACT_ADDRESS="axelar1vaj9sfzc3z0gpel90wu4ljutncutv0wuhvvwfsh30rqxq422z89qnd989l"
export CHAIN_NAME="avalanche"
export VOTING_VERIFIER_OR_MULTISIG_CONTRACT_ADDRESS="axelar1elaymnd2epmfr498h2x9p2nezc4eklv95uv92u9csfs8wl75w7yqdc0h67" || "0x7eeE33A59Db27d762AA1Fa31b26efeE0dABa1132"
export RPC="http://devnet-amplifier.axelar.dev:26657"

export REWARDS_CONTRACT_ADDRESS="axelar1harq5xe68lzl2kx4e5ch4k8840cgqnry567g0fgw7vt2atcuugrqfa7j5z"
export CHAIN_NAME="test-avalanche"
export VOTING_VERIFIER_OR_MULTISIG_CONTRACT_ADDRESS="axelar1hupk5du59cgu4ps5s637rhakwsq0060ycdp57j2ccevna7wqqzrqnfrr0p" || "0x7eeE33A59Db27d762AA1Fa31b26efeE0dABa1132"
export RPC="https://tm.axelar-testnet.lava.build:443"

axelard tx wasm execute $REWARDS_CONTRACT_ADDRESS \
    '{
        "distribute_rewards":
            {
                "pool_id":
                    {
                        "chain_name":"'"$CHAIN_NAME"'",
                        "contract":"'"$VOTING_VERIFIER_OR_MULTISIG_CONTRACT_ADDRESS"'"
                    },
                "epoch_count":10
            }
    }' \
    --keyring-backend test \
    --from wallet \
    --gas auto --gas-adjustment 1.5 --gas-prices 0.007uamplifier \
    --node $RPC

Rewards are distributed to verifiers with a participation rate greater than the threshold as the epoch closes. Rewards are calculated based on the time passed since the last event and the total number of verifiers, and split equally amongst all participating verifiers in the epoch.

epoch_count is the maximum number of historical epochs for which to distribute rewards, starting with the oldest. If not specified, rewards will be distributed for the last 10 epochs.