Introduction to Chain Integration

💡

The Axelar Virtual Machine (AVM) and Amplifier are currently under active development, so these instructions are likely to change. Please check back frequently for updates.

There are several components to build to integrate a chain into Amplifier. The main components to make the chain operational include:

building Amplifier contracts
building gateway contracts on the connected chain
building a relayer to send messages to/from the connected chain
establishing a verifier set
Additionally, Interop Labs exposes a set of API/SDK services that, with some configuration, will support your chain as well

A table of the major components are as follows:

Category	Component	Description	Links
Amplifier Contracts	Chain-specific Amplifier contracts: Gateway, Verifier, Prover	There are three contracts you need to adapt: the Verifier Contract, the Gateway Contract, and the Multisig Prover Contract. It is up to the integrator to determine how to best utilize the reference contracts, whether that may be by using the reference contracts we expose as is, maintaining a fork, or something else.	TBD - to eventual replace with an INTEGRATION.md file that lives in the axelar-amplifier repo Multisig Prover, Gateway, Voting Verifier
	Internal Contracts on Axelar: Coordinator, Multisig, Router, Service Registry, Rewards, Governance	These contracts are global to the protocol and provide a stable API to integrators. Integrators should not develop or fork any of the protocol contracts. If there are any changes that need to be made to these contracts (e.g. such as the addition of a new signature scheme that needs to be added to the multisig contract, or message ID validation in the router contract, for example), integrators should expect to coordinate with the Interop Labs team to incorporate those changes.	TBD - to eventual replace with an INTEGRATION.md file that lives in the axelar-amplifier repo Coordinator, Multisig, Rewards, Router, Service Registry, Rewards
	ampd	Ampd is the off-chain daemon responsible for voting and signing within the amplifier protocol. The daemon listens to the Axelar blockchain for specific events, connects to external blockchains via JSON-RPC, and uses tofnd for signing transactions and batches of messages If a chain does not conform to standard EVM compatibility, a pull request should be made to the Amplifier repo with a new module for that chain. In the future, Interop Labs will expose a plugin architecture to replace the current mechanism - details TBD.	ampd readme
External Chain Contracts	Source Chain Gateway Contract	A smart contract implementing the Cross-Chain Gateway Protocol. For EVM chains, the EVM Gateway can be reused.	Cross-Chain Gateway Protocol specifications, Amplifier Gateway Integration
	Governance Contract	A source chain contract to receive governance-related messages from Axelar, such as updates to your gateway.	Sample governance contracts
	Gas Service Contract	TBD	TBD
	ITS	ITS	TBD
	Squid	Squid	Squid Router contract requirements
Relaying	Relayer API components (sentinel, listener, relayer)	Relayer API components (sentinel, listener, relayer)	Automated relaying architecture TBD - Example utilization
	GMP data collection	By leveraging the Relayer API above, GMP events for all transactions are automatically sent to our indexers. More information on the schema of the GMP data and all event types are listed here.	TBD - need to flesh out docs on the schema that is produced here
	Gas reconciliation and tracking	TBD - but this section should go over the accounting of gas payments by users, refunds for overpayments issues by the Relayer API, and the settlement mechanism of discrepancies with accounting
Verifiers	Instantiate verifier set to support the Amplifier chain (fund rewards, etc)	[TBU] Today, there is a global set of 30 verifiers ready to support a new chain connection. A new connection will need to coordiate with the verifier set to fund rewards pools and have them initiate chain connections	TBD
Additional Services	Axelarscan APIs (GMP fee estimation, GMP transaction queries)	For all supported chains on Axelar, Interop Labs exposes a number of query APIs, such as gas fee estimations, GMP transaction statuses, etc. With some input from you, your chain can be supported as well.	Axelarscan API documentation, TBD - to eventually replace with an INTEGRATION.md file that walk through CLI process in this repo for adding a chain. This will primarily include basic chain properties, gas assumptions, deployed contract addresses Sample chain config
	Axelarscan UI (static chain info, verifier performance, GMP data)	Once the above config is approved for the Axelarscan APIs, the new chain should appear on Axelarscan UI out of the box!
	AxelarJS SDK Support	The AxelarJS SDK is a Javascript wrapper for several helpful utility functions to the Axelar network, including transaction recovery, querying fee estimations, etc. Interop Labs will develop a plugin for you to adapt your chain into these SDKs, expected to be available in Q4	TBD
Operations & Monitoring	Standardized deployment scripts for CICD	Standardized deployment scripts for CICD	TBD
	Monitoring for smart contracts (rate limits, large transfers, rotations, etc)	Monitoring for smart contracts (rate limits, large transfers, rotations, etc)	TBD
	Monitoring for relaying robustness (missed transactions, recovery, etc)	Monitoring for relaying robustness (missed transactions, recovery, etc)	TBD
	(If using Axelar governance) coordinated governance for upgrades	(If using Axelar governance) coordinated governance for upgrades	TBD
	Update global chains config	Update global chains config	TBD
Testing	Deployment scripts for chains to play well with e2e testing	Deployment scripts for chains to play well with e2e testing	TBD
Testing	GMP tests to/from chain	GMP tests to/from chain	TBD

[TBD - consider moving to component-specific repos] Integration Architecture

To connect your chain to the Axelar network via the Interchain Amplifier, you’ll need to build or instantiate 4 smart contracts and 1 relayer service.

Source Chain Gateway Contract
- Built using the tech stack of your chain, you’ll need to deploy a smart contract implementing the Cross-Chain Gateway Protocol.
- For EVM chains, you can re-use the existing EVM Gateway.
- This contract serves as the primary API for developers sending messages from your chain.
Verifier Contract
- A smart contract on the Axelar network that verifies the validity of transactions on your chain.
- Most integrators will begin by using or customizing a Voting Verifier or can be customized to your needs for cases such as verification via ZK Proof.
- If you deploy a Voting Verifier, verifiers will need to support your chain and vote on the truth of source chain transactions.
Gateway Contract
- A gateway contract that exists on the Axelar network that will know how to use your verifier contract to check the validity of a transaction and then knows how to forward transactions onto the Amplifier router.
- Most integrators will begin by using or customizing this Gateway Contract.
Prover Contract
- A smart contract on the Axelar network that knows how to prove the validity of a transaction on your chain.
- Most integrators will begin by using or customizing the multisig prover
Message Relayer
- A service built with any tech stack that listens for events on your chain and relays them to the Axelar network.
- Get started with our Message Relayer Example
- Setup your relayer to send data to the Axelarscan API (TBD) related to transactions with your network
Governance Contract
- A source chain contract that can receive messages from the Axelar Network representing governance decisions, such as updating your gateway.
Gas Table Updater
- A service that updates the gas table, so that gas price estimations involving your chain are accurate.

The chain integration tutorial will guide you through this process within the current Amplifier DevNet. Contract deployment on Testnet or Mainnet will require governance proposal.

[TBD - consider moving to component-specific repos] Integration Process

Most integrators will follow the following process:

Learn & Understand Amplifier
- Follow the chain integration tutorial to deploy standardize contracts to the DevNet to understand the tools and basics of the process.
Customize and Deploy to DevNet
- Build (or instantiate or customize) each of the required contracts and the relayer.
- You may choose to change the logic of your verifier contract (for ZK use cases for example) or prover contract.
Whitelist contracts
- For the DevNet use the form to ask to be whitelisted
Become a verifier for your chain.
- To test your chain, you will need active verifiers to vote on messages from your chain
Test your integration
- Make sure you can send and receive messages on your chain.
Begin audit process
- You should audit your on-chain contracts.
Propose to Testnet
- Make on-chain proposals on the testnet to create your CosmWasm smart contracts.
  1. Proposal to store your CosmWasm code.
  2. Proposal to instantiate your contracts.
- Make an on-chain proposal to add your chain to the Amplifier router.
Test in Testnet
- Ensure your contracts are working as expected.
- Verify with developers that they can send messages to and from your chain.
Productionize your relayer
- Ensure your relayer is robust, fault-tolerant, and can handle the load of your chain.
Propose to Mainnet
- Make on-chain proposals on Mainnet to create your CosmWasm smart contracts.
  1. Proposal to store your CosmWasm code.
  2. Proposal to instantiate your contracts.
- Make an on-chain proposal to add your chain to the Amplifier router.

Edit this page