# Akash Node IBC Integration Pattern: Cross-Chain Communication Architecture

> Explore the Akash Node IBC integration pattern for cross-chain communication. Learn how Cosmos-SDK, keepers, ICS-20, and Tendermint clients enable trustless packet verification.

- Repository: [Akash Network/node](https://github.com/akash-network/node)
- Tags: architecture
- Published: 2026-02-24

---

**Akash Node implements a layered IBC integration pattern through Cosmos-SDK that initializes core keepers, registers the ICS-20 transfer module, builds a static IBC router, and wires Tendermint light clients for trustless cross-chain packet verification.**

The `akash-network/node` repository integrates the Inter-Blockchain Communication (IBC) protocol using a standard Cosmos-SDK application pattern. This integration pattern enables Akash Node to participate in cross-chain communication by sending and receiving IBC packets, facilitating token transfers, and validating cryptographic proofs from other chains. The implementation spans keeper initialization, module routing, and block lifecycle management across three core files.

## Core IBC Keeper Initialization

The integration begins by instantiating the foundational **IBC keeper** that manages clients, connections, and channels. In [`app/types/app.go`](https://github.com/akash-network/node/blob/main/app/types/app.go) at lines 317–323, the application creates the core keeper using `ibckeeper.NewKeeper()`, passing the codec, store service, subspace, upgrade keeper, and governance authority address.

```go
app.Keepers.Cosmos.IBC = ibckeeper.NewKeeper(
    cdc,
    runtime.NewKVStoreService(app.keys[ibcexported.StoreKey]),
    app.GetSubspace(ibcexported.ModuleName),
    app.Keepers.Cosmos.Upgrade,
    authtypes.NewModuleAddress(govtypes.ModuleName).String(),
)

```

This keeper serves as the central coordinator for all IBC-related state management and cryptographic verification.

## ICS-20 Token Transfer Module Registration

Akash Node enables fungible token transfers via the **ICS-20 standard** by registering the transfer keeper. At lines 81–92 in [`app/types/app.go`](https://github.com/akash-network/node/blob/main/app/types/app.go), the application initializes `ibctransferkeeper.NewKeeper()` with dependencies on the IBC channel keeper, authentication module, bank keeper, and message service router.

```go
app.Keepers.Cosmos.Transfer = ibctransferkeeper.NewKeeper(
    cdc,
    runtime.NewKVStoreService(app.keys[ibctransfertypes.StoreKey]),
    app.GetSubspace(ibctransfertypes.ModuleName),
    app.Keepers.Cosmos.IBC.ChannelKeeper,
    app.Keepers.Cosmos.IBC.ChannelKeeper,
    bApp.MsgServiceRouter(),
    app.Keepers.Cosmos.Acct,
    app.Keepers.Cosmos.Bank,
    authtypes.NewModuleAddress(govtypes.ModuleName).String(),
)

```

The dual injection of `ChannelKeeper` satisfies both the ICS-20 specification requirements for escrow account management and packet forwarding capabilities.

## Static IBC Router Configuration

To route incoming IBC packets to appropriate application modules, Akash Node constructs a **static IBC router** at lines 96–100 of [`app/types/app.go`](https://github.com/akash-network/node/blob/main/app/types/app.go). The pattern uses `porttypes.NewRouter()` to create the routing table, adds the transfer module route using `ibctransfertypes.ModuleName`, and seals the configuration on the IBC keeper.

```go
ibcRouter := porttypes.NewRouter()
ibcRouter.AddRoute(ibctransfertypes.ModuleName, transferIBCModule)
app.Keepers.Cosmos.IBC.SetRouter(ibcRouter)

```

This static routing approach ensures deterministic packet handling where all IBC applications must be registered during application initialization.

## Tendermint Light Client Integration

For verifying block headers and state commitments from counterparty chains, Akash Node integrates the **Tendermint light client** (IBC-Go "07-tendermint"). The implementation at lines 102–108 in [`app/types/app.go`](https://github.com/akash-network/node/blob/main/app/types/app.go) retrieves the client keeper's store provider, instantiates `ibctm.NewLightClientModule()`, and registers it via `clientKeeper.AddRoute()`.

```go
clientKeeper := app.Keepers.Cosmos.IBC.ClientKeeper
storeProvider := clientKeeper.GetStoreProvider()
app.Keepers.Modules.TMLight = ibctm.NewLightClientModule(cdc, storeProvider)
clientKeeper.AddRoute(ibctm.ModuleName, &app.Keepers.Modules.TMLight)

```

This integration allows Akash Node to verify Merkle proofs against tendermint consensus states from any IBC-connected Cosmos chain.

## Module Lifecycle Management

The IBC modules enter the application's dependency graph through explicit registration and ordering. In [`app/modules.go`](https://github.com/akash-network/node/blob/main/app/modules.go) at lines 31–39, the module manager receives the IBC core application module, transfer module, and Tendermint light-client module via `ibc.NewAppModule()`, `transfer.NewAppModule()`, and `ibctm.NewAppModule()` respectively.

Block processing order ensures correct state transitions. In [`app/app.go`](https://github.com/akash-network/node/blob/main/app/app.go) at lines 86–92, the `OrderBeginBlockers` and `OrderEndBlockers` sequences place `ibctm.ModuleName` before `ibchost.ModuleName`, guaranteeing that light client updates process prior to IBC packet handling during each block.

## Complete IBC Integration Code Example

The following excerpt from `akash-network/node` demonstrates the complete wiring pattern required to enable IBC cross-chain communication:

```go
// 1. Core IBC keeper initialization
app.Keepers.Cosmos.IBC = ibckeeper.NewKeeper(
    cdc,
    runtime.NewKVStoreService(app.keys[ibcexported.StoreKey]),
    app.GetSubspace(ibcexported.ModuleName),
    app.Keepers.Cosmos.Upgrade,
    authtypes.NewModuleAddress(govtypes.ModuleName).String(),
)

// 2. ICS-20 transfer keeper with channel dependencies
app.Keepers.Cosmos.Transfer = ibctransferkeeper.NewKeeper(
    cdc,
    runtime.NewKVStoreService(app.keys[ibctransfertypes.StoreKey]),
    app.GetSubspace(ibctransfertypes.ModuleName),
    app.Keepers.Cosmos.IBC.ChannelKeeper,
    app.Keepers.Cosmos.IBC.ChannelKeeper,
    bApp.MsgServiceRouter(),
    app.Keepers.Cosmos.Acct,
    app.Keepers.Cosmos.Bank,
    authtypes.NewModuleAddress(govtypes.ModuleName).String(),
)

// 3. Static router with transfer route sealed
transferMod := transfer.NewIBCModule(app.Keepers.Cosmos.Transfer)
router := porttypes.NewRouter()
router.AddRoute(ibctransfertypes.ModuleName, transferMod)
app.Keepers.Cosmos.IBC.SetRouter(router)

// 4. Tendermint light client for cross-chain verification
clientKeeper := app.Keepers.Cosmos.IBC.ClientKeeper
storeProvider := clientKeeper.GetStoreProvider()
app.Keepers.Modules.TMLight = ibctm.NewLightClientModule(cdc, storeProvider)
clientKeeper.AddRoute(ibctm.ModuleName, &app.Keepers.Modules.TMLight)

```

All IBC dependencies import from `github.com/cosmos/ibc-go/v10`, ensuring compatibility with the IBC-Go v10 specification.

## Summary

- **Akash Node** implements a standard Cosmos-SDK IBC integration pattern using `github.com/cosmos/ibc-go/v10`.
- The architecture initializes four key components: core IBC keeper, ICS-20 transfer module, static packet router, and Tendermint light client.
- Critical initialization occurs in [`app/types/app.go`](https://github.com/akash-network/node/blob/main/app/types/app.go) (lines 81–108, 317–323), module registration in [`app/modules.go`](https://github.com/akash-network/node/blob/main/app/modules.go) (lines 31–39), and lifecycle ordering in [`app/app.go`](https://github.com/akash-network/node/blob/main/app/app.go) (lines 86–92).
- The **static router pattern** requires all IBC applications to be registered at compile time via `porttypes.NewRouter()` and `SetRouter()`.
- **Tendermint light client** integration enables trustless verification of remote chain states using the "07-tendermint" implementation.

## Frequently Asked Questions

### What is the role of the static IBC router in Akash Node?

The static IBC router, constructed using `porttypes.NewRouter()` in [`app/types/app.go`](https://github.com/akash-network/node/blob/main/app/types/app.go) at lines 96–100, maps IBC port identifiers to specific application modules. When Akash Node receives an IBC packet, the router inspects the destination port and dispatches the packet to the registered handler—such as the transfer module for ICS-20 tokens—ensuring deterministic routing without runtime dynamic registration.

### How does Akash Node verify headers from other chains?

Akash Node verifies remote chain headers through the **Tendermint light client module** instantiated at lines 102–108 in [`app/types/app.go`](https://github.com/akash-network/node/blob/main/app/types/app.go). The `ibctm.NewLightClientModule()` creates a light client instance that processes block headers from counterparty chains, validates Merkle proofs against stored consensus states, and updates client states according to the Tendermint consensus algorithm.

### Which version of IBC-Go does Akash Node use?

According to the source code analysis, Akash Node imports and builds against **`github.com/cosmos/ibc-go/v10`**. This dependency is defined in the project's `go.mod` file and provides the IBC core keeper, transfer module, and Tendermint light client implementations used throughout the integration pattern.

### Why is module ordering important for IBC functionality in Akash Node?

Module ordering in [`app/app.go`](https://github.com/akash-network/node/blob/main/app/app.go) (lines 86–92) ensures that the Tendermint light client updates (`ibctm.ModuleName`) execute before the core IBC module (`ibchost.ModuleName`) during `BeginBlock` and `EndBlock` processing. This sequencing guarantees that client state updates—which provide the trusted root for verification—are committed to state before any packets relying on those roots are processed, preventing invalid packet verification failures.