Become an Amplifier Verifier

💡

Amplifier is under active development, so these instructions are likely to change. Please check back frequently for updates.

By running a verifier for a chain integration with Axelar's Amplifier, you will be responsible for voting on the validity of transactions on the Axelar network and signing command batches for a given chain.

Architecture

Running a verifier requires three components:

tofnd - threshold signing service
ampd - core daemon that subscribes to Axelar chain events and exposes a gRPC server
One handler binary per chain you want to support (e.g. evm-handler, solana-handler)

                    ┌───────────────────────────────────┐
                    │          Axelar Node              │
                    │  (JSON-RPC :26657, gRPC :9090)    │
                    └──────────────┬────────────────────┘
                                   │
                    ┌──────────────▼─────────────────────┐
┌────────┐          │            ampd                    │
│ tofnd  │◄─────────│  - subscribes to chain events      │
│ :50051 │          │  - broadcasts transactions         │
└────────┘          │  - gRPC server for handlers :9090  │
                    └───────────────┬────────────────────┘
                                    │ gRPC
              ┌────────────┬────────┼───────┬────────────┐
              │            │        │       │            │
          ┌───▼───┐   ┌────▼───┐ ┌──▼────┐ ┌──▼────┐ ┌───▼───┐
          │  evm  │   │ solana │ │  sui  │ │stellar│ │ xrpl  │
          │handler│   │handler │ │handler│ │handler│ │handler│
          └───────┘   └────────┘ └───────┘ └───────┘ └───────┘
              │            │         │         │          │
          EVM RPC       Solana   Sui RPC   Stellar   XRPL RPC
                          RPC                RPC

Handlers are separate processes that connect to ampd's gRPC server. If a handler crashes, it does not affect ampd or other handlers.

💡

Run tofnd, ampd and the handlers on the same host, and keep ampd's gRPC server on 127.0.0.1 (the default, and the value in the config examples below). The gRPC API has no authentication: exposing it on 0.0.0.0 or a public interface would let anyone who can reach it sign and broadcast transactions through your verifier. The same goes for tofnd's port.

There are three ways to set up and run a verifier:

Option 1: Source -- Clone and build directly from the GitHub source code.
Option 2: Binaries -- Download prebuilt binaries from the GitHub releases page.
Option 3: Docker -- Use Docker to run tofnd, ampd, and handlers.

Set up `tofnd`

ampd needs access to a locally running tofnd instance in order to onboard as a verifier or run the daemon. See the tofnd repository for more information.

Install tofnd from source by cloning and building the tofnd repository.

git clone git@github.com:axelarnetwork/tofnd.git --recursive
cd tofnd
cargo build --release --locked

This will create a binary in the target/release directory. You can move this binary to a location in your PATH or run it directly from the target/release directory.

Create a default mnemonic and configuration in ~/.tofnd/, then back it up and delete it.

tofnd -m create
mv ~/.tofnd/export ~/.tofnd/export-new-location

Now run tofnd.

tofnd

Download the tofnd binary depending on the type of machine you have:

Linux: tofnd-linux-amd64-v1.0.1
Apple Mac (AMD64 or ARM): tofnd-darwin-amd64-v1.0.1

Create a default mnemonic and configuration in ~/.tofnd/, then back it up and delete it.

~/Downloads/tofnd*-v1.0.1 -m create
mv ~/.tofnd/export ~/.tofnd/export-new-location

Now run tofnd.

tofnd

Pull and run the latest version of tofnd from Docker:

docker pull axelarnet/tofnd:v1.0.1
docker run -p 127.0.0.1:50051:50051 --env MNEMONIC_CMD=auto --env NOPASSWORD=true --env ADDRESS=0.0.0.0 -v tofnd:/.tofnd axelarnet/tofnd:v1.0.1

Leave this process running in the background, and perform additional commands in a new terminal window or shell.

💡

Note: If you are running a validator as well, you should use a different node for your verifier (the Axelar node that ampd connects to) on both testnet and mainnet than the one being run for your validator node to prevent loss of rewards in case the verifier fails. This node can use the everything pruning config to reduce resource use.

💡

Note: You also must run different tofnd instances for vald (for your validator) and ampd (for your verifier). You cannot use the same tofnd instance for both.

Set up `ampd`

Install ampd from source by cloning and building the axelar-amplifier repository.

cargo build --release -p ampd

Download the ampd binary depending on the type of machine you have:

Linux: ampd-linux-amd64-v1.14.2
Apple Silicon Mac: ampd-darwin-arm64-v1.14.2

From Docker, pull and run the 1.14.2 version of ampd:

docker pull axelarnet/axelar-ampd:v1.14.2
# mount your config and state directory, and expose the gRPC port for handlers
docker run -p 127.0.0.1:9090:9090 -v ~/.ampd:/home/axelard/.ampd axelarnet/axelar-ampd:v1.14.2

💡

The address for your verifier node will also be the address that rewards are sent to (this will change in the future). You should make sure to claim and move any available rewards regularly to mitigate any associated risks.

Add `ampd` to your `PATH`

If you downloaded the binary, make it executable and link it into your PATH (skip this if you built from source or use Docker):

chmod a+x ~/Downloads/ampd-*-v1.14.2
sudo ln -s ~/Downloads/ampd-*-v1.14.2 /usr/local/bin/ampd

Run ampd --version to check it; it should print 1.14.2.

Configure `ampd`

Create an ampd configuration file at ~/.ampd/config.toml.

This configuration file tells ampd how to connect to your local tofnd, how to talk to the Axelar network, and which chains to support via the gRPC server that handlers connect to.

tm_jsonrpc="http://devnet-amplifier.axelar.dev:26657"
tm_grpc="tcp://devnet-amplifier.axelar.dev:9090"

[service_registry]
cosmwasm_contract="axelar1c9fkszt5lq34vvvlat3fxj6yv7ejtqapz04e97vtc9m5z9cwnamq8zjlhz"

[broadcast]
chain_id="devnet-amplifier"
gas_price="0.007uaxl"
tx_fetch_interval="1000ms"
tx_fetch_max_retries="15"
gas_adjustment=1.2
batch_gas_limit="20000000"
queue_cap=1000
broadcast_interval="1s"
tx_confirmation_buffer_size="10"
tx_confirmation_queue_cap="1000"

[tofnd_config]
key_uid="axelar"
party_uid="ampd"
url="http://127.0.0.1:50051"
timeout="3s"

[grpc]
ip_addr="127.0.0.1"
port=9090
global_concurrency_limit=1024
concurrency_limit_per_connection=32
request_timeout="30s"

# Add a [[grpc.blockchain_service.chains]] entry for each chain you support.
# Contract addresses for devnet can be found at:
# https://github.com/axelarnetwork/axelar-contract-deployments/blob/main/axelar-chains-config/info/devnet-amplifier.json

[[grpc.blockchain_service.chains]]
chain_name="ethereum-sepolia"
voting_verifier="axelar1e6jnuljng6aljk0tjct6f0hl9tye6l0n9p067pwx2374h82dmr0s9qcqy9"
multisig_prover="axelar1g0ufaefvqkfvhxacsns63s3p8raf9a0k8agg3r4tfhx3k6gcz0dq0ynmcx"
multisig="axelar19jxy26z0qnnspa45y5nru0l5rmy9d637z5km2ndjxthfxf5qaswst9290r"

[[grpc.blockchain_service.chains]]
chain_name="avalanche"
voting_verifier="axelar1ty7mx0cllgz8xuvhn2j7e3qy8999ssgmjtktyqetl335em0g88lq6rjhl2"
multisig_prover="axelar1e3uxqmkxfxkk3qk2aqfnsc7uk2ld57r37t6p33v8xlzw7ptfz34s3xu7w6"
multisig="axelar19jxy26z0qnnspa45y5nru0l5rmy9d637z5km2ndjxthfxf5qaswst9290r"

# replace with your Axelar testnet node
tm_jsonrpc="http://127.0.0.1:26657"
tm_grpc="tcp://127.0.0.1:9090"

[service_registry]
cosmwasm_contract="axelar1rpj2jjrv3vpugx9ake9kgk3s2kgwt0y60wtkmcgfml5m3et0mrls6nct9m"

[broadcast]
chain_id="axelar-testnet-lisbon-3"
gas_price="0.007uaxl"
tx_fetch_interval="1000ms"
tx_fetch_max_retries="15"
gas_adjustment=1.2
batch_gas_limit="20000000"
queue_cap=1000
broadcast_interval="1s"
tx_confirmation_buffer_size="10"
tx_confirmation_queue_cap="1000"

[tofnd_config]
key_uid="axelar"
party_uid="ampd"
url="http://127.0.0.1:50051"
timeout="3s"

[grpc]
ip_addr="127.0.0.1"
port=9090
global_concurrency_limit=1024
concurrency_limit_per_connection=32
request_timeout="30s"

# Add a [[grpc.blockchain_service.chains]] entry for each chain you support.
# Contract addresses can be found at:
# https://github.com/axelarnetwork/axelar-contract-deployments/blob/main/axelar-chains-config/info/testnet.json

[[grpc.blockchain_service.chains]]
chain_name="xrpl-evm"
voting_verifier="axelar1q8kn9t39ddpce42atk0d6wpdudr6djqxmz689m3nxy92ck0nnftqxfsuyk"
multisig_prover="axelar198xehj5htckk75s8wcamxerxtdc45669zdqjmr69guveqntj9f6s5rqq55"
multisig="axelar14a4ar5jh7ue4wg28jwsspf23r8k68j7g5d6d3fsttrhp42ajn4xq6zayy5"

[[grpc.blockchain_service.chains]]
chain_name="sui"
voting_verifier="axelar1sykyha8kzf35kc5hplqk76kdufntjn6w45ntwlevwxp74dqr3rvsq7fazh"
multisig_prover="axelar1v8jrupu2rqpskwgtr69max0ajul92q8z5mdxd505m2hu3xc5jzcqm8zyc6"
multisig="axelar14a4ar5jh7ue4wg28jwsspf23r8k68j7g5d6d3fsttrhp42ajn4xq6zayy5"

[[grpc.blockchain_service.chains]]
chain_name="stellar-2026-q1-2"
voting_verifier="axelar1wmwnuj0609q5sd6xfl9xvptcprsas6vr95z2kxjsnanc7suchntqgk3flu"
multisig_prover="axelar14xy6t4gnl26jxe3z2lqk24nnu3q0f7khlrpns9d00q9dvaqjzqmqp93ahp"
multisig="axelar14a4ar5jh7ue4wg28jwsspf23r8k68j7g5d6d3fsttrhp42ajn4xq6zayy5"

# Continue adding for each supported chain.
# See the ampd v1.14.2 release guide for a full list of testnet chain entries:
# https://github.com/axelarnetwork/axelar-contract-deployments/blob/main/releases/ampd/2025-12-19-ampd-v1.14.2.md

# replace with your Axelar mainnet node
tm_jsonrpc="http://127.0.0.1:26657"
tm_grpc="tcp://127.0.0.1:9090"

[service_registry]
cosmwasm_contract="axelar1rpj2jjrv3vpugx9ake9kgk3s2kgwt0y60wtkmcgfml5m3et0mrls6nct9m"

[broadcast]
chain_id="axelar-dojo-1"
gas_price="0.007uaxl"
tx_fetch_interval="1000ms"
tx_fetch_max_retries="15"
gas_adjustment=1.2
batch_gas_limit="20000000"
queue_cap=1000
broadcast_interval="1s"
tx_confirmation_buffer_size="10"
tx_confirmation_queue_cap="1000"

[tofnd_config]
key_uid="axelar"
party_uid="ampd"
url="http://127.0.0.1:50051"
timeout="3s"

[grpc]
ip_addr="127.0.0.1"
port=9090
global_concurrency_limit=1024
concurrency_limit_per_connection=32
request_timeout="30s"

# Add a [[grpc.blockchain_service.chains]] entry for each chain you support.
# Contract addresses can be found at:
# https://github.com/axelarnetwork/axelar-contract-deployments/blob/main/axelar-chains-config/info/mainnet.json

[[grpc.blockchain_service.chains]]
chain_name="xrpl-evm"
voting_verifier="axelar1q8kn9t39ddpce42atk0d6wpdudr6djqxmz689m3nxy92ck0nnftqxfsuyk"
multisig_prover="axelar198xehj5htckk75s8wcamxerxtdc45669zdqjmr69guveqntj9f6s5rqq55"
multisig="axelar14a4ar5jh7ue4wg28jwsspf23r8k68j7g5d6d3fsttrhp42ajn4xq6zayy5"

[[grpc.blockchain_service.chains]]
chain_name="sui"
voting_verifier="axelar1sykyha8kzf35kc5hplqk76kdufntjn6w45ntwlevwxp74dqr3rvsq7fazh"
multisig_prover="axelar1v8jrupu2rqpskwgtr69max0ajul92q8z5mdxd505m2hu3xc5jzcqm8zyc6"
multisig="axelar14a4ar5jh7ue4wg28jwsspf23r8k68j7g5d6d3fsttrhp42ajn4xq6zayy5"

[[grpc.blockchain_service.chains]]
chain_name="stellar"
voting_verifier="axelar1dalnx2yvmu3g3aau8m7fj426fk9u8dnzlr5azvqmr4x82rtclats8lhjmu"
multisig_prover="axelar1wdgp5xyqjyv5zsq86n6pah2lsmd46mn0gt4055mvvk6mezn9skqs6p93dg"
multisig="axelar14a4ar5jh7ue4wg28jwsspf23r8k68j7g5d6d3fsttrhp42ajn4xq6zayy5"

# Continue adding for each supported chain.
# See the ampd v1.14.2 release guide for a full list of mainnet chain entries:
# https://github.com/axelarnetwork/axelar-contract-deployments/blob/main/releases/ampd/2025-12-19-ampd-v1.14.2.md

See the ampd README for the full config reference, including every [broadcast] field (if you include a section, all of its fields are required), configuring through AMPD_* environment variables, and the optional monitoring server. Contract addresses for all chains can be found in the axelar-contract-deployments repository.

💡

If you get a transport error with an ampd command, make sure that you have tofnd running in the background.

Set up handlers

Handlers are separate binaries that connect to ampd's gRPC server. Each handler requires a config directory with two files:

Base config (config.toml) - ampd connection and chain name
Chain-specific config - RPC URL and chain-specific parameters

Binary	Chains	Docker Image
`evm-handler`	Hedera, Monad, Hyperliquid, XRPL EVM, etc.	`axelarnet/axelar-ampd-evm-handler`
`solana-handler`	Solana	`axelarnet/axelar-ampd-solana-handler`
`sui-handler`	Sui	`axelarnet/axelar-ampd-sui-handler`
`stellar-handler`	Stellar	`axelarnet/axelar-ampd-stellar-handler`
`xrpl-handler`	XRPL	`axelarnet/axelar-ampd-xrpl-handler`

Prebuilt binaries are available on the GitHub Releases page. Handler releases are tagged as <handler>-v* (e.g. sui-handler-v0.2.1), and each handler has its own version: use the latest release of each. The Sui handler needs v0.2.0 or later, the first to use the Sui gRPC API that the config below points to.

Directory structure

Create a config directory per chain handler:

~/.ampd/
├── config.toml              # ampd config (see above)
├── state.json               # ampd state (auto-created)
├── xrpl-evm/
│   ├── config.toml                 # base handler config
│   └── evm-handler-config.toml     # EVM-specific config
├── sui/
│   ├── config.toml                 # base handler config
│   └── sui-handler-config.toml     # Sui-specific config
├── stellar/
│   ├── config.toml                 # base handler config
│   └── stellar-handler-config.toml # Stellar-specific config
└── xrpl/
    ├── config.toml                 # base handler config
    └── xrpl-handler-config.toml    # XRPL-specific config

Base handler config

Each handler's config.toml contains:

ampd_url = "http://127.0.0.1:9090"
chain_name = "<chain_name>"  # must match a chain in ampd's grpc.blockchain_service.chains

Chain-specific configs

EVM (evm-handler-config.toml):

rpc_url = "<your_rpc_url>"
finalization = "RPCFinalizedBlock"  # or "ConfirmationHeight"

Sui (sui-handler-config.toml):

rpc_url = "<your_grpc_url>"  # gRPC endpoint of your Sui node

Stellar (stellar-handler-config.toml):

rpc_url = "<your_rpc_url>"

XRPL (xrpl-handler-config.toml):

rpc_url = "<your_rpc_url>"

Solana (solana-handler-config.toml):

rpc_url = "<your_rpc_url>"
gateway_address = "<gateway_address>"    # base58 pubkey of the Solana gateway
domain_separator = "<domain_separator>"  # hex, 32 bytes, from MultisigProver config

Run handlers

Start each handler, pointing to its config directory:

evm-handler --config-dir ~/.ampd/xrpl-evm/
sui-handler --config-dir ~/.ampd/sui/
stellar-handler --config-dir ~/.ampd/stellar/
xrpl-handler --config-dir ~/.ampd/xrpl/

For each handler, mount its config directory and run:

docker run -d \
  --name xrpl-evm-handler \
  --restart unless-stopped \
  -v ~/.ampd/xrpl-evm:/config \
  axelarnet/axelar-ampd-evm-handler:v0.1.6 \
  --config-dir /config

docker run -d \
  --name sui-handler \
  --restart unless-stopped \
  -v ~/.ampd/sui:/config \
  axelarnet/axelar-ampd-sui-handler:v0.2.1 \
  --config-dir /config

Replace the image tag and handler type as needed. Ensure handlers can reach ampd's gRPC server. If running all containers on the same machine, use a shared Docker network or --network host.

💡

Handler processes should be configured with automatic restart policies. The daemon can run without handlers connected, but handlers will crash if they cannot reach ampd. Both ampd and each handler should be orchestrated as separate services with auto-restart (e.g. Restart=always with systemd).

Fund your wallet

Prior to running the ampd daemon, you will need to set up your wallet with funds.

Determine your verifier address:
```
ampd verifier-address
```
💡
If you get a security warning while trying to run ampd on an Apple Silicon Mac, you can disable the gatekeeper for a single binary with sudo xattr -d com.apple.quarantine ~/Downloads/ampd-darwin-arm64-v1.14.2 or disable gatekeeper globally with sudo spctl --master-disable.
Fund your verifier address.
1. Fill out the Amplifier Verifier Onboarding Form for your address to be whitelisted or to receive funds.

Activate and run the verifier

Bond your verifier:
ampd bond-verifier validators 100 uamplifier
ampd bond-verifier amplifier 100000000000 uaxl
ampd bond-verifier amplifier 50000000000 uaxl
Bonded verifiers will stay bonded until they unbond or are removed by governance. The bond for testnet is 100000000000uaxl (100k AXL). The bond for mainnet is 50000000000uaxl (50k AXL).
Register your public keys. Register both ecdsa (used by the EVM chains, Solana, Sui and XRPL) and ed25519 (used by Stellar):
```
ampd register-public-key ecdsa
ampd register-public-key ed25519
```
Authorize your verifier.

This is dependent on the environment, and can be done via governance, or by the network operators. Wait until your verifier is authorized before registering chain support: the service registry rejects register-chain-support with Unauthorized for verifiers that aren't authorized yet.
Register support for desired chains, enabling ampd to participate in voting and signing for your supported chains.
ampd register-chain-support validators ethereum-sepolia ampd register-chain-support validators avalanche
ampd register-chain-support amplifier sui ampd register-chain-support amplifier stellar-2026-q1-2
ampd register-chain-support amplifier sui ampd register-chain-support amplifier stellar
The command takes a single chain (ampd register-chain-support [service name] [chain]), so run it once for each chain you want to support. Note that any chain you want to support here must have a corresponding [[grpc.blockchain_service.chains]] entry in your ampd config.toml and a running handler.
Run the ampd daemon.

Running ampd without any command will run the daemon. Then start your handler processes as described in Set up handlers.

Productionizing

As you move towards testnet and mainnet, you should switch to running your own full Axelar node and your own full node or light client for any chains you are voting on.

Help

For more info about the available commands and options, run:

ampd --help

Feedback

If you have any feedback or would like to report a bug, please open a ticket on Axelar Zendesk.

On this page