Bech32

Address format conversion between Ethereum hex addresses and Cosmos bech32 addresses

Address: 0x0000000000000000000000000000000000000400

Related Module: Address conversion utilities

The Bech32 precompile provides address format conversion functionality between Ethereum hex addresses and Cosmos bech32 addresses.

Overview

The Bech32 precompile exposes simple conversion helpers so Solidity contracts can:

1. Convert an Ethereum address to a Bech32 string with a desired prefix (e.g. cosmos).
2. Convert any Bech32 address string back into an EVM address.

It is a thin wrapper around the Cosmos address‐conversion library and lives at 0x0000000000000000000000000000000000000400.

Gas Costs

Both methods use a configurable base gas amount that is set during chain initialization. The gas cost is fixed regardless of string length within reasonable bounds.

Primary Methods

hexToBech32

Signature: hexToBech32(address addr, string memory prefix) → string memory

Description: Converts an Ethereum hex address to Cosmos bech32 format using the specified prefix.

Ethers.js

import { ethers } from "ethers";

// Connect to the network
const provider = new ethers.JsonRpcProvider("<RPC_URL>");

// Precompile address and ABI
const precompileAddress = "0x0000000000000000000000000000000000000400";
const precompileAbi = [
  "function hexToBech32(address addr, string memory prefix) returns (string memory)"
];

// Create a contract instance
const contract = new ethers.Contract(precompileAddress, precompileAbi, provider);

// Inputs
const ethAddress = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"; // Placeholder
const prefix = "cosmos";

async function convertToBech32() {
  try {
    const bech32Address = await contract.hexToBech32.staticCall(ethAddress, prefix);
    console.log("Bech32 Address:", bech32Address);
  } catch (error) {
    console.error("Error converting to Bech32:", error);
  }
}

convertToBech32();

Parameters:

• addr (address): The Ethereum hex address to convert
• prefix (string): The bech32 prefix to use (e.g., “cosmos”)

Returns: String containing the bech32 formatted address

bech32ToHex

Signature: bech32ToHex(string memory bech32Address) → address

Description: Converts a Cosmos bech32 address to Ethereum hex format.

Ethers.js

import { ethers } from "ethers";

// Connect to the network
const provider = new ethers.JsonRpcProvider("<RPC_URL>");

// Precompile address and ABI
const precompileAddress = "0x0000000000000000000000000000000000000400";
const precompileAbi = [
  "function bech32ToHex(string memory bech32Address) returns (address)"
];

// Create a contract instance
const contract = new ethers.Contract(precompileAddress, precompileAbi, provider);

// Input
const bech32Address = "cosmos1mrdxhunfvjhe6lhdncp72dq46da2jcz9d9sh93"; // Placeholder

async function convertToHex() {
  try {
    const hexAddress = await contract.bech32ToHex.staticCall(bech32Address);
    console.log("Hex Address:", hexAddress);
  } catch (error) {
    console.error("Error converting to Hex:", error);
  }
}

convertToHex();

Parameters:

• bech32Address (string): The bech32 formatted address to convert

Returns: Ethereum address in hex format

Full Interface & ABI

Bech32 Solidity Interface

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.8.17;

/// @dev The Bech32I contract's address.
address constant Bech32_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000400;

/// @dev The Bech32I contract's instance.
Bech32I constant BECH32_CONTRACT = Bech32I(Bech32_PRECOMPILE_ADDRESS);

interface Bech32I {
    function hexToBech32(address addr,string memory prefix) external returns (string memory bech32Address);
    function bech32ToHex(string memory bech32Address) external returns (address addr);
}

Bech32 ABI

{
  "_format": "hh-sol-artifact-1",
  "contractName": "Bech32I",
  "sourceName": "solidity/precompiles/bech32/Bech32I.sol",
  "abi": [
    {
      "inputs": [
        { "internalType": "string", "name": "bech32Address", "type": "string" }
      ],
      "name": "bech32ToHex",
      "outputs": [
        { "internalType": "address", "name": "addr", "type": "address" }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        { "internalType": "address", "name": "addr", "type": "address" },
        { "internalType": "string", "name": "prefix", "type": "string" }
      ],
      "name": "hexToBech32",
      "outputs": [
        { "internalType": "string", "name": "bech32Address", "type": "string" }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    }
  ],
  "bytecode": "0x",
  "deployedBytecode": "0x",
  "linkReferences": {},
  "deployedLinkReferences": {}
}

Implementation Details

Address Validation

Both methods perform validation on the address format:

• hexToBech32: Validates that the hex address is exactly 20 bytes and the prefix is non-empty
• bech32ToHex: Validates that the bech32 address contains the separator character “1” and decodes to 20 bytes

Prefix Handling

For hexToBech32:

• The prefix parameter determines the human-readable part of the bech32 address
• Common prefixes include account addresses, validator addresses, and consensus addresses
• Empty or whitespace-only prefixes result in an error with suggested valid prefixes

For bech32ToHex:

• The prefix is automatically extracted from the bech32 address
• No prefix parameter is required as it’s embedded in the address

State Mutability

While both methods are marked as nonpayable in the ABI, they function as read-only operations and do not modify blockchain state.