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

package/dist/entry.evm.d.mts

@@ -0,0 +1,544 @@
+import { Ca as Message, L as evmAbi, _r as EvmRpcClientOptions, ao as MsgCallSchema, br as TransactionReceipt, ea as TokenInfo, ft as createErc20Token, gr as EvmRpcClient, hr as EvmLog, io as MsgCall, ko as EvmTxSigner, mr as EvmBlock, v as HasEvmService, vr as EvmTransaction, xr as createEvmRpcClient, yr as GetLogsFilter } from "./types-DGrP9Ro_.mjs";
+import { Client } from "@connectrpc/connect";
+import { ContractConstructorArgs, ContractEventName, ContractFunctionArgs, ContractFunctionName, ContractFunctionReturnType, DecodeEventLogReturnType, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionResult, encodeAbiParameters, encodeErrorResult, encodeEventTopics, encodeFunctionData, encodeFunctionResult, parseEventLogs } from "viem";
+import { Abi, Abi as Abi$1, AbiError, AbiEvent, AbiFunction, AbiParameter } from "abitype";
+
+//#region src/contracts/evm/types.d.ts
+/**
+ * EVM contract configuration.
+ */
+interface EvmContractConfig<TAbi extends Abi$1 = Abi$1> {
+  /** Contract address (0x-prefixed hex or bech32) */
+  address: string;
+  /** Contract ABI */
+  abi: TAbi;
+}
+/**
+ * Options for write and estimateGas function calls.
+ */
+interface WriteOptions {
+  /** Native token value to send with the call (for payable functions). In smallest unit. */
+  value?: string | bigint;
+}
+/** View/pure function names from ABI */
+type ViewFunctionName<TAbi extends Abi$1> = ContractFunctionName<TAbi, 'view' | 'pure'>;
+/** Non-payable/payable function names from ABI */
+type WriteFunctionName<TAbi extends Abi$1> = ContractFunctionName<TAbi, 'nonpayable' | 'payable'>;
+/**
+ * Read functions proxy type.
+ *
+ * Maps view/pure function names to callable async functions.
+ * Return types are inferred from the ABI.
+ *
+ * @example
+ * ```typescript
+ * const balance = await contract.read.balanceOf(address)  // bigint
+ * const symbol = await contract.read.symbol()             // string
+ * ```
+ */
+type ReadFunctions<TAbi extends Abi$1> = { [K in ViewFunctionName<TAbi>]: (...args: ContractFunctionArgs<TAbi, 'view' | 'pure', K> extends readonly unknown[] ? ContractFunctionArgs<TAbi, 'view' | 'pure', K> : never) => Promise<ContractFunctionReturnType<TAbi, 'view' | 'pure', K>> };
+/**
+ * Write functions proxy type.
+ *
+ * Maps state-changing function names to functions that return MsgCall messages.
+ * These messages can be signed and broadcast via signAndBroadcast().
+ *
+ * @example
+ * ```typescript
+ * // Standard call
+ * const msg = contract.write.transfer(sender, to, amount)
+ *
+ * // Payable call with value
+ * const msg = contract.write.deposit(sender, { value: '1000000' })
+ * await ctx.signAndBroadcast([msg])
+ * ```
+ */
+type WriteFunctions<TAbi extends Abi$1> = { [K in WriteFunctionName<TAbi>]: (sender: string, ...args: ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K> extends readonly unknown[] ? [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>] | [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>, WriteOptions] : never) => Message<typeof MsgCallSchema> };
+/**
+ * Gas estimation proxy type.
+ *
+ * Maps state-changing function names to async gas estimation functions.
+ *
+ * @example
+ * ```typescript
+ * const gas = await contract.estimateGas.transfer(sender, to, amount)
+ * const gas = await contract.estimateGas.deposit(sender, { value: '1000000' })
+ * ```
+ */
+type EstimateGasFunctions<TAbi extends Abi$1> = { [K in WriteFunctionName<TAbi>]: (sender: string, ...args: ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K> extends readonly unknown[] ? [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>] | [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>, WriteOptions] : never) => Promise<bigint> };
+/**
+ * EVM contract instance.
+ *
+ * Provides type-safe access to contract functions via proxies:
+ * - `read`: View/pure functions (gRPC Query.Call)
+ * - `write`: State-changing functions (returns MsgCall)
+ * - `estimateGas`: Gas estimation for write functions
+ *
+ * @example
+ * ```typescript
+ * import { createEvmContract } from 'initia.js'
+ *
+ * const erc20 = createEvmContract(ctx, address, abi)
+ *
+ * // Read
+ * const balance = await erc20.read.balanceOf(owner)
+ *
+ * // Write (sender as first arg, consistent with Move/Wasm)
+ * const msg = erc20.write.transfer(sender, to, amount)
+ * await ctx.signAndBroadcast([msg])
+ *
+ * // Gas estimation
+ * const gas = await erc20.estimateGas.transfer(sender, to, amount)
+ * ```
+ */
+interface EvmContract<TAbi extends Abi$1 = Abi$1> {
+  /** Contract address */
+  readonly address: string;
+  /** Contract ABI */
+  readonly abi: TAbi;
+  /** Read-only functions (view/pure) - calls via gRPC Query.Call */
+  readonly read: ReadFunctions<TAbi>;
+  /** State-changing functions - creates MsgCall messages */
+  readonly write: WriteFunctions<TAbi>;
+  /** Gas estimation for write functions */
+  readonly estimateGas: EstimateGasFunctions<TAbi>;
+  /**
+   * Parse human-readable amount to smallest unit.
+   * Requires decimals() function in ABI.
+   *
+   * @param value - Human-readable amount (e.g., "1.5")
+   * @returns Amount in smallest unit as bigint
+   *
+   * @example
+   * ```typescript
+   * const amount = await usdc.parseUnits("1.5")  // 1500000n (6 decimals)
+   * ```
+   */
+  parseUnits(value: string): Promise<bigint>;
+  /**
+   * Format smallest unit to human-readable amount.
+   * Requires decimals() function in ABI.
+   *
+   * @param value - Amount in smallest unit
+   * @returns Human-readable amount as string
+   *
+   * @example
+   * ```typescript
+   * const display = await usdc.formatUnits(1500000n)  // "1.5"
+   * ```
+   */
+  formatUnits(value: bigint): Promise<string>;
+  /**
+   * Get ERC20 token metadata.
+   * Fetches name, symbol, decimals, totalSupply in parallel.
+   *
+   * @returns Token info object
+   *
+   * @example
+   * ```typescript
+   * const info = await usdc.getTokenInfo()
+   * // { name: "USD Coin", symbol: "USDC", decimals: 6, totalSupply: 1000000000000n }
+   * ```
+   */
+  getTokenInfo(): Promise<TokenInfo>;
+}
+/**
+ * Options for deploying an EVM contract.
+ */
+interface DeployEvmContractOptions<TAbi extends Abi$1 = Abi$1> {
+  /** Contract ABI */
+  abi: TAbi;
+  /** Contract bytecode (hex string, with or without 0x prefix) */
+  bytecode: string;
+  /** Constructor arguments (type inferred from ABI constructor inputs) */
+  args?: ContractConstructorArgs<TAbi>;
+  /** Value to send with deployment (in smallest unit) */
+  value?: bigint;
+}
+/**
+ * Result of contract deployment.
+ */
+interface DeployEvmContractResult {
+  /** Transaction hash */
+  txHash: string;
+  /** Deployed contract address (0x-prefixed) */
+  contractAddress: string;
+}
+/**
+ * Options for creating an EVM contract with JSON-RPC transport.
+ */
+interface EvmContractJsonRpcOptions {
+  transport: 'jsonrpc';
+  /** Private key for write and estimateGas operations (0x-prefixed hex).
+   *  If omitted, extracted from context.signer at runtime. */
+  privateKey?: `0x${string}`;
+}
+/**
+ * Write functions proxy for JSON-RPC transport.
+ *
+ * Unlike gRPC write, there is no `sender` first argument
+ * (derived from privateKey) and the return type is `Promise<string>` (tx hash).
+ *
+ * @example
+ * ```typescript
+ * const txHash = await contract.write.transfer(to, amount)
+ * const txHash = await contract.write.deposit({ value: '1000000' })
+ * ```
+ */
+type JsonRpcWriteFunctions<TAbi extends Abi$1> = { [K in WriteFunctionName<TAbi>]: (...args: ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K> extends readonly unknown[] ? [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>] | [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>, WriteOptions] : never) => Promise<string> };
+/**
+ * Gas estimation proxy for JSON-RPC transport.
+ *
+ * Unlike gRPC estimateGas, there is no `sender` first argument
+ * (derived from privateKey, or zero address if not available).
+ *
+ * @example
+ * ```typescript
+ * const gas = await contract.estimateGas.transfer(to, amount)
+ * ```
+ */
+type JsonRpcEstimateGasFunctions<TAbi extends Abi$1> = { [K in WriteFunctionName<TAbi>]: (...args: ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K> extends readonly unknown[] ? [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>] | [...ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', K>, WriteOptions] : never) => Promise<bigint> };
+/**
+ * EVM contract instance using JSON-RPC transport.
+ *
+ * Differences from gRPC `EvmContract`:
+ * - `write`: no `sender` arg, returns `Promise<string>` (tx hash)
+ * - `estimateGas`: no `sender` arg
+ * - `read`: identical API
+ * - Revert errors include raw data in `ContractError.data`
+ *
+ * @example
+ * ```typescript
+ * const erc20 = createEvmContract(ctx, address, abi, { transport: 'jsonrpc' })
+ *
+ * // Read (same as gRPC)
+ * const balance = await erc20.read.balanceOf(owner)
+ *
+ * // Write (no sender, returns tx hash)
+ * const txHash = await erc20.write.transfer(to, amount)
+ *
+ * // Estimate gas (no sender)
+ * const gas = await erc20.estimateGas.transfer(to, amount)
+ * ```
+ */
+interface EvmContractJsonRpc<TAbi extends Abi$1 = Abi$1> {
+  /** Contract address */
+  readonly address: string;
+  /** Contract ABI */
+  readonly abi: TAbi;
+  /** Read-only functions (view/pure) - calls via JSON-RPC eth_call */
+  readonly read: ReadFunctions<TAbi>;
+  /** State-changing functions - sends EVM transaction via JSON-RPC, returns tx hash */
+  readonly write: JsonRpcWriteFunctions<TAbi>;
+  /** Gas estimation for write functions via JSON-RPC eth_estimateGas */
+  readonly estimateGas: JsonRpcEstimateGasFunctions<TAbi>;
+  /** Parse human-readable amount to smallest unit (same as gRPC) */
+  parseUnits(value: string): Promise<bigint>;
+  /** Format smallest unit to human-readable amount (same as gRPC) */
+  formatUnits(value: bigint): Promise<string>;
+  /** Get ERC20 token metadata (same as gRPC) */
+  getTokenInfo(): Promise<TokenInfo>;
+}
+//#endregion
+//#region src/contracts/evm/contract.d.ts
+/**
+ * Creates a type-safe EVM contract instance.
+ *
+ * @param context - ChainContext with client (must have evm service)
+ * @param address - Contract address (0x hex or bech32)
+ * @param abi - Contract ABI
+ * @param options - Transport options (omit or `{ transport: 'jsonrpc' }`)
+ * @returns Type-safe contract instance
+ *
+ * @example
+ * ```typescript
+ * import { createEvmContract } from 'initia.js'
+ *
+ * // gRPC (default)
+ * const erc20 = createEvmContract(ctx, address, erc20Abi)
+ * const msg = erc20.write.transfer(sender, to, amount)
+ * await ctx.signAndBroadcast([msg])
+ *
+ * // JSON-RPC
+ * const erc20 = createEvmContract(ctx, address, erc20Abi, { transport: 'jsonrpc' })
+ * const txHash = await erc20.write.transfer(to, amount)
+ * ```
+ */
+declare function createEvmContract<const TAbi extends Abi$1>(context: HasEvmService & {
+  evmTransport: 'jsonrpc';
+}, address: string, abi: TAbi): EvmContractJsonRpc<TAbi>;
+declare function createEvmContract<const TAbi extends Abi$1>(context: HasEvmService, address: string, abi: TAbi, options: EvmContractJsonRpcOptions): EvmContractJsonRpc<TAbi>;
+declare function createEvmContract<const TAbi extends Abi$1>(context: HasEvmService, address: string, abi: TAbi): EvmContract<TAbi>;
+/**
+ * Deploys an EVM contract.
+ *
+ * Note: This creates a MsgCreate message. Use with signAndBroadcast().
+ *
+ * @param sender - Deployer address
+ * @param options - Deployment options (abi, bytecode, args, value)
+ * @returns MsgCreate message for signing
+ *
+ * @example
+ * ```typescript
+ * const deployMsg = createDeployEvmContractMsg(ctx.address, {
+ *   abi: myContractAbi,
+ *   bytecode: '0x6080...',
+ *   args: [arg1, arg2],
+ * })
+ *
+ * const result = await ctx.signAndBroadcast([deployMsg])
+ * ```
+ */
+declare function createDeployEvmContractMsg<const TAbi extends Abi$1>(sender: string, options: DeployEvmContractOptions<TAbi>): MsgCall;
+/**
+ * Decodes an EVM revert reason from error data.
+ *
+ * @param data - Hex encoded error data
+ * @param abi - Optional contract ABI for custom error decoding
+ * @returns Decoded error reason
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await contract.read.transfer(to, amount)
+ * } catch (e) {
+ *   if (e instanceof ContractError && e.data) {
+ *     const reason = decodeRevertReason(e.data, contract.abi)
+ *     console.log('Revert reason:', reason)
+ *   }
+ * }
+ * ```
+ */
+declare function decodeRevertReason(data: string, abi?: Abi$1): string;
+//#endregion
+//#region src/contracts/evm/abi.d.ts
+/**
+ * Encodes an EVM function call from a human-readable signature string.
+ * Accepts bech32 addresses in args — automatically converts to hex for address params.
+ *
+ * @param signature - Human-readable function signature (e.g., "function transfer(address to, uint256 amount)")
+ * @param args - Function arguments (bech32 addresses accepted for address params)
+ * @returns ABI-encoded calldata with function selector
+ *
+ * @example
+ * ```typescript
+ * // With 'function' keyword
+ * const calldata = encodeEvmCall(
+ *   'function transfer(address to, uint256 amount)',
+ *   ['init1qwer...', 100n]
+ * )
+ *
+ * // Without 'function' keyword (also accepted)
+ * const calldata = encodeEvmCall(
+ *   'transfer(address,uint256)',
+ *   ['init1qwer...', 100n]
+ * )
+ *
+ * const msg = createExecuteMsg(sender, contractAddr, calldata)
+ * ```
+ */
+declare function encodeEvmCall(signature: string, args: unknown[]): `0x${string}`;
+/**
+ * Encodes ABI parameters from type strings with bech32 address auto-conversion.
+ *
+ * @param types - Parameter type strings (e.g., ["address", "uint256"])
+ * @param values - Parameter values (bech32 addresses accepted for address params)
+ * @returns ABI-encoded parameters (no function selector)
+ *
+ * @example
+ * ```typescript
+ * const encoded = encodeEvmParameters(
+ *   ['address', 'uint256'],
+ *   ['init1qwer...', 100n]
+ * )
+ * ```
+ */
+declare function encodeEvmParameters(types: string[], values: unknown[]): `0x${string}`;
+//#endregion
+//#region src/contracts/evm/events.d.ts
+/**
+ * Decoded EVM event with original log data.
+ *
+ * When `TAbi` is a narrow `as const` ABI, `eventName` and `args` are
+ * inferred from the ABI event definitions. When `TEventName` is provided,
+ * the type is narrowed to that specific event.
+ */
+type DecodedEvmLog<TAbi extends Abi$1 = Abi$1, TEventName extends ContractEventName<TAbi> | undefined = undefined> = {
+  /** Original log data */log: EvmLog; /** Block number (parsed to bigint) */
+  blockNumber: bigint; /** Transaction index */
+  transactionIndex: number; /** Log index */
+  logIndex: number;
+} & DecodeEventLogReturnType<TAbi, TEventName>;
+/**
+ * Options for decoding EVM logs.
+ */
+interface DecodeEvmLogsOptions {
+  /**
+   * Whether to skip logs that fail to decode.
+   * If false, throws an error on decode failure.
+   * @default true
+   */
+  skipInvalid?: boolean;
+}
+/**
+ * Decode a single EVM log using the provided ABI.
+ *
+ * @param abi - Contract ABI containing event definitions
+ * @param log - EVM log to decode
+ * @returns Decoded event data with ABI-inferred eventName and args
+ * @throws If log cannot be decoded with the provided ABI
+ *
+ * @example
+ * ```typescript
+ * import { decodeEvmLog } from 'initia.js'
+ *
+ * const log = await rpcClient.getLogs({ address: contractAddress })
+ * const decoded = decodeEvmLog(erc20Abi, log[0])
+ * if (decoded.eventName === 'Transfer') {
+ *   console.log(decoded.args.from, decoded.args.to, decoded.args.value)
+ * }
+ * ```
+ */
+declare function decodeEvmLog<const TAbi extends Abi$1>(abi: TAbi, log: EvmLog): DecodedEvmLog<TAbi>;
+/**
+ * Decode multiple EVM logs using the provided ABI.
+ *
+ * @param abi - Contract ABI containing event definitions
+ * @param logs - Array of EVM logs to decode
+ * @param options - Decode options
+ * @returns Array of decoded events with ABI-inferred types
+ *
+ * @example
+ * ```typescript
+ * import { createEvmRpcClient, decodeEvmLogs } from 'initia.js'
+ *
+ * const rpc = createEvmRpcClient(evmRpcEndpoint)
+ * const logs = await rpc.getLogs({
+ *   address: contractAddress,
+ *   fromBlock: 1000000,
+ *   toBlock: 'latest',
+ * })
+ *
+ * const decoded = decodeEvmLogs(erc20Abi, logs)
+ * for (const event of decoded) {
+ *   if (event.eventName === 'Transfer') {
+ *     console.log(event.args.from, event.args.to, event.args.value)
+ *   }
+ * }
+ * ```
+ */
+declare function decodeEvmLogs<const TAbi extends Abi$1>(abi: TAbi, logs: EvmLog[], options?: DecodeEvmLogsOptions): DecodedEvmLog<TAbi>[];
+/**
+ * Filter and decode logs by event name.
+ *
+ * @param abi - Contract ABI containing event definitions
+ * @param logs - Array of EVM logs to filter and decode
+ * @param eventName - Event name to filter by (narrowed to ABI event names)
+ * @returns Array of decoded events narrowed to the specified event type
+ *
+ * @example
+ * ```typescript
+ * import { filterEvmLogsByEvent } from 'initia.js'
+ *
+ * const transfers = filterEvmLogsByEvent(erc20Abi, logs, 'Transfer')
+ * for (const transfer of transfers) {
+ *   // args is typed: { from: `0x${string}`, to: `0x${string}`, value: bigint }
+ *   console.log(`Transfer from ${transfer.args.from} to ${transfer.args.to}: ${transfer.args.value}`)
+ * }
+ * ```
+ */
+declare function filterEvmLogsByEvent<const TAbi extends Abi$1, TEventName extends ContractEventName<TAbi>>(abi: TAbi, logs: EvmLog[], eventName: TEventName): DecodedEvmLog<TAbi, TEventName>[];
+/**
+ * Get event signature (topic0) for an event by name.
+ *
+ * @param abi - Contract ABI containing event definitions
+ * @param eventName - Event name (narrowed to ABI event names)
+ * @returns Event signature hash (topic0) or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * import { getEventSignature } from 'initia.js'
+ *
+ * const topic = getEventSignature(erc20Abi, 'Transfer')
+ * // 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
+ * ```
+ */
+declare function getEventSignature<const TAbi extends Abi$1>(abi: TAbi, eventName: ContractEventName<TAbi>): `0x${string}` | undefined;
+//#endregion
+//#region src/tx/evm.d.ts
+interface SendEvmTxOptions {
+  /** EvmRpcClient instance or RPC URL string (creates a client internally) */
+  rpc: EvmRpcClient | string;
+  /** EVM tx signer (RawKey, MnemonicKey, or any EvmTxSigner) */
+  signer?: EvmTxSigner;
+  /** Private key as 0x-prefixed hex (alternative to signer) */
+  privateKey?: `0x${string}`;
+  /** Target contract/recipient address */
+  to: `0x${string}`;
+  /** ABI-encoded calldata (0x-prefixed) */
+  data: `0x${string}`;
+  /** Native token value in wei */
+  value?: bigint;
+  /** Gas limit override (auto-estimated if omitted) */
+  gasLimit?: bigint;
+  /** Max fee per gas override (auto-calculated if omitted) */
+  maxFeePerGas?: bigint;
+  /** Max priority fee per gas override (defaults to gasPrice / 10) */
+  maxPriorityFeePerGas?: bigint;
+}
+interface EvmTxResult {
+  txHash: string;
+  status: 'success' | 'reverted';
+  blockNumber: bigint;
+  gasUsed: bigint;
+}
+/**
+ * Send a raw EVM transaction and return the transaction hash.
+ *
+ * Handles nonce retrieval, gas estimation, EIP-1559 serialization, and signing
+ * via the provided EvmTxSigner or raw private key.
+ *
+ * @example Using signer (preferred)
+ * ```typescript
+ * const key = new MnemonicKey({ mnemonic: '...' })
+ * const txHash = await sendEvmTx({
+ *   rpc: 'https://1rpc.io/sepolia',
+ *   signer: key,
+ *   to: '0x...',
+ *   data: '0x...',
+ *   value: 1000000000000000n, // 0.001 ETH
+ * })
+ * ```
+ *
+ * @example Using privateKey (legacy)
+ * ```typescript
+ * const txHash = await sendEvmTx({
+ *   rpc: 'https://1rpc.io/sepolia',
+ *   privateKey: key.getPrivateKeyHex(),
+ *   to: '0x...',
+ *   data: '0x...',
+ * })
+ * ```
+ */
+declare function sendEvmTx(options: SendEvmTxOptions): Promise<string>;
+/**
+ * Send an EVM transaction and wait for the receipt.
+ *
+ * Polls `eth_getTransactionReceipt` until the transaction is confirmed
+ * or the timeout is reached.
+ *
+ * @example
+ * ```typescript
+ * const result = await sendEvmTxAndWait({
+ *   rpc: 'https://1rpc.io/sepolia',
+ *   signer: key,
+ *   to: '0x...',
+ *   data: '0x...',
+ * })
+ * console.log(result.status) // 'success' or 'reverted'
+ * ```
+ */
+declare function sendEvmTxAndWait(options: SendEvmTxOptions, pollIntervalMs?: number, timeoutMs?: number): Promise<EvmTxResult>;
+//#endregion
+export { type Abi, type AbiError, type AbiEvent, type AbiFunction, type AbiParameter, type DecodeEvmLogsOptions, type DecodedEvmLog, type DeployEvmContractOptions, type DeployEvmContractResult, type EstimateGasFunctions, type EvmBlock, type EvmContract, type EvmContractConfig, type EvmContractJsonRpc, type EvmContractJsonRpcOptions, type EvmLog, EvmRpcClient, type EvmRpcClientOptions, type EvmTransaction, type EvmTxResult, type GetLogsFilter, type JsonRpcEstimateGasFunctions, type JsonRpcWriteFunctions, type ReadFunctions, type SendEvmTxOptions, type TransactionReceipt, type WriteFunctions, type WriteOptions, createDeployEvmContractMsg, createErc20Token, createEvmContract, createEvmRpcClient, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeEvmLog, decodeEvmLogs, decodeFunctionResult, decodeRevertReason, encodeAbiParameters, encodeErrorResult, encodeEventTopics, encodeEvmCall, encodeEvmParameters, encodeFunctionData, encodeFunctionResult, evmAbi, filterEvmLogsByEvent, getEventSignature, parseEventLogs, sendEvmTx, sendEvmTxAndWait };
+//# sourceMappingURL=entry.evm.d.mts.map