Set up an ICS-20 route to Injective Testnet, deliver an asset to a Solidity contract, and verify the result on both chains.

Injective Core v1.21 adds two ways for the EVM to work with standard ICS-20 transfers. An incoming packet can credit an Injective account and call a Solidity contract through an EVM hook. In the other direction, an EVM account or contract can send a transfer through the IBC precompile at 0x69. Both use Injective’s native bank balances through the MultiVM Token Standard (MTS).

If you operate a partner chain, start with an inbound transfer from your testnet to Injective Testnet. The sender submits a standard ICS-20 transfer on your chain, and your relayer delivers the packet and returns the acknowledgement. Use the IBC precompile demo for commands, Solidity contracts, and packet queries. The IBC precompile reference covers the interface and protocol behavior.

How an inbound transfer reaches the EVM

The packet receiver gets the funds, and the memo specifies which contract runs the hook. To have the same contract receive the funds and run the hook, use its Injective bech32 address as the packet receiver and its EVM hex address as the memo target.

1. Establish a route between the two testnets

Injective Testnet uses native chain ID injective-888 for IBC and EVM chain ID 1439 for deploying and inspecting contracts. Start with the Testnet Chain Portal for RPCs, faucets, and explorers.

If you already have a route, verify that the client on your chain tracks injective-888 and that the client on Injective tracks your current testnet chain ID. Both clients should be Active. Both channel ends should report STATE_OPEN, use transfer and ics20-1, and point back to each other. Check for recent packet delivery and acknowledgement on this exact route. An open channel can still have expired clients or no relayer. Client and channel verification queries

If you need a new route, configure your relayer with both testnets’ native endpoints, chain IDs, and funded relay accounts. For a compatible CometBFT counterparty, use a Tendermint light client on each chain to track the other. Reuse an open connection backed by active clients if one exists. Otherwise, establish the clients and connection before opening an unordered channel with port transfer on both sides and version ics20-1. Keep client updates and packet relaying running in both directions so acknowledgements and timeouts can be processed as well as deliveries. Hermes channel setup

Record the client, connection, and channel IDs for both ends. When sending to Injective, use the channel ID on your chain. The hook receives the corresponding Injective channel ID.

2. Verify the asset with a plain transfer

Send a small ICS-20 transfer without a hook memo and confirm the acknowledgement and credited balance. This establishes that the route works and identifies the exact bank denom received on Injective. A token new to Injective typically arrives as an ibc/… voucher. Its denom depends on the transfer path, so look up the received denom rather than relying on the token symbol.

Before using the hook with a voucher, confirm that this exact denom has an MTS ERC20 pair on Injective. Pair creation for IBC vouchers is permissionless. Returning native INJ along the original route is another option for an initial hook test, since native INJ resolves to the zero address. MultiVM Token Standard guide · Pairing reference

3. Deliver a packet that calls your contract

Deploy the demo receiver or your own hook contract on Injective Testnet EVM. From your chain, send an ICS-20 transfer using a client that can set the packet memo. The memo’s evm object specifies the hook contract’s hex address, a hex encoded payload, and a positive gas limit. If the contract should hold the funds, use its Injective bech32 address as the packet receiver and its EVM hex address as the memo’s contract target. The receiver holds the funds when the hook runs. Inbound hook walkthrough · Address conversion

The contract should verify that the immediate caller of onIBCTransfer is the system address 0x0000000000000000000000000000000000000069. If your application only accepts a particular route, validate the Injective destination channel as well. Treat packetSender as packet data rather than proof of identity. Hook contract requirements

4. Confirm delivery, execution, and refunds

Record the source transaction hash, both channel IDs, and the packet sequence from send_packet. On Injective, verify the receiver balance and the native injective.evm.v1.EventIBCHookCall event in the relay transaction. Check that a success acknowledgement was written on Injective and processed on your chain. Synthetic EVM receipts and logs are available when your RPC provider runs a compatible EVM gateway and has event virtualization enabled. Observing hook calls

Repeat with a hook that intentionally reverts. The Injective credit should roll back, and the original sender should recover the tokens after the error acknowledgement is relayed and processed. If the destination relay transaction itself runs out of gas, no acknowledgement is written and the relayer can retry with a larger transaction gas limit. Distinguish that case from a hook failure that produces an error acknowledgement.

If your integration also sends from Injective, follow the demo’s outbound section. The immediate caller of 0x69 funds the transfer and receives any refund. A returned sequence confirms dispatch. Track the acknowledgement or timeout separately. Outbound contract example

Forwarding native USDC from CCTP to IBC

The IBC precompile lets a bridge combine two operations in one Injective EVM transaction. A forwarder can submit a Circle CCTP V2 attestation with receiveMessage, then call transfer at 0x69 once the minted USDC is in the calling contract’s balance. If the enclosing transaction reverts, both the Injective mint and packet dispatch roll back. A relayer delivers the packet afterward and returns the acknowledgement. Ethereum Sepolia → Injective Testnet is one way to exercise the mint step with Circle’s Iris sandbox. USDC and CCTP guide

For bridge and wallet teams. If a user already holds native USDC on Injective, an ICS-20 send over the destination’s supported channel is enough. Use CCTP first when funds start on another supported chain. A forwarder is useful when you want that mint and IBC send to happen together. Budget for attestation, signing, and relay delays when you set the timeout. Outbound contract demo

For chains accepting Injective USDC. Confirm the accepted channel, the incoming IBC denom, and the balance the destination credits. dYdX is an early example. Its deposit route accepts USDC via Injective, while its canonical USDC module credits the user in the existing dYdX USDC denom. That lets balances and collateral stay the same as the backing moves from Noble to Injective. Route builders need to map the incoming voucher to the asset the user will see. dYdX migration guide

For relayers and indexers. Record the CCTP burn hash, the Injective mint and dispatch hash, and the IBC source channel and packet sequence. Use the packet identifiers to track the actual destination credit and the acknowledgement back to Injective. Troubleshoot an outbound transfer