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

package/README.md

@@ -1,235 +1,302 @@
 # initia.js
-Initia.js is a TypeScript-written JavaScript SDK tailored for the Initia blockchain, enhancing the development experience with user-friendly TypeScript definitions and integration with Initia's core data structures.
 
-## Main Features
-- **Improved TypeScript Definitions**: Offers comprehensive integration with Initia core data structures for an enhanced developer experience.
-- **Core Layer**: Includes key management, BCS serialization, and support for initia.proto.
-- **Client Layer**: Facilitates API request generation and REST provider interaction.
+TypeScript SDK for Initia and its rollup ecosystem.
 
+## Features
 
-## Installation
+- Multi-VM support: Move, EVM, and CosmWasm contracts in one SDK
+- Type-safe gRPC client with Proxy-based service access
+- Typed context factories: `createInitiaContext`, `createMinievmContext`, `createMiniwasmContext`, `createMinimoveContext`
+- VM-agnostic token abstraction (Fungible Asset, ERC20, CW20)
+- OP Bridge and Router API for L1/L2 cross-chain transfers
+- Automatic Amino conversion via proto schema options
+- Transaction decoding with VM-aware arg enrichment (`ctx.getTx()`)
+- ABI-driven contracts: BCS (Move), `abitype` (EVM), JSON schema (CosmWasm)
+- CometBFT HTTP RPC client (23 endpoints) and EVM JSON-RPC client
+- Signer bridge adapters for viem and ethers.js interop
+- Cosmos chain-registry integration (Osmosis, Noble, etc.)
+- Browser-native with gRPC-Web transport, zero Node.js polyfills
+- WebSocket subscriptions and event parsing
+- Codegen CLI (`npx abigen`) for Move, EVM, and CosmWasm ABIs
+- tree-shakeable subpath exports
 
-Before installation, check the latest version of [npm](https://www.npmjs.com/package/@initia/initia.js): 
+## Supported Environments
 
-```bash
-npm install @initia/initia.js
-```
+| Environment | Version | Transport |
+|-------------|---------|-----------|
+| Node.js | >= 22 | Native gRPC (HTTP/2) |
+| Browser | Modern | gRPC-Web |
+| Bun | >= 1.3.11 | Native gRPC (HTTP/2) |
+| Deno | >= 2.5 | Native gRPC (HTTP/2) |
 
-## Usage
+## Compatibility
 
-The usage section of this document provides detailed explanations and code examples of the most commonly used classes of the Initia.js library, which can be utilized both in a Node.js environment and within a browser.
+### Chain Versions
 
-### REST client 
+| initia.js | Initia L1 | Minievm | Minimove | Miniwasm | OPinit |
+|-----------|-----------|---------|----------|----------|--------|
+| v2.0.x | v1.4.0 | v1.2.15 | v1.1.11\* | v1.2.11 | v1.3.0 |
 
-**RESTClient** class facilitates interaction with the Initia blockchain.
+\* Minimove v1.1.11 uses Initia v1.2.2 move proto — governance messages (Whitelist/Delist) differ from v1.4.0. Core move execute/view/query are compatible.
 
-```typescript
-import { RESTClient } from '@initia/initia.js'
+### Proto Dependencies
 
-const rest = new RESTClient('https://rest.testnet.initia.xyz', {
-  chainId: 'initiation-2',
-  gasPrices: '0.15uinit', // default gas prices
-  gasAdjustment: '1.75',  // default gas adjustment for fee estimation
-})
-```
+| initia.js | Cosmos SDK | IBC | CosmWasm | Connect (Oracle) |
+|-----------|-----------|-----|---------|-----------------|
+| v2.0.x | [`5a6ab7bc`][cs] | [`cc1d31ac`][ibc] | [`3c30b822`][cw] | [`ea643a0e`][co] |
 
+[cs]: https://buf.build/cosmos/cosmos-sdk/commits/5a6ab7bc14314acaa912d5e53aef1c2f
+[ibc]: https://buf.build/cosmos/ibc/commits/cc1d31ac98a0477580379346dab8e87b
+[cw]: https://buf.build/cosmwasm/wasmd/commits/3c30b822226c4bea96d5fad293a6e010
+[co]: https://buf.build/skip-mev/connect/commits/ea643a0e8c46420caa71d33530c84b46
 
-> **`gasPrices`** and **`gasAdjustment`**are optional, but essential for the fee estimation
+## Installation
 
+```bash
+npm install initia.js
+```
 
-### Key
+All proto dependencies are sourced from BSR (Buf Schema Registry) packages (`@buf/cosmos_cosmos-sdk`, `@buf/initia-labs_initia`, `@buf/initia-labs_minievm`, etc.) and bundled as regular dependencies — no registry configuration needed.
 
-An abstract key interface that enables transaction signing and provides Bech32 address and public key derivation from a public key. 
+## Which Provider?
 
-```typescript
-import { MnemonicKey } from '@initia/initia.js'
+- **Initia L1/L2** → `RegistryProvider` (default, zero config)
+- **Cosmos chains** (Osmosis, Noble, etc.) → `CosmosRegistryProvider`
+- **Custom/private endpoints** → `CustomProvider`
+- **CI/offline** → `PackageProvider`
 
-const key = new MnemonicKey({
-  mnemonic: 'bird upset ...  evil cigar', // (optional) if null, generate a new Mnemonic key
-  account: 0, // (optional) BIP44 account number. default = 0
-  index: 0, // (optional) BIP44 index number. default = 0
-  coinType: 60, // (optional) BIP44 coinType. default = 60
-})
-```
+Most users don't need to choose — `createInitiaContext({ network: 'mainnet' })` uses `RegistryProvider` automatically.
 
-#### Ledger Hardware Wallet
+## Quick Start
 
-For Ledger hardware wallet support, use [@initia/ledger-key](./ledger-key):
+### Query balance
 
 ```typescript
-import { LedgerKey } from '@initia/ledger-key'
+import { createInitiaContext } from 'initia.js'
 
-// e.g. `transport` from @ledgerhq/hw-transport-webhid / webusb / node-hid
-const key = await LedgerKey.create(transport)
-```
+const ctx = await createInitiaContext({ network: 'mainnet' })
 
-### BCS
+const { balance } = await ctx.client.bank.balance({
+  address: 'init1...',
+  denom: 'uinit',
+})
+console.log(balance?.amount)
+```
 
-**BCS**(Binary Canonical Serialization) is the binary encoding for Move resources and other non-module values published on-chain.  
+### Send tokens
 
 ```typescript
-import { bcs } from '@initia/initia.js'
-
-// serialize, serialize value to BCS and encode it to base64
-const serializedU64 = bcs
-  .u64() // type
-  .serialize(1234) // value 
-  .toBase64()
-
-// deserialize
-const deserializedU64 = bcs
-  .u64() // type
-  .parse(Uint8Array.from(Buffer.from(serializedU64, 'base64')))
-
-// vector
-const serializedVector = bcs
-  .vector(bcs.u64())
-  .serialize([123, 456, 789])
-  .toBase64()
-
-// option
-const serializedSome = bcs.option(bcs.u64()).serialize(123)
-const serializedNone = bcs.option(bcs.u64()).serialize(null)
+import { createInitiaContext, MnemonicKey, coin } from 'initia.js'
+
+const key = new MnemonicKey({ mnemonic: 'your mnemonic ...' })
+const ctx = await createInitiaContext({ network: 'mainnet', signer: key })
+
+const result = await ctx.signAndBroadcast([
+  ctx.msgs.bank.send({
+    fromAddress: ctx.address,
+    toAddress: 'init1recipient...',
+    amount: [coin('uinit', '1000000')],
+  }),
+])
+console.log(result.txHash)
 ```
 
-**Support types for BCS**
-> \`u8\`, \`u16\`, \`u32\`, \`u64\`, \`u128\`, \`u256\`, \`bool\`, \`vector\`, \`address\`, \`string\`, \`option\`, \`fixed_point32\`, \`fixed_point64\`, \`decimal128\`, \`decimal256\`
-
-### Msg 
-
-Msgs are objects whose end-goal is to trigger state-transitions. They are wrapped in transactions, which may contain one or more of them.
-
-* `MsgSend()` 
-
-Send coins to others.
+### Move contract call
 
 ```typescript
-import { MsgSend } from '@initia/initia.js'
+import { createMoveContract } from 'initia.js/move'
 
-const msg = new MsgSend(
-  'init1kdwzpz3wzvpdj90gtga4fw5zm9tk4cyrgnjauu',   // sender address
-  'init18sj3x80fdjc6gzfvwl7lf8sxcvuvqjpvcmp6np',   // recipient address
-  '1000uinit',                                     // send amount
-)
-```
+const coin = await createMoveContract(ctx, '0x1', 'coin')
 
-* `MsgDelegate()`
+const balance = await coin.view.balance({
+  typeArgs: ['0x1::native_uinit::Coin'],
+  args: ['init1owner...'],
+})
+const msg = coin.execute.transfer(ctx.address, {
+  typeArgs: ['0x1::native_uinit::Coin'],
+  args: ['init1recipient...', '1000000'],
+})
+await ctx.signAndBroadcast([msg])
+```
 
-Delegate governance coin to validators (staking).
+### EVM contract call
 
 ```typescript
-import { MsgDelegate } from '@initia/initia.js'
+import { createEvmContract, type Abi } from 'initia.js/evm'
 
-const msg = new MsgDelegate(
-  'init1kdwzpz3wzvpdj90gtga4fw5zm9tk4cyrgnjauu',             // delegator address
-  'initvaloper14qekdkj2nmmwea4ufg9n002a3pud23y8l3ep5z',      // validator's operator (valoper) address
-  '100000uinit',                                             // delegate amount
-)
-```
+const abi = [/* ERC-20 ABI */] as const satisfies Abi
+const erc20 = createEvmContract(ctx, '0xContractAddress', abi)
 
-* `MsgUndelegate()`
+const balance = await erc20.read.balanceOf('0xOwner')
+const msg = erc20.write.transfer(ctx.address, '0xRecipient', 1000n)
+await ctx.signAndBroadcast([msg])
+```
 
-Undelegate governance coin from validators (unstaking).
+### Event parsing
 
 ```typescript
-import { MsgUndelegate } from '@initia/initia.js'
+// Cosmos events — typed attribute extraction
+import { parseEventAttrs, parseMoveEventData } from 'initia.js/events'
 
-const msg = new MsgUndelegate(
-  'init1kdwzpz3wzvpdj90gtga4fw5zm9tk4cyrgnjauu',             // delegator address
-  'initvaloper14qekdkj2nmmwea4ufg9n002a3pud23y8l3ep5z',      // validator's operator (valoper) address
-  '100000uinit',                                             // undelegate amount
-)
-```
+const transfers = parseEventAttrs(result.events, 'transfer', ['recipient', 'sender', 'amount'])
+// → Array<{ recipient: string, sender: string, amount: string }>
 
-* `MsgExecute()`
+// Move events — auto JSON parse
+const withdraws = parseMoveEventData(result.events, '0x1::fungible_asset::WithdrawEvent')
+// → Array<{ store_addr: string, metadata_addr: string, amount: string }>
 
-Execute move contract function.
+// EVM logs — viem-powered typed decoding
+import { parseEventLogs } from 'initia.js/evm'
 
-```typescript
-import { MsgExecute } from '@initia/initia.js'
-
-const msg = new MsgExecute(
-  'init1kdwzpz3wzvpdj90gtga4fw5zm9tk4cyrgnjauu', // sender address
-  '0x1',                                         // owner of the module
-  'dex',                                         // name of the module
-  'swap_script',                                 // function name
-  [],                                            // type arguments
-  [                                              
-    bcs.address().serialize('0x2').toBase64(),   // arguments, BCS-encoded
-    bcs.address().serialize('0x3').toBase64(),   // arguments, BCS-encoded
-    bcs.u64().serialize(10000).toBase64()        // arguments, BCS-encoded
-  ]
-)
+const logs = parseEventLogs({ abi: erc20Abi, eventName: 'Transfer', logs: receipt.logs })
+logs[0].args.from // full autocomplete from ABI
 ```
 
-### Tx broadcasting&#x20;
+> **Note**: `parseEventLogs` returns addresses in EIP-55 checksum format (mixed-case), while on-chain RPC returns lowercase. Use `.toLowerCase()` when comparing with raw on-chain data.
 
-* `createAndSignTx()`
+### CometBFT RPC
 
-Create a wallet and sign transaction. &#x20;
+The `ctx.rpc` accessor provides a CometBFT HTTP RPC client covering 23 endpoints not available via gRPC. It is lazily initialized and automatically inherits `auth`, `headers`, and `timeoutMs` from the context. All methods accept per-request option overrides.
 
-```typescript
-import { Wallet, RESTClient, MnemonicKey, MsgSend } from '@initia/initia.js'
+**Endpoints by category:** blocks & headers (`block`, `blockByHash`, `blockResults`, `header`, `headerByHash`, `blockchain`, `blockSearch`), transactions (`tx`, `txSearch`, `unconfirmedTxs`, `numUnconfirmedTxs`), consensus (`validators`, `commit`, `consensusParams`, `consensusState`, `dumpConsensusState`), node (`status`, `health`, `netInfo`, `genesis`, `genesisChunked`), ABCI (`abciInfo`, `abciQuery`).
 
-const key = new MnemonicKey({
-  mnemonic: 
-    'moral wise tape glance grit gentle movie doll omit you pet soon enter year funny gauge digital supply cereal city ring egg repair coyote',
-})
+```typescript
+import { createInitiaContext } from 'initia.js'
 
-const rest = new RESTClient('https://rest.testnet.initia.xyz', {
-  chainId: 'initiation-2',
-  gasPrices: '0.15uinit', // default gas prices
-  gasAdjustment: '1.75',  // default gas adjustment for fee estimation
+const ctx = await createInitiaContext({
+  network: 'mainnet',
+  auth: { type: 'api-key', key: 'my-key' },
+  timeoutMs: 5000,
 })
 
-const wallet = new Wallet(rest, key)
-
-const sendMsg = new MsgSend(
-  'init14l3c2vxrdvu6y0sqykppey930s4kufsvt97aeu',   // sender address
-  'init18sj3x80fdjc6gzfvwl7lf8sxcvuvqjpvcmp6np',   // recipient address
-  '1000uinit',                                     // send amount
-)
-
-const signedTx = await wallet.createAndSignTx({
-  msgs: [sendMsg],
-  memo: 'sample memo',
-})
+// CometBFT RPC — auth/headers/timeoutMs forwarded automatically
+const blockResult = await ctx.rpc.blockResults(100)
+const txResult = await ctx.rpc.tx('A1B2C3...')
+const searchResult = await ctx.rpc.txSearch("message.action='/cosmos.bank.v1beta1.MsgSend'")
+const status = await ctx.rpc.status()
+const healthy = await ctx.rpc.health() // true/false, never throws
 ```
 
-When sending coins with `MsgSend`, sender address should be the same as wallet address.
+For minievm chains, `ctx.evmRpc` provides an Ethereum JSON-RPC client with the same option forwarding, including `getTransactionByHash()` and `getStorageAt()`.
 
-* `broadcast()`
+### Signer bridges
 
-`broadcast()` is the action that sends your transaction to the blockchain code.
+Use existing viem or ethers.js wallets as Cosmos signers:
 
 ```typescript
-const broadcastResult = await rest.tx.broadcast(signedTx)
-```
+import { viemAccountToSigner, keyToViemAccount } from 'initia.js/signer'
 
-### Queries&#x20;
+// viem private key → Cosmos signer
+const signer = viemAccountToSigner('0xprivateKey...')
 
-* `balance()`
+// RawKey → viem LocalAccount (for EVM dApps)
+const account = keyToViemAccount(rawKey)
+```
 
-Query the balance of the account.
+## Architecture
 
-```typescript
-const balances = await rest.bank.balance('init14l3c2vxrdvu6y0sqykppey930s4kufsvt97aeu')
+```
+Provider  -->  ChainInfo  -->  ChainContext
+(registry)     (chain data)    (client + signer + msgs)
 ```
 
-* `viewfunction()`
+### Which provider to use
 
-Obtain the return values of a Move view function.
+| Provider | Use case |
+|----------|----------|
+| `createRegistryProvider()` | **Default choice.** Fetches chain data from Initia registry. Works for all Initia L1/L2 chains. |
+| `CustomProvider` | Private chains, local testnets, or non-Initia chains with manual config. |
+| `CosmosRegistryProvider` | External Cosmos chains (Osmosis, Noble, etc.) via chain-registry npm package. |
+| `composeProviders(a, b)` | Combine multiple providers (e.g., Initia registry + Cosmos registry). |
 
 ```typescript
-const res = await rest.move.viewFunction(
-  '0x1',                                         // owner of the module
-  'dex',                                         // name of the module
-  'get_swap_simulation',                         // function name
-  [],                                            // type arguments
-  [       
-    bcs.address().serialize('0x2').toBase64(),   // arguments, BCS-encoded
-    bcs.address().serialize('0x3').toBase64(),   // arguments, BCS-encoded
-    bcs.u64().serialize(10000).toBase64()        // arguments, BCS-encoded
-  ]                           
+// Most users — just use this:
+const ctx = await createInitiaContext({ network: 'mainnet', signer: key })
+
+// For external Cosmos chains:
+import { CosmosRegistryProvider } from 'initia.js/cosmos'
+import { composeProviders } from 'initia.js/provider'
+const provider = composeProviders(
+  await createRegistryProvider({ network: 'mainnet' }),
+  new CosmosRegistryProvider(),
 )
 ```
+
+Domain-specific APIs are available via subpath exports:
+
+| Import path | Description |
+|-------------|-------------|
+| `initia.js` | Core types, keys, wallet, typed context factories |
+| `initia.js/client` | gRPC client, transport, interceptors |
+| `initia.js/tx` | Signing, serialization, Amino conversion |
+| `initia.js/msgs` | Module-namespaced message builders and decode |
+| `initia.js/move` | Move contracts, BCS encoding, ABI |
+| `initia.js/evm` | EVM contracts, ABI encoding, JSON-RPC client |
+| `initia.js/wasm` | CosmWasm contracts, JSON schema |
+| `initia.js/bridge` | OP Bridge, deposit/withdraw/claim, Router API |
+| `initia.js/provider` | Registry, custom, and composite providers |
+| `initia.js/signer` | Signer interfaces, KeyStore, viem/ethers bridges |
+| `initia.js/events` | Event parsing, WebSocket subscriptions |
+| `initia.js/util` | Address, hash, denom, formatting utilities |
+| `initia.js/usernames` | `.init` domain resolution |
+| `initia.js/cosmos` | Cosmos chain-registry integration (Osmosis, Noble, ...) |
+| `initia.js/vip` | VIP lock staking, gauge voting, rewards |
+| `initia.js/codegen` | ABI codegen for Move, EVM, CosmWasm |
+
+## Examples
+
+See the [examples/](./examples) directory for runnable scripts:
+
+**Getting started**
+
+- [query.ts](./examples/query.ts) -- Read-only gRPC queries
+- [send.ts](./examples/send.ts) -- Send tokens with high-level API
+- [send-amino.ts](./examples/send-amino.ts) -- Send tokens with Amino signing mode
+- [staking.ts](./examples/staking.ts) -- Delegate, redelegate, undelegate, claim rewards
+- [get-tx.ts](./examples/get-tx.ts) -- Decode transactions with VM-aware arg enrichment
+
+**Smart contracts**
+
+- [move-contract.ts](./examples/move-contract.ts) -- ABI-driven Move contract interactions
+- [move-typed.ts](./examples/move-typed.ts) -- Move contract with full type inference
+- [evm-contract.ts](./examples/evm-contract.ts) -- ABI-driven EVM contract interactions
+- [evm-typed.ts](./examples/evm-typed.ts) -- EVM contract with full type inference
+- [wasm-contract.ts](./examples/wasm-contract.ts) -- CosmWasm contract interactions
+- [wasm-typed.ts](./examples/wasm-typed.ts) -- CosmWasm contract with full type inference
+- [deploy-cw20.ts](./examples/deploy-cw20.ts) -- Deploy and interact with a CW20 token
+
+**RPC & low-level**
+
+- [evm-rpc.ts](./examples/evm-rpc.ts) -- EVM JSON-RPC (blocks, logs, receipts)
+- [evm-jsonrpc.ts](./examples/evm-jsonrpc.ts) -- EVM JSON-RPC direct calls
+- [auth-headers.ts](./examples/auth-headers.ts) -- API key / Bearer auth configuration
+- [block-subscription.ts](./examples/block-subscription.ts) -- WebSocket block/event subscriptions
+- [raw-send.ts](./examples/raw-send.ts) -- Send using raw BSR proto messages
+- [raw-query-historical.ts](./examples/raw-query-historical.ts) -- Query at historical block heights
+
+**Cross-chain**
+
+- [op-bridge.ts](./examples/op-bridge.ts) -- OP Bridge deposit, withdraw, and claim
+- [smart-route.ts](./examples/smart-route.ts) -- Router API for cross-chain transfers
+- [ibc-transfer.ts](./examples/ibc-transfer.ts) -- IBC transfers between Initia chains
+- [noble-ibc-transfer.ts](./examples/noble-ibc-transfer.ts) -- IBC from external Cosmos chains
+- [osmosis-custom-provider.ts](./examples/osmosis-custom-provider.ts) -- Custom provider for external Cosmos chains
+
+**Custom chains & modules**
+
+- [custom-chain.ts](./examples/custom-chain.ts) -- CustomProvider, CosmosRegistryProvider, composeProviders
+- [custom-rollup.ts](./examples/custom-rollup.ts) -- Add custom proto modules to rollup contexts
+
+**Utilities**
+
+- [usernames.ts](./examples/usernames.ts) -- `.init` domain resolution
+- [token.ts](./examples/token.ts) -- VM-agnostic token operations
+- [vip.ts](./examples/vip.ts) -- VIP lock staking, gauge voting, and reward claims
+- [address-utils.ts](./examples/address-utils.ts) -- Address type detection and profile lookup
+- [cache-management.ts](./examples/cache-management.ts) -- gRPC response cache control
+- [provider-assets.ts](./examples/provider-assets.ts) -- Provider asset and denom lookup
+- [keystore.ts](./examples/keystore.ts) -- KeyStore multi-key management
+
+## License
+
+[Apache-2.0](./LICENSE)

package/dist/abi-helpers-DdwdqhMQ.mjs

@@ -0,0 +1,51 @@
+//#region src/contracts/abi-helpers.ts
+/**
+* EVM ABI helper — preserves literal types without `as const satisfies Abi`.
+*
+* @example
+* ```typescript
+* const ERC20 = evmAbi([
+*   { type: 'function', name: 'balanceOf', inputs: [{ name: 'account', type: 'address' }], outputs: [{ name: '', type: 'uint256' }], stateMutability: 'view' },
+* ])
+* ```
+*/
+function evmAbi(abi) {
+	return abi;
+}
+/**
+* Move ABI helper — preserves literal types without `as const satisfies ReadonlyMoveModuleAbi`.
+*
+* @example
+* ```typescript
+* const COIN = moveAbi({
+*   address: '0x1', name: 'coin',
+*   friends: [], exposed_functions: [], structs: [],
+* })
+* ```
+*/
+function moveAbi(abi) {
+	return abi;
+}
+/**
+* Wasm schema helper — preserves literal types without `as const satisfies ReadonlyWasmContractSchema`.
+* Eliminates the need for nested `as const` on `required` arrays for inline literals.
+* Pre-assigned variables still require `as const` (e.g., `required: ['transfer'] as const`).
+*
+* @example
+* ```typescript
+* const CW20 = wasmAbi({
+*   execute: { oneOf: [{ required: ['transfer'], properties: { transfer: {} } }] },
+*   query: { oneOf: [{ required: ['balance'], properties: { balance: {} } }] },
+* })
+* ```
+*/
+function wasmAbi(schema) {
+	return schema;
+}
+function abi(abi) {
+	return abi;
+}
+//#endregion
+export { wasmAbi as i, evmAbi as n, moveAbi as r, abi as t };
+
+//# sourceMappingURL=abi-helpers-DdwdqhMQ.mjs.map

package/dist/abi-helpers-DdwdqhMQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi-helpers-DdwdqhMQ.mjs","names":[],"sources":["../src/contracts/abi-helpers.ts"],"sourcesContent":["import type { Abi } from 'abitype'\nimport type { ReadonlyMoveModuleAbi } from './move/types'\nimport type { ReadonlyWasmContractSchema } from './wasm/types'\n\n/**\n * EVM ABI helper — preserves literal types without `as const satisfies Abi`.\n *\n * @example\n * ```typescript\n * const ERC20 = evmAbi([\n *   { type: 'function', name: 'balanceOf', inputs: [{ name: 'account', type: 'address' }], outputs: [{ name: '', type: 'uint256' }], stateMutability: 'view' },\n * ])\n * ```\n */\nexport function evmAbi<const T extends Abi>(abi: T): T {\n  return abi\n}\n\n/**\n * Move ABI helper — preserves literal types without `as const satisfies ReadonlyMoveModuleAbi`.\n *\n * @example\n * ```typescript\n * const COIN = moveAbi({\n *   address: '0x1', name: 'coin',\n *   friends: [], exposed_functions: [], structs: [],\n * })\n * ```\n */\nexport function moveAbi<const T extends ReadonlyMoveModuleAbi>(abi: T): T {\n  return abi\n}\n\n/**\n * Wasm schema helper — preserves literal types without `as const satisfies ReadonlyWasmContractSchema`.\n * Eliminates the need for nested `as const` on `required` arrays for inline literals.\n * Pre-assigned variables still require `as const` (e.g., `required: ['transfer'] as const`).\n *\n * @example\n * ```typescript\n * const CW20 = wasmAbi({\n *   execute: { oneOf: [{ required: ['transfer'], properties: { transfer: {} } }] },\n *   query: { oneOf: [{ required: ['balance'], properties: { balance: {} } }] },\n * })\n * ```\n */\nexport function wasmAbi<const T extends ReadonlyWasmContractSchema>(schema: T): T {\n  return schema\n}\n\n/**\n * Unified ABI helper — TypeScript overload resolution selects the correct type\n * constraint: EVM for arrays, Move for objects satisfying `ReadonlyMoveModuleAbi`\n * (`address`, `name`, `friends`, `exposed_functions`, `structs`), Wasm for objects\n * satisfying `ReadonlyWasmContractSchema` (`execute`/`query`).\n * No runtime detection; this is compile-time only.\n *\n * For ambiguous shapes (e.g. an object with both `address`/`name` and `execute`/`query`),\n * prefer the explicit variants: `evmAbi()`, `moveAbi()`, `wasmAbi()`.\n *\n * @example\n * ```typescript\n * const erc20 = abi([{ type: 'function', name: 'balanceOf', inputs: [{ name: 'account', type: 'address' }], outputs: [{ name: '', type: 'uint256' }], stateMutability: 'view' }])\n * const coin  = abi({ address: '0x1', name: 'coin', friends: [], exposed_functions: [], structs: [] })\n * const cw20  = abi({ execute: { oneOf: [{ required: ['transfer'], properties: { transfer: {} } }] } })\n * ```\n * Note: For pre-assigned Wasm variables, `required` arrays need `as const`; see `wasmAbi()`.\n */\nexport function abi<const T extends Abi>(abi: T): T\nexport function abi<const T extends ReadonlyMoveModuleAbi>(abi: T): T\nexport function abi<const T extends ReadonlyWasmContractSchema>(abi: T): T\nexport function abi(abi: unknown): unknown {\n  return abi\n}\n"],"mappings":";;;;;;;;;;;AAcA,SAAgB,OAA4B,KAAW;AACrD,QAAO;;;;;;;;;;;;;AAcT,SAAgB,QAA+C,KAAW;AACxE,QAAO;;;;;;;;;;;;;;;AAgBT,SAAgB,QAAoD,QAAc;AAChF,QAAO;;AAwBT,SAAgB,IAAI,KAAuB;AACzC,QAAO"}