@initia/initia.js 1.0.21 → 2.0.0-rc.1

package/dist/cosmos-Bqh8qNfP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmos-Bqh8qNfP.mjs","names":["#privateKey","#destroyed","createInitia","createMinievm","createMinimove","createMiniwasm","createCosmos"],"sources":["../src/key/key.ts","../src/key/raw-key.ts","../src/key/mnemonic-key.ts","../src/key/hd-path.ts","../src/token/resolver.ts","../src/client/create-client-cosmos.ts","../src/client/resolve-client.ts","../src/contexts/cosmos.ts"],"sourcesContent":["/**\n * Abstract base class for Initia key management.\n *\n * Handles both Cosmos-style and EVM-style address derivation:\n * - Cosmos: ripemd160(sha256(compressed_pubkey))\n * - EVM: keccak256(uncompressed_pubkey[1:])[12:32]\n *\n * Implements the Signer interface for compatibility with external key management.\n */\n\nimport { sha256, ripemd160, keccak256 } from '../util/hash'\nimport { secp256k1 } from '@noble/curves/secp256k1.js'\nimport { bech32, base64 } from '@scure/base'\nimport { bytesToHex } from '@noble/hashes/utils.js'\nimport type { AccAddress, ValAddress } from '../util/address'\nimport type {\n  SigningAlgorithm,\n  OfflineSigner,\n  DirectSignDoc,\n  DirectSignResponse,\n  AminoSignDoc,\n  AminoSignResponse,\n} from '../signer/types'\nimport type { SignModeType } from '../client/types'\nimport {\n  makeSignBytes,\n  makeStdSignDoc,\n  makeAminoSignBytes,\n  makeEIP191SignBytes,\n  encodeTxDirect,\n  buildStdFee,\n} from '../tx/sign'\nimport { sortObject } from '../tx/amino'\nimport { packPubKey, getAminoPubKeyType } from '../util/public-key'\nimport type { UnsignedTx, MultisigSignature } from '../tx/unsigned-tx'\nimport type { MultisigPublicKey } from './multisig'\nimport { ValidationError } from '../errors'\n\n/** Default bech32 prefix for Initia addresses */\nexport const DEFAULT_BECH32_PREFIX = 'init'\n\n/**\n * Abstract base class for cryptographic key operations.\n *\n * Implements the Signer interface, making it compatible with:\n * - External key stores (KeyStore)\n * - Hardware wallets (Ledger)\n * - Browser extensions (Keplr, Leap)\n *\n * Subclasses must implement:\n * - publicKey: The compressed secp256k1 public key bytes\n * - isEth: Whether to use EVM-style address derivation\n * - signRaw(): Sign raw bytes with SHA256 hash (protected)\n * - signWithKeccak256(): Sign with Keccak256 hash\n */\nexport abstract class Key implements OfflineSigner {\n  /** Compressed secp256k1 public key (33 bytes) */\n  abstract readonly publicKey: Uint8Array\n\n  /** If true, uses EVM-style (keccak256) address derivation */\n  abstract readonly isEth: boolean\n\n  /**\n   * Signing algorithm.\n   * - 'eth_secp256k1' for Initia/Ethereum (isEth=true)\n   * - 'secp256k1' for Cosmos chains (isEth=false)\n   */\n  get algorithm(): SigningAlgorithm {\n    return this.isEth ? 'eth_secp256k1' : 'secp256k1'\n  }\n\n  /** Bech32 prefix for address encoding (default: 'init') */\n  abstract readonly bech32Prefix: string\n\n  /** Preferred sign mode hint (undefined = auto-detect via duck typing) */\n  preferredSignMode?: SignModeType\n\n  /**\n   * Sign raw bytes with SHA256 hash.\n   * @param message - Raw message bytes to sign\n   * @returns ECDSA signature (64 bytes, r || s format)\n   */\n  protected abstract signRaw(message: Uint8Array): Promise<Uint8Array>\n\n  /**\n   * Sign a message with Keccak256 hash (EVM compatible).\n   * @param message - Raw message bytes to sign\n   * @returns ECDSA signature (64 bytes, r || s format)\n   */\n  abstract signWithKeccak256(message: Uint8Array): Promise<Uint8Array>\n\n  /**\n   * Sign raw bytes, an UnsignedTx, or participate in multisig signing.\n   *\n   * For UnsignedTx: dispatches by signMode (direct/amino/eip191).\n   * - direct: protobuf SignDoc\n   * - amino: canonical JSON StdSignDoc\n   * - eip191: EIP-191 prefixed amino (always keccak256)\n   */\n  async sign(message: Uint8Array): Promise<Uint8Array>\n  async sign(tx: UnsignedTx): Promise<Uint8Array>\n  async sign(tx: UnsignedTx, mpk: MultisigPublicKey): Promise<MultisigSignature>\n  async sign(\n    input: Uint8Array | UnsignedTx,\n    mpk?: MultisigPublicKey\n  ): Promise<Uint8Array | MultisigSignature> {\n    // Raw bytes → delegate to signRaw\n    if (input instanceof Uint8Array) {\n      return this.signRaw(input)\n    }\n\n    // Multisig: validate membership first, then sign\n    if (mpk) {\n      const index = mpk.publicKeys.findIndex(\n        pk => pk.length === this.publicKey.length && pk.every((b, i) => b === this.publicKey[i])\n      )\n      if (index === -1) {\n        throw new ValidationError(\n          'key',\n          'This key is not a member of the provided MultisigPublicKey'\n        )\n      }\n      const signBytes = input.getMultisigSignBytes(mpk)\n      const signature = this.isEth\n        ? await this.signWithKeccak256(signBytes)\n        : await this.signRaw(signBytes)\n      return { index, signature }\n    }\n\n    // Single key: dispatch by signMode\n    return this._signTx(input)\n  }\n\n  protected async _signTx(tx: UnsignedTx): Promise<Uint8Array> {\n    switch (tx.signMode) {\n      case 'amino':\n      case 'eip191': {\n        const stdSignDoc = makeStdSignDoc(\n          tx.msgs.map(m => m.toAmino()),\n          buildStdFee(tx),\n          tx.chainId,\n          tx.memo,\n          tx.accountNumber,\n          tx.sequence\n        )\n        const signBytes =\n          tx.signMode === 'eip191'\n            ? makeEIP191SignBytes(stdSignDoc)\n            : makeAminoSignBytes(stdSignDoc)\n        return this.isEth || tx.signMode === 'eip191'\n          ? this.signWithKeccak256(signBytes)\n          : this.signRaw(signBytes)\n      }\n      case 'direct': {\n        const algorithm = this.isEth ? ('ethsecp256k1' as const) : ('secp256k1' as const)\n        const { bodyBytes, authInfoBytes } = encodeTxDirect(tx, this.publicKey, algorithm)\n        const signBytes = makeSignBytes(bodyBytes, authInfoBytes, tx.chainId, tx.accountNumber)\n        return this.isEth ? this.signWithKeccak256(signBytes) : this.signRaw(signBytes)\n      }\n      default:\n        throw new ValidationError('signMode', `Unsupported sign mode: ${tx.signMode as string}`)\n    }\n  }\n\n  // ========== Signer interface implementation ==========\n\n  /**\n   * Get the public key (Signer interface).\n   * @returns Compressed secp256k1 public key (33 bytes)\n   */\n  // eslint-disable-next-line @typescript-eslint/require-await\n  async getPublicKey(): Promise<Uint8Array> {\n    return this.publicKey\n  }\n\n  /**\n   * Get the bech32 address (Signer interface).\n   * @param prefix - Address prefix (default: configured bech32Prefix)\n   * @returns Bech32-encoded address\n   */\n  // eslint-disable-next-line @typescript-eslint/require-await\n  async getAddress(prefix?: string): Promise<string> {\n    const p = prefix ?? this.bech32Prefix\n    return bech32.encode(p, bech32.toWords(this.rawAddress))\n  }\n\n  // ========== OfflineSigner interface implementation ==========\n\n  /**\n   * Sign a SignDoc directly (Protobuf encoding).\n   * Implements DirectSigner.signDirect.\n   */\n  async signDirect(_signerAddress: string, signDoc: DirectSignDoc): Promise<DirectSignResponse> {\n    const signBytes = makeSignBytes(\n      signDoc.bodyBytes,\n      signDoc.authInfoBytes,\n      signDoc.chainId,\n      signDoc.accountNumber\n    )\n    const signature = this.isEth\n      ? await this.signWithKeccak256(signBytes)\n      : await this.signRaw(signBytes)\n    const pubKeyAny = packPubKey(this.publicKey, this.isEth ? 'ethsecp256k1' : 'secp256k1')\n\n    return {\n      signed: signDoc,\n      signature: {\n        pubKey: { typeUrl: pubKeyAny.typeUrl, value: pubKeyAny.value },\n        signature,\n      },\n    }\n  }\n\n  /**\n   * Sign an Amino JSON document.\n   * Implements AminoSigner.signAmino.\n   */\n  async signAmino(_signerAddress: string, signDoc: AminoSignDoc): Promise<AminoSignResponse> {\n    const sorted = sortObject(signDoc)\n    const json = JSON.stringify(sorted)\n    const signBytes = new TextEncoder().encode(json)\n    const signature = this.isEth\n      ? await this.signWithKeccak256(signBytes)\n      : await this.signRaw(signBytes)\n\n    const pubKeyType = getAminoPubKeyType(this.isEth ? 'ethsecp256k1' : 'secp256k1')\n\n    return {\n      signed: signDoc,\n      signature: {\n        pub_key: {\n          type: pubKeyType,\n          value: base64.encode(this.publicKey),\n        },\n        signature: base64.encode(signature),\n      },\n    }\n  }\n\n  // ========== EIP-191 signing ==========\n\n  /**\n   * Sign data with EIP-191 personal sign prefix.\n   * Prepends \"\\x19Ethereum Signed Message:\\n{length}\" and signs with keccak256.\n   *\n   * @param data - Raw bytes to sign (typically Amino sign bytes)\n   * @returns ECDSA signature (64 bytes, r || s)\n   */\n  async signPersonal(data: Uint8Array): Promise<Uint8Array> {\n    const prefix = `\\x19Ethereum Signed Message:\\n${data.length}`\n    const prefixBytes = new TextEncoder().encode(prefix)\n    const prefixed = new Uint8Array(prefixBytes.length + data.length)\n    prefixed.set(prefixBytes, 0)\n    prefixed.set(data, prefixBytes.length)\n    return this.signWithKeccak256(prefixed)\n  }\n\n  // ========== Address derivation ==========\n\n  /**\n   * Raw address bytes (20 bytes).\n   * Derivation method depends on isEth flag.\n   */\n  get rawAddress(): Uint8Array {\n    if (this.isEth) {\n      // EVM: keccak256(uncompressed_pubkey[1:])[12:32]\n      const point = secp256k1.Point.fromHex(bytesToHex(this.publicKey))\n      const uncompressed = point.toBytes(false).slice(1) // remove 0x04 prefix\n      return keccak256(uncompressed).slice(12)\n    } else {\n      // Cosmos: ripemd160(sha256(compressed_pubkey))\n      return ripemd160(sha256(this.publicKey))\n    }\n  }\n\n  /**\n   * Account address (e.g., init1..., osmo1..., noble1...).\n   * Uses bech32 encoding with the configured prefix.\n   */\n  get address(): AccAddress {\n    return bech32.encode(this.bech32Prefix, bech32.toWords(this.rawAddress))\n  }\n\n  /**\n   * Validator operator address (e.g., initvaloper1...).\n   * Uses bech32 encoding with the configured prefix + 'valoper'.\n   */\n  get valAddress(): ValAddress {\n    return bech32.encode(this.bech32Prefix + 'valoper', bech32.toWords(this.rawAddress))\n  }\n\n  /**\n   * EVM hex address (0x...).\n   * Always uses keccak256 derivation regardless of isEth flag.\n   */\n  get evmAddress(): `0x${string}` {\n    const point = secp256k1.Point.fromHex(bytesToHex(this.publicKey))\n    const uncompressed = point.toBytes(false).slice(1)\n    return `0x${bytesToHex(keccak256(uncompressed).slice(12))}`\n  }\n\n  /**\n   * Verify a signature against a message.\n   * Uses SHA256 hash for verification.\n   * @param message - Original message bytes\n   * @param signature - ECDSA signature (64 bytes)\n   * @returns true if signature is valid\n   */\n  verify(message: Uint8Array, signature: Uint8Array): boolean {\n    const msgHash = sha256(message)\n    return secp256k1.verify(signature, msgHash, this.publicKey, { prehash: false })\n  }\n\n  /**\n   * Verify a signature using Keccak256 hash (EVM compatible).\n   * @param message - Original message bytes\n   * @param signature - ECDSA signature (64 bytes)\n   * @returns true if signature is valid\n   */\n  verifyWithKeccak256(message: Uint8Array, signature: Uint8Array): boolean {\n    const msgHash = keccak256(message)\n    return secp256k1.verify(signature, msgHash, this.publicKey, { prehash: false })\n  }\n}\n","/**\n * RawKey - Key implementation using a raw private key.\n *\n * Creates keys from raw 32-byte private keys for signing transactions.\n * Supports both Cosmos-style and EVM-style address derivation.\n */\n\nimport { secp256k1 } from '@noble/curves/secp256k1.js'\nimport { hexToBytes, bytesToHex } from '@noble/hashes/utils.js'\nimport { sha256, keccak256 } from '../util/hash'\nimport { Key, DEFAULT_BECH32_PREFIX } from './key'\nimport { KeyError } from '../errors'\nimport type { RecoverableSignature } from '../signer/types'\n\n/**\n * Key implementation using a raw private key.\n *\n * @example\n * ```typescript\n * // From raw bytes\n * const key = new RawKey(privateKeyBytes)\n *\n * // From hex string\n * const key = RawKey.fromHex('0x...')\n *\n * // Get address\n * console.log(key.address) // init1...\n * ```\n */\nexport class RawKey extends Key {\n  readonly publicKey: Uint8Array\n  readonly isEth: boolean\n  readonly bech32Prefix: string\n\n  /** Private key stored securely using ES2022 private field */\n  #privateKey: Uint8Array\n\n  /** Track if key has been destroyed */\n  #destroyed = false\n\n  /**\n   * Create a RawKey from a private key.\n   * @param privateKey - 32-byte private key\n   * @param isEth - Use EVM-style address derivation (default: true)\n   * @param bech32Prefix - Bech32 prefix for address encoding (default: 'init')\n   */\n  constructor(privateKey: Uint8Array, isEth = true, bech32Prefix = DEFAULT_BECH32_PREFIX) {\n    super()\n    if (privateKey.length !== 32) {\n      throw new KeyError('import', 'Private key must be 32 bytes')\n    }\n    this.#privateKey = privateKey\n    this.publicKey = secp256k1.getPublicKey(privateKey, true) // compressed\n    this.isEth = isEth\n    this.bech32Prefix = bech32Prefix\n  }\n\n  /**\n   * Create a RawKey from a hex string.\n   * @param hex - 64-character hex string (with or without 0x prefix)\n   * @param isEth - Use EVM-style address derivation (default: true)\n   * @param bech32Prefix - Bech32 prefix for address encoding (default: 'init')\n   */\n  static fromHex(hex: string, isEth = true, bech32Prefix = DEFAULT_BECH32_PREFIX): RawKey {\n    const cleaned = hex.replace(/^0x/, '')\n    if (cleaned.length !== 64) {\n      throw new KeyError('import', 'Private key must be 64 hex characters')\n    }\n    return new RawKey(hexToBytes(cleaned), isEth, bech32Prefix)\n  }\n\n  /**\n   * Check if the key has been destroyed.\n   */\n  get isDestroyed(): boolean {\n    return this.#destroyed\n  }\n\n  /**\n   * Securely destroy the key by zeroing out the private key bytes.\n   *\n   * After calling this method:\n   * - The private key memory is overwritten with zeros\n   * - Any subsequent signing operations will throw an error\n   * - The public key and address remain accessible\n   *\n   * WARNING: This operation is irreversible.\n   *\n   * @example\n   * ```typescript\n   * const key = new RawKey(privateKeyBytes)\n   * await key.sign(message)\n   * key.destroy() // Zero out private key when done\n   * ```\n   */\n  destroy(): void {\n    if (this.#destroyed) return\n    this.#privateKey.fill(0)\n    this.#destroyed = true\n  }\n\n  /**\n   * Get the private key as a hex string (0x-prefixed).\n   * Use for EVM transaction signing or external key export.\n   * @throws KeyError if the key has been destroyed\n   */\n  getPrivateKeyHex(): `0x${string}` {\n    if (this.#destroyed) {\n      throw new KeyError('sign', 'Key has been destroyed')\n    }\n    return `0x${bytesToHex(this.#privateKey)}`\n  }\n\n  /**\n   * Sign raw bytes with SHA256 hash.\n   * @param message - Raw message bytes to sign\n   * @returns ECDSA signature in compact format (64 bytes, r || s)\n   * @throws KeyError if the key has been destroyed\n   */\n  // eslint-disable-next-line @typescript-eslint/require-await\n  protected async signRaw(message: Uint8Array): Promise<Uint8Array> {\n    if (this.#destroyed) {\n      throw new KeyError('sign', 'Key has been destroyed')\n    }\n    const msgHash = sha256(message)\n    // noble-curves v2: prehash defaults to true (applies curve hash internally).\n    // We pre-hash ourselves, so disable prehash to avoid double-hashing.\n    return secp256k1.sign(msgHash, this.#privateKey, { prehash: false })\n  }\n\n  /**\n   * Sign a message with Keccak256 hash (EVM compatible).\n   * @param message - Raw message bytes to sign\n   * @returns ECDSA signature in compact format (64 bytes, r || s)\n   * @throws KeyError if the key has been destroyed\n   */\n  // eslint-disable-next-line @typescript-eslint/require-await\n  async signWithKeccak256(message: Uint8Array): Promise<Uint8Array> {\n    if (this.#destroyed) {\n      throw new KeyError('sign', 'Key has been destroyed')\n    }\n    const msgHash = keccak256(message)\n    // noble-curves v2: prehash defaults to true (applies curve hash internally).\n    // We pre-hash ourselves, so disable prehash to avoid double-hashing.\n    return secp256k1.sign(msgHash, this.#privateKey, { prehash: false })\n  }\n\n  /**\n   * Sign an EVM transaction hash with recoverable signature.\n   *\n   * Returns r, s, and yParity components needed for EIP-1559 transaction\n   * serialization. Uses keccak256-compatible ECDSA signing.\n   *\n   * @param hash - 32-byte hash to sign (already hashed, no prehash applied)\n   * @returns Recoverable signature components\n   * @throws KeyError if the key has been destroyed\n   */\n  // eslint-disable-next-line @typescript-eslint/require-await\n  async signEvmHash(hash: Uint8Array): Promise<RecoverableSignature> {\n    if (this.#destroyed) {\n      throw new KeyError('sign', 'Key has been destroyed')\n    }\n    if (hash.length !== 32) {\n      throw new KeyError('sign', `Expected 32-byte hash, got ${hash.length} bytes`)\n    }\n    // noble-curves v2: format:'recovered' returns 65 bytes: recovery(1) || r(32) || s(32)\n    const sig = secp256k1.sign(hash, this.#privateKey, { prehash: false, format: 'recovered' })\n    const recovery = sig[0]\n    if (recovery !== 0 && recovery !== 1) {\n      throw new KeyError('sign', `Unexpected recovery byte: ${recovery}`)\n    }\n    return {\n      r: sig.slice(1, 33),\n      s: sig.slice(33, 65),\n      yParity: recovery,\n    }\n  }\n}\n","/**\n * MnemonicKey - Key implementation using BIP-39 mnemonic phrases.\n *\n * Derives keys from 24-word mnemonic phrases using BIP-32/BIP-44 HD derivation.\n * Default derivation path: m/44'/60'/0'/0/0 (Ethereum/Initia)\n */\n\nimport { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from '@scure/bip39'\nimport { HDKey } from '@scure/bip32'\nimport { wordlist } from '@scure/bip39/wordlists/english.js'\nimport { RawKey } from './raw-key'\nimport { DEFAULT_BECH32_PREFIX } from './key'\nimport { KeyError } from '../errors'\n\n/** Ethereum coin type used for Initia (BIP-44) */\nexport const INIT_COIN_TYPE = 60\n\n/**\n * Options for creating a MnemonicKey.\n */\nexport interface MnemonicKeyOptions {\n  /** BIP-39 mnemonic phrase (24 words). Required for constructor. */\n  mnemonic: string\n  /** BIP-44 coin type (default: 60 for Ethereum/Initia) */\n  coinType?: number\n  /** BIP-44 account index (default: 0) */\n  account?: number\n  /** BIP-44 address index (default: 0) */\n  index?: number\n  /** Use EVM-style address derivation (default: true) */\n  isEth?: boolean\n  /** Bech32 prefix for address encoding (default: 'init') */\n  bech32Prefix?: string\n}\n\n/**\n * Options for generating a new MnemonicKey.\n */\nexport type MnemonicKeyGenerateOptions = Omit<MnemonicKeyOptions, 'mnemonic'>\n\nconst DEFAULT_OPTIONS = {\n  coinType: INIT_COIN_TYPE,\n  account: 0,\n  index: 0,\n  isEth: true,\n  bech32Prefix: DEFAULT_BECH32_PREFIX,\n}\n\n/**\n * Key implementation using BIP-39 mnemonic phrases.\n *\n * ⚠️ SECURITY: Mnemonic phrases are NOT stored in the key instance.\n * Use `MnemonicKey.generate()` to create a new key and get the mnemonic for backup.\n *\n * @example\n * ```typescript\n * // Generate new key with mnemonic backup\n * const { key, mnemonic } = MnemonicKey.generate()\n * console.log(mnemonic) // Display to user for backup, then discard\n *\n * // From existing mnemonic\n * const key = new MnemonicKey({ mnemonic: 'word1 word2 ...' })\n *\n * // Custom derivation path\n * const key = new MnemonicKey({\n *   mnemonic: '...',\n *   account: 1,\n *   index: 5,\n * })\n * ```\n */\nexport class MnemonicKey extends RawKey {\n  /**\n   * Create a MnemonicKey from an existing mnemonic.\n   *\n   * For generating a new key with mnemonic backup, use `MnemonicKey.generate()`.\n   *\n   * @param options - Mnemonic key options (mnemonic is required)\n   */\n  constructor(options: MnemonicKeyOptions) {\n    const { mnemonic, coinType, account, index, isEth, bech32Prefix } = {\n      ...DEFAULT_OPTIONS,\n      ...options,\n    }\n\n    if (!validateMnemonic(mnemonic, wordlist)) {\n      throw new KeyError('import', 'Invalid mnemonic phrase')\n    }\n\n    const seed = mnemonicToSeedSync(mnemonic)\n    const hdKey = HDKey.fromMasterSeed(seed)\n    const path = `m/44'/${coinType}'/${account}'/0/${index}`\n    const derived = hdKey.derive(path)\n\n    if (!derived.privateKey) {\n      throw new KeyError('derive', 'Failed to derive private key from mnemonic')\n    }\n\n    super(derived.privateKey, isEth, bech32Prefix)\n    // NOTE: mnemonic is intentionally NOT stored for security\n  }\n\n  /**\n   * Generate a new mnemonic key with backup phrase.\n   *\n   * ⚠️ SECURITY WARNING:\n   * - The returned mnemonic provides FULL wallet recovery capability\n   * - Display to user for backup, then IMMEDIATELY discard from memory\n   * - NEVER log, store in database, or transmit the mnemonic\n   * - The mnemonic is NOT stored in the key instance\n   *\n   * @param options - Key generation options (derivation path, prefix, etc.)\n   * @returns Object containing the key and mnemonic for one-time backup\n   *\n   * @example\n   * ```typescript\n   * const { key, mnemonic } = MnemonicKey.generate()\n   *\n   * // Show mnemonic to user for backup\n   * displayBackupScreen(mnemonic)\n   *\n   * // After user confirms backup, clear the mnemonic\n   * // The key can be used for signing without the mnemonic\n   * ```\n   */\n  static generate(options: MnemonicKeyGenerateOptions = {}): {\n    key: MnemonicKey\n    mnemonic: string\n  } {\n    const mnemonic = generateMnemonic(wordlist, 256)\n    const key = new MnemonicKey({ ...options, mnemonic })\n    return { key, mnemonic }\n  }\n}\n","/**\n * SLIP-0044 Coin Type constants\n */\nexport const COIN_TYPE = {\n  INITIA: 60, // EVM compatible\n  ETHEREUM: 60, // Same as Initia\n  COSMOS: 118, // Cosmos Hub, Celestia, Osmosis, and most Cosmos chains\n} as const\n\nexport type CoinType = (typeof COIN_TYPE)[keyof typeof COIN_TYPE]\n\n/**\n * BIP-44 HD Path helper class\n *\n * Use with @scure/bip32 HDKey.derive()\n *\n * @example\n * ```typescript\n * import { HDKey } from '@scure/bip32'\n *\n * const hdKey = HDKey.fromMasterSeed(seed)\n * const derived = hdKey.derive(HDPath.initia().toString())\n * ```\n */\nexport class HDPath {\n  private constructor(\n    private purpose_: number,\n    private coinType_: number,\n    private account_: number,\n    private change_: number,\n    private index_: number\n  ) {}\n\n  // ===== Preset Factories =====\n\n  static initia(index = 0): HDPath {\n    return new HDPath(44, COIN_TYPE.INITIA, 0, 0, index)\n  }\n\n  static cosmos(index = 0): HDPath {\n    return new HDPath(44, COIN_TYPE.COSMOS, 0, 0, index)\n  }\n\n  static fromCoinType(coinType: number, index = 0, account = 0): HDPath {\n    return new HDPath(44, coinType, account, 0, index)\n  }\n\n  // ===== Transformation Methods =====\n\n  index(n: number): HDPath {\n    return new HDPath(this.purpose_, this.coinType_, this.account_, this.change_, n)\n  }\n\n  account(n: number): HDPath {\n    return new HDPath(this.purpose_, this.coinType_, n, this.change_, this.index_)\n  }\n\n  // ===== Output =====\n\n  /** Path string for @scure/bip32 HDKey.derive() */\n  toString(): string {\n    return `m/${this.purpose_}'/${this.coinType_}'/${this.account_}'/${this.change_}/${this.index_}`\n  }\n\n  // ===== Accessors =====\n\n  get coinType(): number {\n    return this.coinType_\n  }\n\n  get addressIndex(): number {\n    return this.index_\n  }\n}\n","/**\n * Token Resolver - VM dispatch logic.\n *\n * Resolves a token identifier to the appropriate TokenContract adapter\n * based on chain type and address format.\n */\n\nimport type { Client as ConnectClient } from '@connectrpc/connect'\nimport type { Query as EvmQuery } from '@buf/initia-labs_minievm.bufbuild_es/minievm/evm/v1/query_pb'\nimport type { Query as WasmQuery } from '@buf/cosmwasm_wasmd.bufbuild_es/cosmwasm/wasm/v1/query_pb'\nimport type { Query as MoveQuery } from '@buf/initia-labs_initia.bufbuild_es/initia/move/v1/query_pb'\n\nimport type { ChainType } from '../client/types'\nimport type { TokenContract } from './types'\nimport { createErc20Token } from './erc20'\nimport { createCw20Token } from './cw20'\nimport { createFungibleAssetToken } from './fungible-asset'\n\nexport interface EvmEnabled {\n  evm: ConnectClient<typeof EvmQuery>\n}\n\nexport interface WasmEnabled {\n  wasm: ConnectClient<typeof WasmQuery>\n}\n\nexport interface MoveEnabled {\n  move: ConnectClient<typeof MoveQuery>\n}\n\n/**\n * Resolve a token identifier to a TokenContract adapter.\n *\n * Dispatch rules:\n * - minievm + 0x address → ERC20\n * - miniwasm + bech32 address → CW20\n * - initia/minimove + metadata address → Move Fungible Asset\n *\n * @param client - gRPC client with appropriate services\n * @param chainType - Chain type for dispatch\n * @param token - Token identifier (contract address or metadata address)\n * @param sender - Optional sender for EVM read queries\n * @throws Error if chain type doesn't match token format\n */\nexport function resolveTokenContract(\n  client: EvmEnabled,\n  chainType: 'minievm',\n  token: string,\n  sender?: string\n): TokenContract\nexport function resolveTokenContract(\n  client: WasmEnabled,\n  chainType: 'miniwasm',\n  token: string,\n  sender?: string\n): TokenContract\nexport function resolveTokenContract(\n  client: MoveEnabled,\n  chainType: 'initia' | 'minimove',\n  token: string,\n  sender?: string\n): TokenContract\nexport function resolveTokenContract(\n  client: EvmEnabled | WasmEnabled | MoveEnabled,\n  chainType: ChainType,\n  token: string,\n  sender?: string\n): TokenContract {\n  switch (chainType) {\n    case 'minievm': {\n      if (!token.startsWith('0x')) {\n        throw new Error(\n          `Invalid token address for minievm: expected 0x-prefixed address, got \"${token}\"`\n        )\n      }\n      return createErc20Token((client as EvmEnabled).evm, token, sender)\n    }\n\n    case 'miniwasm': {\n      if (token.startsWith('0x')) {\n        throw new Error(\n          `Invalid token address for miniwasm: expected bech32 address, got \"${token}\"`\n        )\n      }\n      return createCw20Token((client as WasmEnabled).wasm, token)\n    }\n\n    case 'initia':\n    case 'minimove': {\n      return createFungibleAssetToken((client as MoveEnabled).move, token)\n    }\n\n    default:\n      throw new Error(\n        `Token contract not supported for chain type \"${chainType}\". ` +\n          'Use bank module queries (ctx.getBalance) for native denoms on unsupported chain types.'\n      )\n  }\n}\n","import type { Transport } from '@connectrpc/connect'\nimport type { ChainInfo } from '../provider/types'\nimport type { BaseClient, AuthConfig } from './types'\nimport { createBaseConfig } from '../chains/common'\nimport { createGrpcClient } from './grpc-client'\nimport { wrapClientWithCache } from './cached-client'\n\nexport function createClientWithConfig(\n  chainInfo: ChainInfo,\n  transport: Transport,\n  contextAuth?: AuthConfig,\n  contextHeaders?: Record<string, string>\n): BaseClient {\n  const config = /* @__PURE__ */ createBaseConfig().build()\n  const client = createGrpcClient(\n    transport,\n    config.services,\n    contextAuth,\n    contextHeaders,\n    config.registry\n  )\n  return wrapClientWithCache(client, chainInfo.chainId) as BaseClient\n}\n","/**\n * Runtime client dispatch — maps chainType to per-chain factory.\n *\n * Each factory returns a specific client type (e.g. InitiaClient) which\n * widens to Client naturally, eliminating double casts.\n */\n\nimport type { Transport } from '@connectrpc/connect'\nimport type { ChainInfo } from '../provider/types'\nimport type { Client } from './types'\nimport { createClientWithConfig as createInitia } from './create-client-initia'\nimport { createClientWithConfig as createMinievm } from './create-client-minievm'\nimport { createClientWithConfig as createMinimove } from './create-client-minimove'\nimport { createClientWithConfig as createMiniwasm } from './create-client-miniwasm'\nimport { createClientWithConfig as createCosmos } from './create-client-cosmos'\n\ntype ClientFactory = (chainInfo: ChainInfo, transport: Transport) => Client\n\nconst factories: Record<string, ClientFactory> = {\n  initia: createInitia,\n  minievm: createMinievm,\n  minimove: createMinimove,\n  miniwasm: createMiniwasm,\n}\n\nconst defaultFactory: ClientFactory = createCosmos\n\n/** Dispatch chainInfo.chainType to the correct per-chain client factory. */\nexport function resolveClient(chainInfo: ChainInfo, transport: Transport): Client {\n  const factory = factories[chainInfo.chainType] ?? defaultFactory\n  return factory(chainInfo, transport)\n}\n","/**\n * Generic Cosmos chain context config (chainType 'other').\n * Uses createBaseConfig() — only shared cosmos modules (bank, auth, ibc, etc.).\n * No chain-specific proto.\n */\nimport { createBaseConfig } from '../chains/common'\nimport type { TypedFactoryOptions } from '../wallet/typed-context'\n\n// createBaseConfig() returns a ChainConfigBuilder — treat it like the chain-specific builders.\n// @__PURE__ annotation tells bundlers this call is droppable if cosmosContextConfig is unused.\nconst cosmosChain = /* @__PURE__ */ createBaseConfig()\n\nexport const cosmosContextConfig = [\n  cosmosChain,\n  {} satisfies TypedFactoryOptions,\n] as const\n"],"mappings":"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"}

package/dist/cosmos-registry-provider-DCrEEhJ-.d.mts

@@ -0,0 +1,123 @@
+import { C as NetworkType, c as OpBridgeInfo, i as ChainInfoForType, m as ChainType, o as IbcChannelInfo, r as ChainInfo, s as ListAssetsOptions, t as AssetInfo, u as TransferPath } from "./types-DGrP9Ro_.mjs";
+import { t as BaseChainDataProvider } from "./base-provider-CLnd7kte.mjs";
+import { AssetList } from "@initia/initia-registry-types";
+import { AssetList as AssetList$1 } from "@chain-registry/types";
+
+//#region src/provider/cosmos-registry-provider.d.ts
+/**
+ * Options for CosmosRegistryProvider.
+ */
+interface CosmosRegistryProviderOptions {
+  /**
+   * Include mainnet chains (default: true)
+   */
+  mainnet?: boolean;
+  /**
+   * Include testnet chains (default: true)
+   */
+  testnet?: boolean;
+  /**
+   * Filter chains by name (optional).
+   * If provided, only chains with matching chain_name will be included.
+   * @example ['osmosis', 'noble', 'cosmoshub']
+   */
+  chainNames?: string[];
+}
+/**
+ * Cosmos Registry Provider.
+ *
+ * Provides chain information from the chain-registry npm package.
+ * This gives access to all Cosmos ecosystem chains like Osmosis, Noble,
+ * Cosmos Hub, Juno, Stargaze, and many more.
+ *
+ * Data is bundled at build time from the chain-registry, so no network
+ * requests are needed at runtime.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const provider = new CosmosRegistryProvider()
+ *
+ * // Get Osmosis mainnet
+ * const osmosis = provider.getChainInfo('osmosis-1')
+ *
+ * // Get Noble mainnet
+ * const noble = provider.getChainInfo('noble-1')
+ *
+ * // List all available chains
+ * const allChains = provider.listChains()
+ *
+ * // Get assets for a chain
+ * const assets = await provider.getAssets('noble-1')
+ * ```
+ *
+ * @example With options
+ * ```typescript
+ * // Only mainnet chains
+ * const mainnetProvider = new CosmosRegistryProvider({ testnet: false })
+ *
+ * // Only specific chains
+ * const selectedProvider = new CosmosRegistryProvider({
+ *   chainNames: ['osmosis', 'noble', 'cosmoshub']
+ * })
+ * ```
+ *
+ * @example Combined with Initia providers
+ * ```typescript
+ * import { CompositeProvider, createRegistryProvider } from 'initia.js/provider'
+ * import { CosmosRegistryProvider } from 'initia.js/cosmos'
+ *
+ * // Support both Initia and Cosmos ecosystem chains
+ * const initiaProvider = await createRegistryProvider()
+ * const provider = new CompositeProvider([
+ *   initiaProvider,                  // Initia chains
+ *   new CosmosRegistryProvider(),    // Cosmos ecosystem chains
+ * ])
+ *
+ * // Now you can access both ecosystems
+ * const initia = provider.getChainInfo('initiation-2')  // Initia testnet
+ * const osmosis = provider.getChainInfo('osmosis-1')    // Osmosis mainnet
+ * ```
+ */
+declare class CosmosRegistryProvider extends BaseChainDataProvider {
+  private chainMap;
+  private assetMap;
+  private assetInfoCache;
+  private ibcDataByChain;
+  private chainNameToIds;
+  private chainIdToName;
+  constructor(options?: CosmosRegistryProviderOptions);
+  getChainInfo<T extends ChainType = ChainType>(chainId: string): ChainInfoForType<T> | undefined;
+  listChains(): ChainInfo[];
+  hasChain(chainId: string): boolean;
+  getAssets(chainId: string): Promise<AssetInfo[]>;
+  getRawAssetList(chainId: string): Promise<AssetList | AssetList$1 | undefined>;
+  findAsset(denom: string, chainId?: string): Promise<AssetInfo | undefined>;
+  findAssetBySymbol(symbol: string, chainId?: string): Promise<AssetInfo[]>;
+  listAssets(options?: ListAssetsOptions): Promise<AssetInfo[]>;
+  getIbcChannels(chainId: string): IbcChannelInfo[];
+  getIbcChannel(fromChainId: string, toChainId: string): IbcChannelInfo | undefined;
+  getTransferPath(fromChainId: string, toChainId: string, _denom?: string): TransferPath | undefined;
+  getOpBridge(_l2ChainId: string): OpBridgeInfo | undefined;
+  resolveChainId(chainName: string, network?: NetworkType): string | undefined;
+  getChainName(chainId: string): string | undefined;
+  /**
+   * Get chain by chain name (not chain ID).
+   *
+   * Useful when you know the chain name but not the specific chain ID.
+   * Note: Returns the first matching chain if multiple networks exist.
+   *
+   * @param chainName - The chain name (e.g., 'osmosis', 'noble')
+   * @returns Chain info if found, undefined otherwise
+   */
+  getChainByName(chainName: string): ChainInfo | undefined;
+  /**
+   * List chains filtered by network type.
+   *
+   * @param network - Network type to filter by
+   * @returns Array of matching chain configurations
+   */
+  listChainsByNetwork(network: NetworkType): ChainInfo[];
+}
+//#endregion
+export { CosmosRegistryProviderOptions as n, CosmosRegistryProvider as t };
+//# sourceMappingURL=cosmos-registry-provider-DCrEEhJ-.d.mts.map

package/dist/cw20-BTpdgMXC.mjs

@@ -0,0 +1,63 @@
+import { t as Message } from "./types-CSS5rfW1.mjs";
+import { r as MsgExecuteContractSchema } from "./tx_pb-u3CoQYge.mjs";
+import { n as encodeMsg, t as decodeResponse } from "./json-CGak0DqP.mjs";
+//#region src/token/cw20.ts
+/**
+* Create a CW20 TokenContract adapter.
+*/
+function createCw20Token(wasmClient, contractAddress) {
+	async function query(msg) {
+		return decodeResponse((await wasmClient.smartContractState({
+			address: contractAddress,
+			queryData: encodeMsg(msg)
+		})).data);
+	}
+	return {
+		async getInfo() {
+			const result = await query({ token_info: {} });
+			return {
+				name: result.name,
+				symbol: result.symbol,
+				decimals: result.decimals,
+				totalSupply: BigInt(result.total_supply)
+			};
+		},
+		async balanceOf(owner) {
+			const result = await query({ balance: { address: owner } });
+			return BigInt(result.balance);
+		},
+		createTransferMsg(sender, to, amount) {
+			return new Message(MsgExecuteContractSchema, {
+				sender,
+				contract: contractAddress,
+				msg: encodeMsg({ transfer: {
+					recipient: to,
+					amount: amount.toString()
+				} }),
+				funds: []
+			});
+		},
+		async allowance(owner, spender) {
+			const result = await query({ allowance: {
+				owner,
+				spender
+			} });
+			return BigInt(result.allowance);
+		},
+		createApproveMsg(sender, spender, amount) {
+			return new Message(MsgExecuteContractSchema, {
+				sender,
+				contract: contractAddress,
+				msg: encodeMsg({ increase_allowance: {
+					spender,
+					amount: amount.toString()
+				} }),
+				funds: []
+			});
+		}
+	};
+}
+//#endregion
+export { createCw20Token as t };
+
+//# sourceMappingURL=cw20-BTpdgMXC.mjs.map

package/dist/cw20-BTpdgMXC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cw20-BTpdgMXC.mjs","names":[],"sources":["../src/token/cw20.ts"],"sourcesContent":["/**\n * CW20 Token Contract Adapter.\n *\n * Implements TokenContract interface for Wasm chains using CW20 standard messages.\n */\n\nimport type { Numeric } from '../types'\nimport type { Client as ConnectClient } from '@connectrpc/connect'\nimport { MsgExecuteContractSchema } from '@buf/cosmwasm_wasmd.bufbuild_es/cosmwasm/wasm/v1/tx_pb'\nimport type { Query as WasmQuery } from '@buf/cosmwasm_wasmd.bufbuild_es/cosmwasm/wasm/v1/query_pb'\n\nimport type { TokenInfo } from '../contracts/types'\nimport { Message } from '../msgs/types'\nimport type { TokenContract } from './types'\nimport { encodeMsg, decodeResponse } from '../util/json'\n\ntype WasmClient = ConnectClient<typeof WasmQuery>\n\n/**\n * Create a CW20 TokenContract adapter.\n */\nexport function createCw20Token(wasmClient: WasmClient, contractAddress: string): TokenContract {\n  async function query(msg: object): Promise<unknown> {\n    const response = await wasmClient.smartContractState({\n      address: contractAddress,\n      queryData: encodeMsg(msg),\n    })\n    return decodeResponse(response.data)\n  }\n\n  return {\n    async getInfo(): Promise<TokenInfo> {\n      const result = (await query({ token_info: {} })) as {\n        name: string\n        symbol: string\n        decimals: number\n        total_supply: string\n      }\n\n      return {\n        name: result.name,\n        symbol: result.symbol,\n        decimals: result.decimals,\n        totalSupply: BigInt(result.total_supply),\n      }\n    },\n\n    async balanceOf(owner: string): Promise<bigint> {\n      const result = (await query({ balance: { address: owner } })) as {\n        balance: string\n      }\n      return BigInt(result.balance)\n    },\n\n    createTransferMsg(sender: string, to: string, amount: Numeric): Message {\n      return new Message(MsgExecuteContractSchema, {\n        sender,\n        contract: contractAddress,\n        msg: encodeMsg({ transfer: { recipient: to, amount: amount.toString() } }),\n        funds: [],\n      })\n    },\n\n    async allowance(owner: string, spender: string): Promise<bigint> {\n      const result = (await query({ allowance: { owner, spender } })) as {\n        allowance: string\n      }\n      return BigInt(result.allowance)\n    },\n\n    createApproveMsg(sender: string, spender: string, amount: Numeric): Message {\n      return new Message(MsgExecuteContractSchema, {\n        sender,\n        contract: contractAddress,\n        msg: encodeMsg({ increase_allowance: { spender, amount: amount.toString() } }),\n        funds: [],\n      })\n    },\n  }\n}\n"],"mappings":";;;;;;;AAqBA,SAAgB,gBAAgB,YAAwB,iBAAwC;CAC9F,eAAe,MAAM,KAA+B;AAKlD,SAAO,gBAJU,MAAM,WAAW,mBAAmB;GACnD,SAAS;GACT,WAAW,UAAU,IAAI;GAC1B,CAAC,EAC6B,KAAK;;AAGtC,QAAO;EACL,MAAM,UAA8B;GAClC,MAAM,SAAU,MAAM,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC;AAO/C,UAAO;IACL,MAAM,OAAO;IACb,QAAQ,OAAO;IACf,UAAU,OAAO;IACjB,aAAa,OAAO,OAAO,aAAa;IACzC;;EAGH,MAAM,UAAU,OAAgC;GAC9C,MAAM,SAAU,MAAM,MAAM,EAAE,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;AAG5D,UAAO,OAAO,OAAO,QAAQ;;EAG/B,kBAAkB,QAAgB,IAAY,QAA0B;AACtE,UAAO,IAAI,QAAQ,0BAA0B;IAC3C;IACA,UAAU;IACV,KAAK,UAAU,EAAE,UAAU;KAAE,WAAW;KAAI,QAAQ,OAAO,UAAU;KAAE,EAAE,CAAC;IAC1E,OAAO,EAAE;IACV,CAAC;;EAGJ,MAAM,UAAU,OAAe,SAAkC;GAC/D,MAAM,SAAU,MAAM,MAAM,EAAE,WAAW;IAAE;IAAO;IAAS,EAAE,CAAC;AAG9D,UAAO,OAAO,OAAO,UAAU;;EAGjC,iBAAiB,QAAgB,SAAiB,QAA0B;AAC1E,UAAO,IAAI,QAAQ,0BAA0B;IAC3C;IACA,UAAU;IACV,KAAK,UAAU,EAAE,oBAAoB;KAAE;KAAS,QAAQ,OAAO,UAAU;KAAE,EAAE,CAAC;IAC9E,OAAO,EAAE;IACV,CAAC;;EAEL"}

package/dist/decode-CXGawqIZ.mjs

@@ -0,0 +1,29 @@
+import { d as ParseError } from "./errors-CN1MFOLv.mjs";
+import { t as Message } from "./types-CSS5rfW1.mjs";
+//#region src/msgs/decode.ts
+/**
+* Create a decode function that resolves Any messages by typeUrl.
+*
+* Looks up the schema from the registered set and returns a fully decoded Message.
+* Throws ParseError if the typeUrl is not registered.
+*
+* The returned Message is unparameterized — use `isMessageOf(decoded, SomeSchema)`
+* to narrow the type and access typed `.value` properties.
+*
+* When duplicate typeUrls exist in schemas, the last entry wins (override semantics).
+* This is intentional for ChainConfigBuilder where network-specific overrides
+* may replace base module schemas.
+*/
+function createDecode(schemas) {
+	const map = /* @__PURE__ */ new Map();
+	for (const s of schemas) map.set("/" + s.typeName, s);
+	return (packed) => {
+		const schema = map.get(packed.typeUrl);
+		if (!schema) throw new ParseError("message", `Unknown message type: ${packed.typeUrl}. Not registered in decode schema map. If using custom modules, ensure all schemas are included in the module definition.`);
+		return Message.fromAny(schema, packed);
+	};
+}
+//#endregion
+export { createDecode as t };
+
+//# sourceMappingURL=decode-CXGawqIZ.mjs.map

package/dist/decode-CXGawqIZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-CXGawqIZ.mjs","names":[],"sources":["../src/msgs/decode.ts"],"sourcesContent":["import type { DescMessage } from '@bufbuild/protobuf'\nimport type { Any } from '@bufbuild/protobuf/wkt'\nimport { ParseError } from '../errors'\nimport { Message } from './types'\n\n/**\n * Create a decode function that resolves Any messages by typeUrl.\n *\n * Looks up the schema from the registered set and returns a fully decoded Message.\n * Throws ParseError if the typeUrl is not registered.\n *\n * The returned Message is unparameterized — use `isMessageOf(decoded, SomeSchema)`\n * to narrow the type and access typed `.value` properties.\n *\n * When duplicate typeUrls exist in schemas, the last entry wins (override semantics).\n * This is intentional for ChainConfigBuilder where network-specific overrides\n * may replace base module schemas.\n */\nexport function createDecode(schemas: DescMessage[]): (packed: Any) => Message {\n  const map = new Map<string, DescMessage>()\n  for (const s of schemas) map.set('/' + s.typeName, s)\n  return (packed: Any) => {\n    const schema = map.get(packed.typeUrl)\n    if (!schema) {\n      throw new ParseError(\n        'message',\n        `Unknown message type: ${packed.typeUrl}. Not registered in decode schema map. ` +\n          'If using custom modules, ensure all schemas are included in the module definition.'\n      )\n    }\n    return Message.fromAny(schema, packed)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAgB,aAAa,SAAkD;CAC7E,MAAM,sBAAM,IAAI,KAA0B;AAC1C,MAAK,MAAM,KAAK,QAAS,KAAI,IAAI,MAAM,EAAE,UAAU,EAAE;AACrD,SAAQ,WAAgB;EACtB,MAAM,SAAS,IAAI,IAAI,OAAO,QAAQ;AACtC,MAAI,CAAC,OACH,OAAM,IAAI,WACR,WACA,yBAAyB,OAAO,QAAQ,2HAEzC;AAEH,SAAO,QAAQ,QAAQ,QAAQ,OAAO"}

package/dist/entry.bridge.browser.d.mts

@@ -0,0 +1,21 @@
+import { a as ChainInfoProvider } from "./types-DGrP9Ro_.mjs";
+import { C as WithdrawOptions, E as WithdrawalStatus, S as WithdrawAndClaimOptions, T as WithdrawalInfo, _ as SignedOpHook, a as BridgeWatchHandle, b as WatchDepositOptions, c as DepositAndWaitOptions, d as OpHookOptions, f as OpHookResult, g as RouteOptions, h as RouteOperation, i as fetchWithdrawals, l as DepositEvent, m as Route, n as FetchWithdrawalsOptions, o as BuildTransferMsgsOptions, p as RoutableAsset, r as fetchWithdrawal, s as ClaimOptions, t as Bridge, u as DepositOptions, v as TransferStatus, w as WithdrawalEvent, x as WatchWithdrawalOptions, y as TransferTx } from "./bridge-cQoOjppA.mjs";
+import { t as calculateWithdrawalHash } from "./hash-Doo89wm3.mjs";
+
+//#region src/entry.bridge.browser.d.ts
+declare function createBridge(provider: ChainInfoProvider, routerUrl?: string): Bridge;
+declare function watchDeposit(provider: ChainInfoProvider, options: WatchDepositOptions, callback: (event: DepositEvent) => void): BridgeWatchHandle;
+declare function watchWithdrawal(provider: ChainInfoProvider, options: WatchWithdrawalOptions, callback: (event: WithdrawalEvent) => void): BridgeWatchHandle;
+declare function waitForDeposit(provider: ChainInfoProvider, options: WatchDepositOptions & {
+  timeout?: number;
+}): Promise<DepositEvent & {
+  status: 'finalized';
+}>;
+declare function waitForClaimable(provider: ChainInfoProvider, options: WatchWithdrawalOptions & {
+  timeout?: number;
+}): Promise<WithdrawalEvent & {
+  status: 'claimable';
+}>;
+//#endregion
+export { Bridge, type BridgeWatchHandle, type BuildTransferMsgsOptions, type ClaimOptions, type DepositAndWaitOptions, type DepositEvent, type DepositOptions, type FetchWithdrawalsOptions, type OpHookOptions, type OpHookResult, type RoutableAsset, type Route, type RouteOperation, type RouteOptions, type SignedOpHook, type TransferStatus, type TransferTx, type WatchDepositOptions, type WatchWithdrawalOptions, type WithdrawAndClaimOptions, type WithdrawOptions, type WithdrawalEvent, type WithdrawalInfo, type WithdrawalStatus, calculateWithdrawalHash, createBridge, fetchWithdrawal, fetchWithdrawals, waitForClaimable, waitForDeposit, watchDeposit, watchWithdrawal };
+//# sourceMappingURL=entry.bridge.browser.d.mts.map

package/dist/entry.bridge.browser.mjs

@@ -0,0 +1,25 @@
+import { t as createTransport } from "./transport.browser-CCUWv3ta.mjs";
+import { a as watchWithdrawal$1, c as fetchWithdrawals, i as watchDeposit$1, n as waitForClaimable$1, o as calculateWithdrawalHash, r as waitForDeposit$1, s as fetchWithdrawal, t as Bridge } from "./bridge-DL-q-7P7.mjs";
+//#region src/entry.bridge.browser.ts
+/**
+* Bridge entry point (Browser) — injects gRPC-Web transport.
+*/
+function createBridge(provider, routerUrl) {
+	return new Bridge(provider, createTransport, routerUrl);
+}
+function watchDeposit(provider, options, callback) {
+	return watchDeposit$1(provider, options, callback);
+}
+function watchWithdrawal(provider, options, callback) {
+	return watchWithdrawal$1(provider, options, callback, createTransport);
+}
+function waitForDeposit(provider, options) {
+	return waitForDeposit$1(provider, options);
+}
+function waitForClaimable(provider, options) {
+	return waitForClaimable$1(provider, options, createTransport);
+}
+//#endregion
+export { Bridge, calculateWithdrawalHash, createBridge, fetchWithdrawal, fetchWithdrawals, waitForClaimable, waitForDeposit, watchDeposit, watchWithdrawal };
+
+//# sourceMappingURL=entry.bridge.browser.mjs.map

package/dist/entry.bridge.browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.bridge.browser.mjs","names":["BridgeInternal","watchDepositInternal","watchWithdrawalInternal","waitForDepositInternal","waitForClaimableInternal"],"sources":["../src/entry.bridge.browser.ts"],"sourcesContent":["/**\n * Bridge entry point (Browser) — injects gRPC-Web transport.\n */\nimport { createTransport } from './client/transport.browser'\nimport type { ChainInfoProvider } from './provider/types'\nimport type {\n  WatchDepositOptions,\n  WatchWithdrawalOptions,\n  DepositEvent,\n  WithdrawalEvent,\n  BridgeWatchHandle,\n} from './bridge/types'\nimport { Bridge as BridgeInternal } from './bridge/bridge'\nimport {\n  watchDeposit as watchDepositInternal,\n  watchWithdrawal as watchWithdrawalInternal,\n  waitForDeposit as waitForDepositInternal,\n  waitForClaimable as waitForClaimableInternal,\n} from './bridge/watch'\n\n// Re-export types and utilities unchanged\nexport type {\n  DepositOptions,\n  WithdrawOptions,\n  ClaimOptions,\n  WithdrawalInfo,\n  WithdrawalStatus,\n  RouteOptions,\n  Route,\n  RouteOperation,\n  BuildTransferMsgsOptions,\n  TransferTx,\n  OpHookOptions,\n  OpHookResult,\n  SignedOpHook,\n  TransferStatus,\n  DepositAndWaitOptions,\n  WithdrawAndClaimOptions,\n  DepositEvent,\n  WithdrawalEvent,\n  WatchDepositOptions,\n  WatchWithdrawalOptions,\n  BridgeWatchHandle,\n  RoutableAsset,\n} from './bridge/types'\nexport { calculateWithdrawalHash } from './bridge/hash'\nexport { fetchWithdrawals, fetchWithdrawal, type FetchWithdrawalsOptions } from './bridge/executor'\n\n// Transport-injecting wrappers — consumer API stays 3-param\nexport function createBridge(provider: ChainInfoProvider, routerUrl?: string): BridgeInternal {\n  return new BridgeInternal(provider, createTransport, routerUrl)\n}\n\n// Re-export Bridge class for type usage (consumers should use createBridge() for construction)\nexport { BridgeInternal as Bridge }\n\nexport function watchDeposit(\n  provider: ChainInfoProvider,\n  options: WatchDepositOptions,\n  callback: (event: DepositEvent) => void\n): BridgeWatchHandle {\n  return watchDepositInternal(provider, options, callback)\n}\n\nexport function watchWithdrawal(\n  provider: ChainInfoProvider,\n  options: WatchWithdrawalOptions,\n  callback: (event: WithdrawalEvent) => void\n): BridgeWatchHandle {\n  return watchWithdrawalInternal(provider, options, callback, createTransport)\n}\n\nexport function waitForDeposit(\n  provider: ChainInfoProvider,\n  options: WatchDepositOptions & { timeout?: number }\n): Promise<DepositEvent & { status: 'finalized' }> {\n  return waitForDepositInternal(provider, options)\n}\n\nexport function waitForClaimable(\n  provider: ChainInfoProvider,\n  options: WatchWithdrawalOptions & { timeout?: number }\n): Promise<WithdrawalEvent & { status: 'claimable' }> {\n  return waitForClaimableInternal(provider, options, createTransport)\n}\n"],"mappings":";;;;;;AAiDA,SAAgB,aAAa,UAA6B,WAAoC;AAC5F,QAAO,IAAIA,OAAe,UAAU,iBAAiB,UAAU;;AAMjE,SAAgB,aACd,UACA,SACA,UACmB;AACnB,QAAOC,eAAqB,UAAU,SAAS,SAAS;;AAG1D,SAAgB,gBACd,UACA,SACA,UACmB;AACnB,QAAOC,kBAAwB,UAAU,SAAS,UAAU,gBAAgB;;AAG9E,SAAgB,eACd,UACA,SACiD;AACjD,QAAOC,iBAAuB,UAAU,QAAQ;;AAGlD,SAAgB,iBACd,UACA,SACoD;AACpD,QAAOC,mBAAyB,UAAU,SAAS,gBAAgB"}

package/dist/entry.bridge.node.d.mts

@@ -0,0 +1,21 @@
+import { a as ChainInfoProvider } from "./types-DGrP9Ro_.mjs";
+import { C as WithdrawOptions, E as WithdrawalStatus, S as WithdrawAndClaimOptions, T as WithdrawalInfo, _ as SignedOpHook, a as BridgeWatchHandle, b as WatchDepositOptions, c as DepositAndWaitOptions, d as OpHookOptions, f as OpHookResult, g as RouteOptions, h as RouteOperation, i as fetchWithdrawals, l as DepositEvent, m as Route, n as FetchWithdrawalsOptions, o as BuildTransferMsgsOptions, p as RoutableAsset, r as fetchWithdrawal, s as ClaimOptions, t as Bridge, u as DepositOptions, v as TransferStatus, w as WithdrawalEvent, x as WatchWithdrawalOptions, y as TransferTx } from "./bridge-cQoOjppA.mjs";
+import { t as calculateWithdrawalHash } from "./hash-Doo89wm3.mjs";
+
+//#region src/entry.bridge.node.d.ts
+declare function createBridge(provider: ChainInfoProvider, routerUrl?: string): Bridge;
+declare function watchDeposit(provider: ChainInfoProvider, options: WatchDepositOptions, callback: (event: DepositEvent) => void): BridgeWatchHandle;
+declare function watchWithdrawal(provider: ChainInfoProvider, options: WatchWithdrawalOptions, callback: (event: WithdrawalEvent) => void): BridgeWatchHandle;
+declare function waitForDeposit(provider: ChainInfoProvider, options: WatchDepositOptions & {
+  timeout?: number;
+}): Promise<DepositEvent & {
+  status: 'finalized';
+}>;
+declare function waitForClaimable(provider: ChainInfoProvider, options: WatchWithdrawalOptions & {
+  timeout?: number;
+}): Promise<WithdrawalEvent & {
+  status: 'claimable';
+}>;
+//#endregion
+export { Bridge, type BridgeWatchHandle, type BuildTransferMsgsOptions, type ClaimOptions, type DepositAndWaitOptions, type DepositEvent, type DepositOptions, type FetchWithdrawalsOptions, type OpHookOptions, type OpHookResult, type RoutableAsset, type Route, type RouteOperation, type RouteOptions, type SignedOpHook, type TransferStatus, type TransferTx, type WatchDepositOptions, type WatchWithdrawalOptions, type WithdrawAndClaimOptions, type WithdrawOptions, type WithdrawalEvent, type WithdrawalInfo, type WithdrawalStatus, calculateWithdrawalHash, createBridge, fetchWithdrawal, fetchWithdrawals, waitForClaimable, waitForDeposit, watchDeposit, watchWithdrawal };
+//# sourceMappingURL=entry.bridge.node.d.mts.map

package/dist/entry.bridge.node.mjs

@@ -0,0 +1,25 @@
+import { t as createTransport } from "./transport.node-DXcJtCnx.mjs";
+import { a as watchWithdrawal$1, c as fetchWithdrawals, i as watchDeposit$1, n as waitForClaimable$1, o as calculateWithdrawalHash, r as waitForDeposit$1, s as fetchWithdrawal, t as Bridge } from "./bridge-DL-q-7P7.mjs";
+//#region src/entry.bridge.node.ts
+/**
+* Bridge entry point (Node.js) — injects native gRPC transport.
+*/
+function createBridge(provider, routerUrl) {
+	return new Bridge(provider, createTransport, routerUrl);
+}
+function watchDeposit(provider, options, callback) {
+	return watchDeposit$1(provider, options, callback);
+}
+function watchWithdrawal(provider, options, callback) {
+	return watchWithdrawal$1(provider, options, callback, createTransport);
+}
+function waitForDeposit(provider, options) {
+	return waitForDeposit$1(provider, options);
+}
+function waitForClaimable(provider, options) {
+	return waitForClaimable$1(provider, options, createTransport);
+}
+//#endregion
+export { Bridge, calculateWithdrawalHash, createBridge, fetchWithdrawal, fetchWithdrawals, waitForClaimable, waitForDeposit, watchDeposit, watchWithdrawal };
+
+//# sourceMappingURL=entry.bridge.node.mjs.map

package/dist/entry.bridge.node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.bridge.node.mjs","names":["BridgeInternal","watchDepositInternal","watchWithdrawalInternal","waitForDepositInternal","waitForClaimableInternal"],"sources":["../src/entry.bridge.node.ts"],"sourcesContent":["/**\n * Bridge entry point (Node.js) — injects native gRPC transport.\n */\nimport { createTransport } from './client/transport.node'\nimport type { ChainInfoProvider } from './provider/types'\nimport type {\n  WatchDepositOptions,\n  WatchWithdrawalOptions,\n  DepositEvent,\n  WithdrawalEvent,\n  BridgeWatchHandle,\n} from './bridge/types'\nimport { Bridge as BridgeInternal } from './bridge/bridge'\nimport {\n  watchDeposit as watchDepositInternal,\n  watchWithdrawal as watchWithdrawalInternal,\n  waitForDeposit as waitForDepositInternal,\n  waitForClaimable as waitForClaimableInternal,\n} from './bridge/watch'\n\n// Re-export types and utilities unchanged\nexport type {\n  DepositOptions,\n  WithdrawOptions,\n  ClaimOptions,\n  WithdrawalInfo,\n  WithdrawalStatus,\n  RouteOptions,\n  Route,\n  RouteOperation,\n  BuildTransferMsgsOptions,\n  TransferTx,\n  OpHookOptions,\n  OpHookResult,\n  SignedOpHook,\n  TransferStatus,\n  DepositAndWaitOptions,\n  WithdrawAndClaimOptions,\n  DepositEvent,\n  WithdrawalEvent,\n  WatchDepositOptions,\n  WatchWithdrawalOptions,\n  BridgeWatchHandle,\n  RoutableAsset,\n} from './bridge/types'\nexport { calculateWithdrawalHash } from './bridge/hash'\nexport { fetchWithdrawals, fetchWithdrawal, type FetchWithdrawalsOptions } from './bridge/executor'\n\n// Transport-injecting wrappers — consumer API stays 3-param\nexport function createBridge(provider: ChainInfoProvider, routerUrl?: string): BridgeInternal {\n  return new BridgeInternal(provider, createTransport, routerUrl)\n}\n\n// Re-export Bridge class for type usage (consumers should use createBridge() for construction)\nexport { BridgeInternal as Bridge }\n\nexport function watchDeposit(\n  provider: ChainInfoProvider,\n  options: WatchDepositOptions,\n  callback: (event: DepositEvent) => void\n): BridgeWatchHandle {\n  return watchDepositInternal(provider, options, callback)\n}\n\nexport function watchWithdrawal(\n  provider: ChainInfoProvider,\n  options: WatchWithdrawalOptions,\n  callback: (event: WithdrawalEvent) => void\n): BridgeWatchHandle {\n  return watchWithdrawalInternal(provider, options, callback, createTransport)\n}\n\nexport function waitForDeposit(\n  provider: ChainInfoProvider,\n  options: WatchDepositOptions & { timeout?: number }\n): Promise<DepositEvent & { status: 'finalized' }> {\n  return waitForDepositInternal(provider, options)\n}\n\nexport function waitForClaimable(\n  provider: ChainInfoProvider,\n  options: WatchWithdrawalOptions & { timeout?: number }\n): Promise<WithdrawalEvent & { status: 'claimable' }> {\n  return waitForClaimableInternal(provider, options, createTransport)\n}\n"],"mappings":";;;;;;AAiDA,SAAgB,aAAa,UAA6B,WAAoC;AAC5F,QAAO,IAAIA,OAAe,UAAU,iBAAiB,UAAU;;AAMjE,SAAgB,aACd,UACA,SACA,UACmB;AACnB,QAAOC,eAAqB,UAAU,SAAS,SAAS;;AAG1D,SAAgB,gBACd,UACA,SACA,UACmB;AACnB,QAAOC,kBAAwB,UAAU,SAAS,UAAU,gBAAgB;;AAG9E,SAAgB,eACd,UACA,SACiD;AACjD,QAAOC,iBAAuB,UAAU,QAAQ;;AAGlD,SAAgB,iBACd,UACA,SACoD;AACpD,QAAOC,mBAAyB,UAAU,SAAS,gBAAgB"}

package/dist/entry.browser.d.mts

@@ -0,0 +1,49 @@
+import { At as ChainConfig, Bo as AccountInfo, Br as INIT_COIN_TYPE, Bt as BroadcastResult, Ca as Message, Ci as AbiRegistryFor, Cn as Subscription, Ct as ChainContextOptions, Di as GetTxOptionsFor, Dt as NoSignerError, Ei as GetTxOptions, Et as GetTokenInfoOptions, Gr as DEFAULT_BECH32_PREFIX, Ho as getAccount, Hr as MnemonicKeyGenerateOptions, Ht as SignBroadcastOptions, I as abi, It as createChainConfig, Kr as Key, Kt as EventFilter, Lr as COIN_TYPE, Mt as CoreMsgMethods, Oi as TxNotFoundError, Rr as CoinType, Sa as JsonMsg, Si as AbiRegistry, St as ChainContext, Ti as DecodedTxMessage, Tt as GetBalanceOptions, Uo as Coins, Ur as MnemonicKeyOptions, Vo as AuthClient, Vr as MnemonicKey, Vt as BroadcastResultWithWait, Wo as DecCoins, Wr as RawKey, Zt as WaitForEventOptions, _i as UnsignedTx, a as ChainInfoProvider, aa as BroadcastErrorCategory, ai as buildStdFee, as as coins, bi as MultisigPublicKey, bs as TransportOptions, bt as TypedFactoryOptions, ca as HeaderConflictError, cs as parseDecCoin, da as TimeoutError, ga as GasPriceClient, gi as MultisigSignature, gt as resolveTokenContract, h as Client$1, ht as WasmEnabled, i as ChainInfoForType, ia as BroadcastError, is as coin, jt as ChainConfigBuilder, kt as TokenContract, la as InitiaError, ls as Numeric, m as ChainType, mt as MoveEnabled, n as ChainDataProvider, na as AssetNotFoundError, ns as CoinLike, oa as ChainNotFoundError, oi as createSignedTx, os as decCoin, pa as isNotFoundError, pi as makeStdSignDoc, pt as EvmEnabled, r as ChainInfo, ra as AuthenticationError, rs as DecCoin, ss as parseCoin, ta as AccountNotFoundError, ts as Coin, ua as SimulationError, ui as makeAminoSignBytes, vi as CompactBitArray, vt as TypedContextFactory, wa as MsgInput, wi as DecodedTx, wt as GetAccountOptions, xi as encodeMultisigAminoPubKey, ya as getGasPrices, yi as MultiSignature, yt as TypedContextOptions, zr as HDPath } from "./types-DGrP9Ro_.mjs";
+import { Transport } from "@connectrpc/connect";
+
+//#region src/client/transport.browser.d.ts
+/**
+ * Create a gRPC-web transport for browsers.
+ *
+ * Uses HTTP/1.1 or HTTP/2 with gRPC-web protocol.
+ * Requires gRPC-web enabled endpoints.
+ *
+ * @param chainInfo - Chain configuration with endpoint URLs
+ * @param options - Transport options
+ * @returns Transport instance
+ *
+ * @example
+ * ```typescript
+ * import { createTransport } from 'initia.js'
+ *
+ * const transport = createTransport(chainInfo)
+ * const client = createClientWithTransport(chainInfo, transport)
+ * ```
+ */
+declare function createTransport(chainInfo: ChainInfo, options?: TransportOptions): Transport;
+//#endregion
+//#region src/entry.browser.d.ts
+declare const createInitiaContext: TypedContextFactory<"initia">;
+declare const createMinievmContext: TypedContextFactory<"minievm">;
+declare const createMiniwasmContext: TypedContextFactory<"miniwasm">;
+declare const createMinimoveContext: TypedContextFactory<"minimove">;
+declare const createCosmosContext: TypedContextFactory<"other">;
+/**
+ * Create a ChainContext from chain info (browser).
+ *
+ * Note: This imports all chain configs at runtime for dynamic resolution.
+ * If your chain type is known at build time, prefer the typed factories
+ * (createInitiaContext, createMinievmContext, etc.) for smaller bundles.
+ */
+declare const createChainContext: <T extends ChainType>(chainInfo: ChainInfo & {
+  chainType: T;
+}, options?: ChainContextOptions) => ChainContext<T>;
+/**
+ * Create a gRPC client from chain info (browser).
+ *
+ * Note: Imports all chain configs. Prefer per-chain subpath imports for smaller bundles.
+ */
+declare function createClient(chainInfo: ChainInfo, options?: TransportOptions): Client$1;
+//#endregion
+export { AbiRegistry, AbiRegistryFor, AccountInfo, AccountNotFoundError, AssetNotFoundError, AuthClient, AuthenticationError, BroadcastError, BroadcastErrorCategory, BroadcastResult, BroadcastResultWithWait, COIN_TYPE, ChainConfig, ChainConfigBuilder, ChainContext, ChainContextOptions, ChainDataProvider, ChainInfo, ChainInfoForType, ChainInfoProvider, ChainNotFoundError, Coin, CoinLike, CoinType, Coins, CompactBitArray, CoreMsgMethods, DEFAULT_BECH32_PREFIX, DecCoin, DecCoins, DecodedTx, DecodedTxMessage, EventFilter, EvmEnabled, GasPriceClient, GetAccountOptions, GetBalanceOptions, GetTokenInfoOptions, GetTxOptions, GetTxOptionsFor, HDPath, HeaderConflictError, INIT_COIN_TYPE, InitiaError, JsonMsg, Key, Message, MnemonicKey, MnemonicKeyGenerateOptions, MnemonicKeyOptions, MoveEnabled, MsgInput, MultiSignature, MultisigPublicKey, MultisigSignature, NoSignerError, Numeric, RawKey, SignBroadcastOptions, SimulationError, Subscription, TimeoutError, TokenContract, TxNotFoundError, TypedContextFactory, TypedContextOptions, TypedFactoryOptions, UnsignedTx, WaitForEventOptions, WasmEnabled, abi, buildStdFee, coin, coins, createChainConfig, createChainContext, createClient, createCosmosContext, createInitiaContext, createMinievmContext, createMinimoveContext, createMiniwasmContext, createSignedTx, createTransport, decCoin, encodeMultisigAminoPubKey, getAccount, getGasPrices, isNotFoundError, makeAminoSignBytes, makeStdSignDoc, parseCoin, parseDecCoin, resolveTokenContract };
+//# sourceMappingURL=entry.browser.d.mts.map

package/dist/entry.browser.mjs

@@ -0,0 +1,46 @@
+import { a as ChainNotFoundError, c as InitiaError, f as SimulationError, g as isNotFoundError, i as BroadcastError, n as AssetNotFoundError, p as TimeoutError, r as AuthenticationError, s as HeaderConflictError, t as AccountNotFoundError } from "./errors-CN1MFOLv.mjs";
+import { a as coins, c as parseDecCoin, n as DecCoin, o as decCoin, r as coin, s as parseCoin, t as Coin } from "./coin-DPWbtAFA.mjs";
+import { c as getGasPrices, d as Coins, f as DecCoins, l as getAccount, o as UnsignedTx } from "./broadcast-De8MdmYa.mjs";
+import { t as Message } from "./types-CSS5rfW1.mjs";
+import { a as CompactBitArray, c as encodeMultisigAminoPubKey, o as MultiSignature, s as MultisigPublicKey } from "./public-key-DV-uGaUC.mjs";
+import { t as TxNotFoundError } from "./get-tx-0P40z_A4.mjs";
+import { l as makeStdSignDoc, n as createSignedTx, o as makeAminoSignBytes, t as buildStdFee } from "./sign-DqagxLcg.mjs";
+import { a as HDPath, c as RawKey, i as COIN_TYPE, l as DEFAULT_BECH32_PREFIX, n as resolveClient, o as INIT_COIN_TYPE, r as resolveTokenContract, s as MnemonicKey, t as cosmosContextConfig, u as Key } from "./cosmos-Bqh8qNfP.mjs";
+import { _ as NoSignerError, g as createChainConfig, h as ChainConfigBuilder, v as buildChainContextFactory } from "./types_pb-K7pKBvcg.mjs";
+import { t as abi } from "./abi-helpers-DdwdqhMQ.mjs";
+import { n as resolveRegistry, r as resolveServices, t as resolveMsgs } from "./resolve-DdtY7KDz.mjs";
+import { t as initiaContextConfig } from "./initia-Cj4bZ1dR.mjs";
+import { t as minievmContextConfig } from "./minievm-DZ8AhnD8.mjs";
+import { t as minimoveContextConfig } from "./minimove-B8U85g-_.mjs";
+import { t as miniwasmContextConfig } from "./miniwasm-CB0XfStg.mjs";
+import { n as buildTypedFactory } from "./typed-context-Cg0If0M9.mjs";
+import { t as createTransport } from "./transport.browser-CCUWv3ta.mjs";
+//#region src/entry.browser.ts
+const createInitiaContext = /* @__PURE__ */ buildTypedFactory("initia", createTransport, initiaContextConfig[0], initiaContextConfig[1]);
+const createMinievmContext = /* @__PURE__ */ buildTypedFactory("minievm", createTransport, minievmContextConfig[0], minievmContextConfig[1]);
+const createMiniwasmContext = /* @__PURE__ */ buildTypedFactory("miniwasm", createTransport, miniwasmContextConfig[0], miniwasmContextConfig[1]);
+const createMinimoveContext = /* @__PURE__ */ buildTypedFactory("minimove", createTransport, minimoveContextConfig[0], minimoveContextConfig[1]);
+const createCosmosContext = /* @__PURE__ */ buildTypedFactory("other", createTransport, cosmosContextConfig[0], cosmosContextConfig[1]);
+/**
+* Create a ChainContext from chain info (browser).
+*
+* Note: This imports all chain configs at runtime for dynamic resolution.
+* If your chain type is known at build time, prefer the typed factories
+* (createInitiaContext, createMinievmContext, etc.) for smaller bundles.
+*/
+const createChainContext = /* @__PURE__ */ buildChainContextFactory(createTransport, resolveServices, resolveMsgs, {
+	tokenResolver: (client, chainType, token, sender) => resolveTokenContract(client, chainType, token, sender),
+	getTypeRegistry: resolveRegistry
+});
+/**
+* Create a gRPC client from chain info (browser).
+*
+* Note: Imports all chain configs. Prefer per-chain subpath imports for smaller bundles.
+*/
+function createClient(chainInfo, options) {
+	return resolveClient(chainInfo, createTransport(chainInfo, options));
+}
+//#endregion
+export { AccountNotFoundError, AssetNotFoundError, AuthenticationError, BroadcastError, COIN_TYPE, ChainConfigBuilder, ChainNotFoundError, Coin, Coins, CompactBitArray, DEFAULT_BECH32_PREFIX, DecCoin, DecCoins, HDPath, HeaderConflictError, INIT_COIN_TYPE, InitiaError, Key, Message, MnemonicKey, MultiSignature, MultisigPublicKey, NoSignerError, RawKey, SimulationError, TimeoutError, TxNotFoundError, UnsignedTx, abi, buildStdFee, coin, coins, createChainConfig, createChainContext, createClient, createCosmosContext, createInitiaContext, createMinievmContext, createMinimoveContext, createMiniwasmContext, createSignedTx, createTransport, decCoin, encodeMultisigAminoPubKey, getAccount, getGasPrices, isNotFoundError, makeAminoSignBytes, makeStdSignDoc, parseCoin, parseDecCoin, resolveTokenContract };
+
+//# sourceMappingURL=entry.browser.mjs.map

package/dist/entry.browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.browser.mjs","names":[],"sources":["../src/entry.browser.ts"],"sourcesContent":["/**\n * Browser entry point for initia.js\n *\n * Uses gRPC-web transport compatible with all modern browsers.\n */\n\nexport * from './index'\n\nimport type { ChainInfo } from './provider/types'\nimport type { TransportOptions } from './client/transport-common'\nimport { createTransport } from './client/transport.browser'\nimport type { Client } from './client/types'\nimport { resolveServices, resolveRegistry, resolveMsgs } from './chains/resolve'\nimport { resolveClient } from './client/resolve-client'\nimport { buildChainContextFactory } from './wallet/chain-context'\nimport { buildTypedFactory } from './wallet/typed-context'\nimport {\n  resolveTokenContract,\n  type EvmEnabled,\n  type WasmEnabled,\n  type MoveEnabled,\n} from './token/resolver'\n\n// Per-chain context configs (tree-shakeable — each imports only its own chain proto)\nimport { initiaContextConfig } from './contexts/initia'\nimport { minievmContextConfig } from './contexts/minievm'\nimport { minimoveContextConfig } from './contexts/minimove'\nimport { miniwasmContextConfig } from './contexts/miniwasm'\nimport { cosmosContextConfig } from './contexts/cosmos'\n\nexport { createTransport }\n\n// =============================================================================\n// Per-chain typed factories (tree-shakeable)\n// =============================================================================\n\nexport const createInitiaContext = /* @__PURE__ */ buildTypedFactory(\n  'initia',\n  createTransport,\n  initiaContextConfig[0],\n  initiaContextConfig[1]\n)\nexport const createMinievmContext = /* @__PURE__ */ buildTypedFactory(\n  'minievm',\n  createTransport,\n  minievmContextConfig[0],\n  minievmContextConfig[1]\n)\nexport const createMiniwasmContext = /* @__PURE__ */ buildTypedFactory(\n  'miniwasm',\n  createTransport,\n  miniwasmContextConfig[0],\n  miniwasmContextConfig[1]\n)\nexport const createMinimoveContext = /* @__PURE__ */ buildTypedFactory(\n  'minimove',\n  createTransport,\n  minimoveContextConfig[0],\n  minimoveContextConfig[1]\n)\nexport const createCosmosContext = /* @__PURE__ */ buildTypedFactory(\n  'other',\n  createTransport,\n  cosmosContextConfig[0],\n  cosmosContextConfig[1]\n)\n\n// =============================================================================\n// Runtime-resolved APIs (import all chains via resolve.ts — tree-shaken if unused)\n// =============================================================================\n\n/**\n * Create a ChainContext from chain info (browser).\n *\n * Note: This imports all chain configs at runtime for dynamic resolution.\n * If your chain type is known at build time, prefer the typed factories\n * (createInitiaContext, createMinievmContext, etc.) for smaller bundles.\n */\nexport const createChainContext = /* @__PURE__ */ buildChainContextFactory(\n  createTransport,\n  resolveServices,\n  resolveMsgs,\n  {\n    tokenResolver: (client, chainType, token, sender) =>\n      resolveTokenContract(\n        client as EvmEnabled & WasmEnabled & MoveEnabled,\n        chainType as 'minievm',\n        token,\n        sender\n      ),\n    getTypeRegistry: resolveRegistry,\n  }\n)\n\n/**\n * Create a gRPC client from chain info (browser).\n *\n * Note: Imports all chain configs. Prefer per-chain subpath imports for smaller bundles.\n */\nexport function createClient(chainInfo: ChainInfo, options?: TransportOptions): Client {\n  const transport = createTransport(chainInfo, options)\n  return resolveClient(chainInfo, transport)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoCA,MAAa,sBAAsC,kCACjD,UACA,iBACA,oBAAoB,IACpB,oBAAoB,GACrB;AACD,MAAa,uBAAuC,kCAClD,WACA,iBACA,qBAAqB,IACrB,qBAAqB,GACtB;AACD,MAAa,wBAAwC,kCACnD,YACA,iBACA,sBAAsB,IACtB,sBAAsB,GACvB;AACD,MAAa,wBAAwC,kCACnD,YACA,iBACA,sBAAsB,IACtB,sBAAsB,GACvB;AACD,MAAa,sBAAsC,kCACjD,SACA,iBACA,oBAAoB,IACpB,oBAAoB,GACrB;;;;;;;;AAaD,MAAa,qBAAqC,yCAChD,iBACA,iBACA,aACA;CACE,gBAAgB,QAAQ,WAAW,OAAO,WACxC,qBACE,QACA,WACA,OACA,OACD;CACH,iBAAiB;CAClB,CACF;;;;;;AAOD,SAAgB,aAAa,WAAsB,SAAoC;AAErF,QAAO,cAAc,WADH,gBAAgB,WAAW,QAAQ,CACX"}

package/dist/entry.chain.initia.browser.d.mts

@@ -0,0 +1,8 @@
+import { F as initiaChain, bs as TransportOptions, j as InitiaClient, r as ChainInfo, vt as TypedContextFactory } from "./types-DGrP9Ro_.mjs";
+
+//#region src/entry.chain.initia.browser.d.ts
+declare const createInitiaContext: TypedContextFactory<"initia">;
+declare function createClient(chainInfo: ChainInfo, options?: TransportOptions): InitiaClient;
+//#endregion
+export { createClient, createInitiaContext, initiaChain };
+//# sourceMappingURL=entry.chain.initia.browser.d.mts.map

package/dist/entry.chain.initia.browser.mjs

@@ -0,0 +1,17 @@
+import { t as initiaChain } from "./initia-B8l_x6sT.mjs";
+import { n as createClientWithConfig, t as initiaContextConfig } from "./initia-Cj4bZ1dR.mjs";
+import { n as buildTypedFactory } from "./typed-context-Cg0If0M9.mjs";
+import { t as createTransport } from "./transport.browser-CCUWv3ta.mjs";
+//#region src/entry.chain.initia.browser.ts
+/**
+* Per-chain entry point: initia.js/initia (Browser)
+* Only includes initia L1 proto — no minievm/minimove/miniwasm.
+*/
+const createInitiaContext = /* @__PURE__ */ buildTypedFactory("initia", createTransport, initiaContextConfig[0], initiaContextConfig[1]);
+function createClient(chainInfo, options) {
+	return createClientWithConfig(chainInfo, createTransport(chainInfo, options));
+}
+//#endregion
+export { createClient, createInitiaContext, initiaChain };
+
+//# sourceMappingURL=entry.chain.initia.browser.mjs.map

package/dist/entry.chain.initia.browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.chain.initia.browser.mjs","names":[],"sources":["../src/entry.chain.initia.browser.ts"],"sourcesContent":["/**\n * Per-chain entry point: initia.js/initia (Browser)\n * Only includes initia L1 proto — no minievm/minimove/miniwasm.\n */\nimport { createTransport } from './client/transport.browser'\nimport { buildTypedFactory } from './wallet/typed-context'\nimport { initiaContextConfig } from './contexts/initia'\nimport { createClientWithConfig } from './client/create-client-initia'\nimport type { ChainInfo } from './provider/types'\nimport type { TransportOptions } from './client/transport-common'\nimport type { InitiaClient } from './client/types'\n\nexport { initiaChain } from './chains/initia'\nexport const createInitiaContext = /* @__PURE__ */ buildTypedFactory(\n  'initia', createTransport, initiaContextConfig[0], initiaContextConfig[1]\n)\nexport function createClient(chainInfo: ChainInfo, options?: TransportOptions): InitiaClient {\n  const transport = createTransport(chainInfo, options)\n  return createClientWithConfig(chainInfo, transport)\n}\n"],"mappings":";;;;;;;;;AAaA,MAAa,sBAAsC,kCACjD,UAAU,iBAAiB,oBAAoB,IAAI,oBAAoB,GACxE;AACD,SAAgB,aAAa,WAAsB,SAA0C;AAE3F,QAAO,uBAAuB,WADZ,gBAAgB,WAAW,QAAQ,CACF"}

package/dist/entry.chain.initia.node.d.mts

@@ -0,0 +1,8 @@
+import { F as initiaChain, bs as TransportOptions, j as InitiaClient, r as ChainInfo, vt as TypedContextFactory } from "./types-DGrP9Ro_.mjs";
+
+//#region src/entry.chain.initia.node.d.ts
+declare const createInitiaContext: TypedContextFactory<"initia">;
+declare function createClient(chainInfo: ChainInfo, options?: TransportOptions): InitiaClient;
+//#endregion
+export { createClient, createInitiaContext, initiaChain };
+//# sourceMappingURL=entry.chain.initia.node.d.mts.map

package/dist/entry.chain.initia.node.mjs

@@ -0,0 +1,17 @@
+import { t as createTransport } from "./transport.node-DXcJtCnx.mjs";
+import { t as initiaChain } from "./initia-B8l_x6sT.mjs";
+import { n as createClientWithConfig, t as initiaContextConfig } from "./initia-Cj4bZ1dR.mjs";
+import { n as buildTypedFactory } from "./typed-context-Cg0If0M9.mjs";
+//#region src/entry.chain.initia.node.ts
+/**
+* Per-chain entry point: initia.js/initia (Node.js)
+* Only includes initia L1 proto — no minievm/minimove/miniwasm.
+*/
+const createInitiaContext = /* @__PURE__ */ buildTypedFactory("initia", createTransport, initiaContextConfig[0], initiaContextConfig[1]);
+function createClient(chainInfo, options) {
+	return createClientWithConfig(chainInfo, createTransport(chainInfo, options));
+}
+//#endregion
+export { createClient, createInitiaContext, initiaChain };
+
+//# sourceMappingURL=entry.chain.initia.node.mjs.map