# Become an Amplifier Verifier (https://docs.axelar.dev/infrastructure/verifiers/amplifier/verifier-onboarding)





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

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 [#architecture]

Running a verifier requires three components:

1. **tofnd** - threshold signing service
2. **ampd** - core daemon that subscribes to Axelar chain events and exposes a gRPC server
3. **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.

<Callout type="warning">
  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.
</Callout>

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](https://docs.docker.com/engine/install/) to run `tofnd`, `ampd`, and handlers.

## Set up `tofnd` [#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](https://github.com/axelarnetwork/tofnd) for more information.

<Tabs items="[&#x22;Source&#x22;,&#x22;Binary&#x22;,&#x22;Docker&#x22;]">
  <Tab value="Source">
    Install `tofnd` from source by cloning and building the [`tofnd` repository](https://github.com/axelarnetwork/tofnd).

    ```bash
    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.

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

    Now run tofnd.

    ```bash
    tofnd
    ```
  </Tab>

  <Tab value="Binary">
    Download the [`tofnd` binary](https://github.com/axelarnetwork/tofnd/releases) depending on the type of machine you have:

    * Linux: [`tofnd-linux-amd64-v1.0.1`](https://github.com/axelarnetwork/tofnd/releases/download/v1.0.1/tofnd-linux-amd64-v1.0.1)
    * Apple Mac (AMD64 or ARM): [`tofnd-darwin-amd64-v1.0.1`](https://github.com/axelarnetwork/tofnd/releases/download/v1.0.1/tofnd-darwin-amd64-v1.0.1)

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

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

    Now run tofnd.

    ```bash
    tofnd
    ```
  </Tab>

  <Tab value="Docker">
    Pull and run the latest version of `tofnd` from Docker:

    ```bash
    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
    ```
  </Tab>
</Tabs>

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

<Callout>
  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.
</Callout>

<Callout>
  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.
</Callout>

## Set up `ampd` [#set-up-ampd]

<Tabs items="[&#x22;Source&#x22;,&#x22;Binary&#x22;,&#x22;Docker&#x22;]">
  <Tab value="Source">
    Install `ampd` from source by cloning and building the [`axelar-amplifier`
    repository](https://github.com/axelarnetwork/axelar-amplifier).

    ```bash
    cargo build --release -p ampd
    ```
  </Tab>

  <Tab value="Binary">
    Download the [`ampd`
    binary](https://github.com/axelarnetwork/axelar-amplifier/releases/tag/ampd-v1.14.2)
    depending on the type of machine you have:

    * Linux:
      [`ampd-linux-amd64-v1.14.2`](https://github.com/axelarnetwork/axelar-amplifier/releases/download/ampd-v1.14.2/ampd-linux-amd64-v1.14.2)
    * Apple Silicon Mac:
      [`ampd-darwin-arm64-v1.14.2`](https://github.com/axelarnetwork/axelar-amplifier/releases/download/ampd-v1.14.2/ampd-darwin-arm64-v1.14.2)
  </Tab>

  <Tab value="Docker">
    From [Docker](https://hub.docker.com/r/axelarnet/axelar-ampd), pull and run the `1.14.2` version of `ampd`:

    ```bash
    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
    ```
  </Tab>
</Tabs>

<Callout>
  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.
</Callout>

## Add `ampd` to your `PATH` [#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):

```bash
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 {AMPD}.

## Configure `ampd` [#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.

<Tabs items="[&#x22;devnet-amplifier&#x22;,&#x22;testnet&#x22;,&#x22;mainnet&#x22;]">
  <Tab value="devnet-amplifier">
    ```toml
    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"
    ```
  </Tab>

  <Tab value="testnet">
    ```toml
    # 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
    ```
  </Tab>

  <Tab value="mainnet">
    ```toml
    # 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
    ```
  </Tab>
</Tabs>

See the [`ampd` README](https://github.com/axelarnetwork/axelar-amplifier/blob/main/ampd/README.md) 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](https://github.com/axelarnetwork/axelar-contract-deployments/tree/main/axelar-chains-config/info).

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

## Set up handlers [#set-up-handlers]

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

1. **Base config** (`config.toml`) - ampd connection and chain name
2. **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](https://github.com/axelarnetwork/axelar-amplifier/releases). 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 [#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 [#base-handler-config]

Each handler's `config.toml` contains:

```toml
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 [#chain-specific-configs]

**EVM** (`evm-handler-config.toml`):

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

**Sui** (`sui-handler-config.toml`):

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

**Stellar** (`stellar-handler-config.toml`):

```toml
rpc_url = "<your_rpc_url>"
```

**XRPL** (`xrpl-handler-config.toml`):

```toml
rpc_url = "<your_rpc_url>"
```

**Solana** (`solana-handler-config.toml`):

```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 [#run-handlers]

<Tabs items="[&#x22;Binary&#x22;,&#x22;Docker&#x22;]">
  <Tab value="Binary">
    Start each handler, pointing to its config directory:

    ```bash
    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/
    ```
  </Tab>

  <Tab value="Docker">
    For each handler, mount its config directory and run:

    ```bash
    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
    ```

    ```bash
    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`.
  </Tab>
</Tabs>

<Callout>
  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).
</Callout>

## Fund your wallet [#fund-your-wallet]

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

1. Determine your verifier address:

   ```bash
   ampd verifier-address
   ```

   <Callout>
     If you get a security warning while trying to run `ampd` on an Apple
     Silicon Mac, you can disable the
     [gatekeeper](https://support.apple.com/guide/security/gatekeeper-and-runtime-protection-sec5599b66df/web)
     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`.
   </Callout>

2. Fund your verifier address.

   1. Fill out the [Amplifier Verifier Onboarding Form](https://docs.google.com/forms/d/e/1FAIpQLSfQQhk292yT9j8sJF5ARRIE8PpI3LjuFc8rr7xZW7posSLtJA/viewform) for your address to be whitelisted or to receive funds.

## Activate and run the verifier [#activate-and-run-the-verifier]

1. Bond your verifier:

   <Tabs items="[&#x22;devnet-amplifier&#x22;,&#x22;testnet&#x22;,&#x22;mainnet&#x22;]">
     <Tab value="devnet-amplifier">
       ```bash
       ampd bond-verifier validators 100 uamplifier
       ```
     </Tab>

     <Tab value="testnet">
       ```bash
       ampd bond-verifier amplifier 100000000000 uaxl
       ```
     </Tab>

     <Tab value="mainnet">
       ```bash
       ampd bond-verifier amplifier 50000000000 uaxl
       ```
     </Tab>
   </Tabs>

   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).

2. Register your public keys. Register both `ecdsa` (used by the EVM chains, Solana, Sui and XRPL) and `ed25519` (used by Stellar):

   ```bash
   ampd register-public-key ecdsa
   ampd register-public-key ed25519
   ```

3. 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.

4. Register support for desired chains, enabling `ampd` to participate in voting and signing for your supported chains.

   <Tabs items="[&#x22;devnet&#x22;,&#x22;testnet&#x22;,&#x22;mainnet&#x22;]">
     <Tab value="devnet">
       ```bash
       ampd register-chain-support validators ethereum-sepolia
       ampd register-chain-support validators avalanche
       ```
     </Tab>

     <Tab value="testnet">
       ```bash
       ampd register-chain-support amplifier sui
       ampd register-chain-support amplifier stellar-2026-q1-2
       ```
     </Tab>

     <Tab value="mainnet">
       ```bash
       ampd register-chain-support amplifier sui
       ampd register-chain-support amplifier stellar
       ```
     </Tab>
   </Tabs>

   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.

5. Run the `ampd` daemon.

   Running `ampd` without any command will run the daemon. Then start your handler processes as described in [Set up handlers](#set-up-handlers).

## Productionizing [#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 [#help]

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

```bash
ampd --help
```

## Feedback [#feedback]

If you have any feedback or would like to report a bug, please open a ticket on [Axelar Zendesk](https://axelar.zendesk.com/).


---

All pages of these docs, as Markdown: https://docs.axelar.dev/llms.txt