地址: 0x0000000000000000000000000000000000000400 相关模块: 地址转换工具 Bech32 预编译提供了 Ethereum 十六进制地址与 Cosmos bech32 地址之间的地址格式转换功能。

​
概览

Bech32 预编译公开了简单的转换辅助方法，使 Solidity 合约可以：
  1. 将 Ethereum address 转换为带有所需 prefix 的 Bech32 字符串（例如 cosmos）。
  2. 将任意 Bech32 地址字符串转换回 EVM address。
它是 Cosmos 地址转换库的一个轻量封装，部署在 0x0000000000000000000000000000000000000400。

​
Gas 成本

这两个方法都使用一个可配置的基础 gas 数量，该值在链初始化期间设置。在合理范围内，无论字符串长度如何，gas 成本都是固定的。

​
主要方法

​
hexToBech32

签名: hexToBech32(address addr, string memory prefix) → string memory 说明: 使用指定前缀将 Ethereum 十六进制地址转换为 Cosmos bech32 格式。 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Interface for the Bech32 precompile
interface IBech32 {
    function hexToBech32(address addr, string memory prefix) external returns (string memory bech32Address);
    function bech32ToHex(string memory bech32Address) external returns (address addr);
}

contract Bech32Example {
    address constant BECH32_PRECOMPILE = 0x0000000000000000000000000000000000000400;
    
    IBech32 public immutable bech32;
    
    event AddressConverted(address indexed hexAddress, string bech32Address, string prefix);
    
    constructor() {
        bech32 = IBech32(BECH32_PRECOMPILE);
    }
    
    function hexToBech32(address addr, string calldata prefix) 
        external 
        returns (string memory bech32Address) 
    {
        require(addr != address(0), "Invalid address");
        require(bytes(prefix).length > 0, "Prefix cannot be empty");
        
        bech32Address = bech32.hexToBech32(addr, prefix);
        
        emit AddressConverted(addr, bech32Address, prefix);
        return bech32Address;
    }
    
    // Convert multiple addresses with the same prefix
    function batchHexToBech32(address[] calldata addresses, string calldata prefix) 
        external 
        returns (string[] memory bech32Addresses) 
    {
        bech32Addresses = new string[](addresses.length);
        
        for (uint256 i = 0; i < addresses.length; i++) {
            require(addresses[i] != address(0), "Invalid address in batch");
            bech32Addresses[i] = bech32.hexToBech32(addresses[i], prefix);
            emit AddressConverted(addresses[i], bech32Addresses[i], prefix);
        }
        
        return bech32Addresses;
    }
    
    // Get common address formats for a single hex address
    function getCommonFormats(address addr) 
        external 
        returns (
            string memory cosmosAddr,
            string memory evmosAddr,
            string memory osmosisAddr
        ) 
    {
        require(addr != address(0), "Invalid address");
        
        cosmosAddr = bech32.hexToBech32(addr, "cosmos");
        evmosAddr = bech32.hexToBech32(addr, "evmos");
        osmosisAddr = bech32.hexToBech32(addr, "osmo");
        
        return (cosmosAddr, evmosAddr, osmosisAddr);
    }
    
    // Convert caller's address to bech32 format
    function getMyBech32Address(string calldata prefix) 
        external 
        returns (string memory) 
    {
        return bech32.hexToBech32(msg.sender, prefix);
    }
}
参数:
  • addr (address): 要转换的 Ethereum 十六进制地址
  • prefix (string): 要使用的 bech32 前缀（例如："cosmos"）
返回值: 包含 bech32 格式地址的字符串

​
bech32ToHex

签名: bech32ToHex(string memory bech32Address) → address 说明: 将 Cosmos bech32 地址转换为 Ethereum 十六进制格式。 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Interface for the Bech32 precompile
interface IBech32 {
    function bech32ToHex(string memory bech32Address) external returns (address addr);
    function hexToBech32(address addr, string memory prefix) external returns (string memory bech32Address);
}

contract Bech32Example {
    address constant BECH32_PRECOMPILE = 0x0000000000000000000000000000000000000400;
    
    IBech32 public immutable bech32;
    
    event Bech32Converted(string bech32Address, address indexed hexAddress);
    
    constructor() {
        bech32 = IBech32(BECH32_PRECOMPILE);
    }
    
    function bech32ToHex(string calldata bech32Address) 
        external 
        returns (address hexAddress) 
    {
        require(bytes(bech32Address).length > 0, "Bech32 address cannot be empty");
        
        hexAddress = bech32.bech32ToHex(bech32Address);
        require(hexAddress != address(0), "Invalid bech32 address");
        
        emit Bech32Converted(bech32Address, hexAddress);
        return hexAddress;
    }
    
    // Convert multiple bech32 addresses to hex format
    function batchBech32ToHex(string[] calldata bech32Addresses) 
        external 
        returns (address[] memory hexAddresses) 
    {
        hexAddresses = new address[](bech32Addresses.length);
        
        for (uint256 i = 0; i < bech32Addresses.length; i++) {
            require(bytes(bech32Addresses[i]).length > 0, "Invalid bech32 address");
            hexAddresses[i] = bech32.bech32ToHex(bech32Addresses[i]);
            require(hexAddresses[i] != address(0), "Invalid bech32 address in batch");
            emit Bech32Converted(bech32Addresses[i], hexAddresses[i]);
        }
        
        return hexAddresses;
    }
    
    // Validate address conversion by converting back and forth
    function validateAddressConversion(address addr, string calldata prefix) 
        external 
        returns (bool isValid) 
    {
        try bech32.hexToBech32(addr, prefix) returns (string memory bech32Addr) {
            try bech32.bech32ToHex(bech32Addr) returns (address convertedBack) {
                isValid = (convertedBack == addr);
                return isValid;
            } catch {
                return false;
            }
        } catch {
            return false;
        }
    }
    
    // Check if two addresses (hex and bech32) represent the same account
    function areAddressesEqual(address hexAddr, string calldata bech32Addr) 
        external 
        returns (bool isEqual) 
    {
        try bech32.bech32ToHex(bech32Addr) returns (address convertedHex) {
            isEqual = (convertedHex == hexAddr);
            return isEqual;
        } catch {
            return false;
        }
    }
    
    // Safely convert bech32 to hex with error handling
    function safeBech32ToHex(string calldata bech32Address) 
        external 
        returns (bool success, address hexAddress) 
    {
        try bech32.bech32ToHex(bech32Address) returns (address addr) {
            return (true, addr);
        } catch {
            return (false, address(0));
        }
    }
}
参数:
  • bech32Address (string): 要转换的 bech32 格式地址
返回值: 十六进制格式的 Ethereum 地址

​
完整接口与 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": {}
}

​
实现细节

​
地址校验

这两个方法都会对地址格式进行校验：
  • hexToBech32：校验十六进制地址是否恰好为 20 字节，且前缀非空
  • bech32ToHex：校验 bech32 地址是否包含分隔符字符 “1”，并能解码为 20 字节

​
前缀处理

对于 hexToBech32：
  • prefix 参数决定 bech32 地址中人类可读部分的内容
  • 常见前缀包括账户地址、验证者地址和共识地址
  • 当前缀为空或仅包含空白字符时，将返回错误并提示建议使用的有效前缀
对于 bech32ToHex：
  • 前缀会从 bech32 地址中自动提取
  • 无需提供 prefix 参数，因为它已嵌入地址中

​
状态可变性

虽然这两个方法在 ABI 中都标记为 nonpayable，但它们实际作为只读操作运行，不会修改区块链状态。
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. 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Interface for the Bech32 precompile
interface IBech32 {
    function hexToBech32(address addr, string memory prefix) external returns (string memory bech32Address);
    function bech32ToHex(string memory bech32Address) external returns (address addr);
}

contract Bech32Example {
    address constant BECH32_PRECOMPILE = 0x0000000000000000000000000000000000000400;
    
    IBech32 public immutable bech32;
    
    event AddressConverted(address indexed hexAddress, string bech32Address, string prefix);
    
    constructor() {
        bech32 = IBech32(BECH32_PRECOMPILE);
    }
    
    function hexToBech32(address addr, string calldata prefix) 
        external 
        returns (string memory bech32Address) 
    {
        require(addr != address(0), "Invalid address");
        require(bytes(prefix).length > 0, "Prefix cannot be empty");
        
        bech32Address = bech32.hexToBech32(addr, prefix);
        
        emit AddressConverted(addr, bech32Address, prefix);
        return bech32Address;
    }
    
    // Convert multiple addresses with the same prefix
    function batchHexToBech32(address[] calldata addresses, string calldata prefix) 
        external 
        returns (string[] memory bech32Addresses) 
    {
        bech32Addresses = new string[](addresses.length);
        
        for (uint256 i = 0; i < addresses.length; i++) {
            require(addresses[i] != address(0), "Invalid address in batch");
            bech32Addresses[i] = bech32.hexToBech32(addresses[i], prefix);
            emit AddressConverted(addresses[i], bech32Addresses[i], prefix);
        }
        
        return bech32Addresses;
    }
    
    // Get common address formats for a single hex address
    function getCommonFormats(address addr) 
        external 
        returns (
            string memory cosmosAddr,
            string memory evmosAddr,
            string memory osmosisAddr
        ) 
    {
        require(addr != address(0), "Invalid address");
        
        cosmosAddr = bech32.hexToBech32(addr, "cosmos");
        evmosAddr = bech32.hexToBech32(addr, "evmos");
        osmosisAddr = bech32.hexToBech32(addr, "osmo");
        
        return (cosmosAddr, evmosAddr, osmosisAddr);
    }
    
    // Convert caller's address to bech32 format
    function getMyBech32Address(string calldata prefix) 
        external 
        returns (string memory) 
    {
        return bech32.hexToBech32(msg.sender, prefix);
    }
}
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. 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Interface for the Bech32 precompile
interface IBech32 {
    function bech32ToHex(string memory bech32Address) external returns (address addr);
    function hexToBech32(address addr, string memory prefix) external returns (string memory bech32Address);
}

contract Bech32Example {
    address constant BECH32_PRECOMPILE = 0x0000000000000000000000000000000000000400;
    
    IBech32 public immutable bech32;
    
    event Bech32Converted(string bech32Address, address indexed hexAddress);
    
    constructor() {
        bech32 = IBech32(BECH32_PRECOMPILE);
    }
    
    function bech32ToHex(string calldata bech32Address) 
        external 
        returns (address hexAddress) 
    {
        require(bytes(bech32Address).length > 0, "Bech32 address cannot be empty");
        
        hexAddress = bech32.bech32ToHex(bech32Address);
        require(hexAddress != address(0), "Invalid bech32 address");
        
        emit Bech32Converted(bech32Address, hexAddress);
        return hexAddress;
    }
    
    // Convert multiple bech32 addresses to hex format
    function batchBech32ToHex(string[] calldata bech32Addresses) 
        external 
        returns (address[] memory hexAddresses) 
    {
        hexAddresses = new address[](bech32Addresses.length);
        
        for (uint256 i = 0; i < bech32Addresses.length; i++) {
            require(bytes(bech32Addresses[i]).length > 0, "Invalid bech32 address");
            hexAddresses[i] = bech32.bech32ToHex(bech32Addresses[i]);
            require(hexAddresses[i] != address(0), "Invalid bech32 address in batch");
            emit Bech32Converted(bech32Addresses[i], hexAddresses[i]);
        }
        
        return hexAddresses;
    }
    
    // Validate address conversion by converting back and forth
    function validateAddressConversion(address addr, string calldata prefix) 
        external 
        returns (bool isValid) 
    {
        try bech32.hexToBech32(addr, prefix) returns (string memory bech32Addr) {
            try bech32.bech32ToHex(bech32Addr) returns (address convertedBack) {
                isValid = (convertedBack == addr);
                return isValid;
            } catch {
                return false;
            }
        } catch {
            return false;
        }
    }
    
    // Check if two addresses (hex and bech32) represent the same account
    function areAddressesEqual(address hexAddr, string calldata bech32Addr) 
        external 
        returns (bool isEqual) 
    {
        try bech32.bech32ToHex(bech32Addr) returns (address convertedHex) {
            isEqual = (convertedHex == hexAddr);
            return isEqual;
        } catch {
            return false;
        }
    }
    
    // Safely convert bech32 to hex with error handling
    function safeBech32ToHex(string calldata bech32Address) 
        external 
        returns (bool success, address hexAddress) 
    {
        try bech32.bech32ToHex(bech32Address) returns (address addr) {
            return (true, addr);
        } catch {
            return (false, address(0));
        }
    }
}
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.