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

package/dist/entry.evm.mjs

@@ -0,0 +1,761 @@
+import { o as ContractError } from "./errors-CN1MFOLv.mjs";
+import { t as Message$1 } from "./types-CSS5rfW1.mjs";
+import { n as keccak256 } from "./hash-D40mxOlF.mjs";
+import { n as createEvmRpcClient, t as EvmRpcClient } from "./evm-rpc-BxpgXIAF.mjs";
+import { c as tryDecodeBech32, o as isValidEvmAddress, t as AccAddress } from "./address-DwAkzgJk.mjs";
+import { n as MsgCallSchema } from "./tx_pb-BVCXH992.mjs";
+import { t as createErc20Token } from "./erc20-CDs3j7vt.mjs";
+import { n as evmAbi } from "./abi-helpers-DdwdqhMQ.mjs";
+import { n as parseUnits, t as formatUnits } from "./utils-B2carKSi.mjs";
+import { create } from "@bufbuild/protobuf";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+import { decodeAbiParameters, decodeErrorResult, decodeErrorResult as decodeErrorResult$1, decodeEventLog, decodeEventLog as decodeEventLog$1, decodeFunctionResult, decodeFunctionResult as decodeFunctionResult$1, encodeAbiParameters, encodeAbiParameters as encodeAbiParameters$1, encodeDeployData, encodeErrorResult, encodeEventTopics, encodeEventTopics as encodeEventTopics$1, encodeFunctionData, encodeFunctionData as encodeFunctionData$1, encodeFunctionResult, parseAbi, parseEventLogs, serializeTransaction } from "viem";
+//#region src/tx/evm.ts
+/**
+* EVM Transaction utilities.
+*
+* Provides functions for building, signing, and sending EVM transactions
+* using the SDK's existing cryptographic primitives and EvmRpcClient.
+*
+* Bundle-optimized: uses viem only for `serializeTransaction` (EIP-1559 serialization),
+* avoids viem's WalletClient/PublicClient/privateKeyToAccount to prevent
+* double-bundling of secp256k1 and pulling in unused action modules.
+*/
+/**
+* Derive EVM address from an uncompressed secp256k1 public key.
+* address = keccak256(pubkey[1:])[12:32]
+*/
+function publicKeyToEvmAddress(uncompressedPubKey) {
+	return `0x${bytesToHex(keccak256(uncompressedPubKey.slice(1)).slice(12))}`;
+}
+function resolveRpc(rpc) {
+	return typeof rpc === "string" ? new EvmRpcClient(rpc) : rpc;
+}
+/**
+* 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...',
+* })
+* ```
+*/
+async function sendEvmTx(options) {
+	const rpc = resolveRpc(options.rpc);
+	let from;
+	let signHash;
+	if (options.signer && options.privateKey) throw new Error("Cannot specify both signer and privateKey. Use one or the other.");
+	if (options.signer) {
+		const signer = options.signer;
+		if (!/^0x[0-9a-fA-F]{40}$/.test(signer.evmAddress)) throw new Error(`Invalid EVM address from signer: "${signer.evmAddress}". Expected 0x-prefixed 40-character hex string.`);
+		from = signer.evmAddress;
+		signHash = async (hash) => {
+			const sig = await signer.signEvmHash(hash);
+			return {
+				r: `0x${bytesToHex(sig.r)}`,
+				s: `0x${bytesToHex(sig.s)}`,
+				yParity: sig.yParity
+			};
+		};
+	} else if (options.privateKey) {
+		const privateKeyBytes = hexToBytes(options.privateKey.slice(2));
+		from = publicKeyToEvmAddress(secp256k1.getPublicKey(privateKeyBytes, false));
+		signHash = (hash) => {
+			const sigBytes = secp256k1.sign(hash, privateKeyBytes, {
+				prehash: false,
+				format: "recovered"
+			});
+			return Promise.resolve({
+				r: `0x${bytesToHex(sigBytes.slice(1, 33))}`,
+				s: `0x${bytesToHex(sigBytes.slice(33, 65))}`,
+				yParity: sigBytes[0]
+			});
+		};
+	} else throw new Error("Either signer or privateKey must be provided");
+	const [nonce, chainId, gasPrice] = await Promise.all([
+		rpc.getTransactionCount(from),
+		rpc.getChainId(),
+		rpc.getGasPrice()
+	]);
+	const gas = options.gasLimit ?? await rpc.estimateGas({
+		from,
+		to: options.to,
+		data: options.data,
+		value: options.value ? `0x${options.value.toString(16)}` : void 0
+	});
+	const maxFeePerGas = options.maxFeePerGas ?? gasPrice * 2n;
+	const maxPriorityFeePerGas = options.maxPriorityFeePerGas ?? gasPrice / 10n;
+	const txParams = {
+		type: "eip1559",
+		chainId: Number(chainId),
+		nonce: Number(nonce),
+		to: options.to,
+		data: options.data,
+		value: options.value ?? 0n,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		gas
+	};
+	const txHash = keccak256(hexToBytes(serializeTransaction(txParams).slice(2)));
+	const { r, s, yParity } = await signHash(txHash);
+	const signedTx = serializeTransaction(txParams, {
+		r,
+		s,
+		yParity
+	});
+	return rpc.sendRawTransaction(signedTx);
+}
+/**
+* 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'
+* ```
+*/
+async function sendEvmTxAndWait(options, pollIntervalMs = 2e3, timeoutMs = 12e4) {
+	const txHash = await sendEvmTx(options);
+	const rpc = resolveRpc(options.rpc);
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const receipt = await rpc.getTransactionReceipt(txHash);
+		if (receipt) return {
+			txHash,
+			status: receipt.status === "0x1" ? "success" : "reverted",
+			blockNumber: BigInt(receipt.blockNumber),
+			gasUsed: BigInt(receipt.gasUsed)
+		};
+		await new Promise((r) => setTimeout(r, pollIntervalMs));
+	}
+	throw new Error(`Timeout waiting for EVM tx receipt: ${txHash}`);
+}
+//#endregion
+//#region src/contracts/evm/contract.ts
+const ZERO_ADDRESS_BECH32 = "init1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqa4qvvl";
+const ZERO_ADDRESS_HEX = "0x0000000000000000000000000000000000000000";
+/**
+* Validates that an address is in a valid format (EVM hex or bech32).
+* @throws Error if address format is invalid
+*/
+function validateContractAddress(address) {
+	if (address.startsWith("0x")) {
+		if (!isValidEvmAddress(address)) throw new Error(`Invalid EVM address format: ${address}. Expected 0x followed by 40 hex characters.`);
+		return;
+	}
+	if (!tryDecodeBech32(address)) throw new Error(`Invalid contract address: ${address}. Expected EVM hex (0x...) or bech32 format.`);
+}
+/**
+* Converts a bech32 string to hex if it's not already hex.
+* Returns the value unchanged if conversion fails or unnecessary.
+*/
+function maybeToHex(val) {
+	if (typeof val === "string" && !val.startsWith("0x")) try {
+		return AccAddress.toHex(val);
+	} catch {}
+	return val;
+}
+/**
+* Recursively converts bech32 addresses to hex based on ABI parameter type.
+* Handles address, address[], tuple (with components), and tuple[].
+*/
+function convertEvmArg(arg, param) {
+	const { type } = param;
+	if (type === "address") return maybeToHex(arg);
+	if (type === "address[]" && Array.isArray(arg)) return arg.map((el) => maybeToHex(el));
+	if (type === "tuple" && param.components && arg && typeof arg === "object") {
+		const obj = { ...arg };
+		for (const comp of param.components) if (comp.name && comp.name in obj) obj[comp.name] = convertEvmArg(obj[comp.name], comp);
+		return obj;
+	}
+	if (type === "tuple[]" && param.components && Array.isArray(arg)) {
+		const tupleParam = {
+			...param,
+			type: "tuple"
+		};
+		return arg.map((el) => convertEvmArg(el, tupleParam));
+	}
+	return arg;
+}
+/**
+* Converts bech32 addresses in function args to hex, guided by ABI types.
+*/
+function convertEvmArgs(contractAbi, functionName, args) {
+	const fn = contractAbi.find((item) => item.type === "function" && item.name === functionName);
+	if (!fn || fn.type !== "function") return args;
+	return args.map((arg, i) => {
+		const input = fn.inputs[i];
+		if (!input) return arg;
+		return convertEvmArg(arg, input);
+	});
+}
+function createEvmContract(context, address, abi, options) {
+	validateContractAddress(address);
+	const contextTransport = context.evmTransport;
+	if (options?.transport === "jsonrpc" || contextTransport === "jsonrpc") return createEvmContractJsonRpc(context, address, abi, options ?? { transport: "jsonrpc" });
+	return createEvmContractGrpc(context, address, abi);
+}
+/**
+* Extract WriteOptions from the end of args if present.
+* Compares args count against the ABI-declared input count to detect the trailing options object.
+*/
+function extractWriteOptions(abi, functionName, args) {
+	const abiItem = abi.find((item) => item.type === "function" && item.name === functionName);
+	const expectedArgCount = abiItem && abiItem.type === "function" ? abiItem.inputs.length : 0;
+	if (args.length > expectedArgCount) {
+		const lastArg = args[args.length - 1];
+		if (lastArg && typeof lastArg === "object" && "value" in lastArg) {
+			const opts = lastArg;
+			return {
+				fnArgs: args.slice(0, -1),
+				value: opts.value !== void 0 ? opts.value.toString() : "0"
+			};
+		}
+	}
+	return {
+		fnArgs: args,
+		value: "0"
+	};
+}
+/**
+* Ensure a hex string has a 0x prefix.
+*/
+function ensureHexPrefix(hex) {
+	return hex.startsWith("0x") ? hex : `0x${hex}`;
+}
+/**
+* Build shared token utility methods (parseUnits, formatUnits, getTokenInfo).
+*/
+function buildTokenUtils(read) {
+	let cachedDecimals;
+	async function getDecimals() {
+		if (cachedDecimals !== void 0) return cachedDecimals;
+		cachedDecimals = await read.decimals();
+		return cachedDecimals;
+	}
+	return {
+		async parseUnits(value) {
+			return parseUnits(value, await getDecimals());
+		},
+		async formatUnits(value) {
+			return formatUnits(value, await getDecimals());
+		},
+		async getTokenInfo() {
+			const erc20 = read;
+			const [name, symbol, decimals, totalSupply] = await Promise.all([
+				erc20.name(),
+				erc20.symbol(),
+				erc20.decimals(),
+				erc20.totalSupply().catch(() => void 0)
+			]);
+			cachedDecimals = decimals;
+			return {
+				name,
+				symbol,
+				decimals,
+				totalSupply
+			};
+		}
+	};
+}
+/**
+* Convert contract address to 0x hex format for JSON-RPC.
+* If already 0x-prefixed, returns as-is. If bech32, converts to hex.
+*/
+function toHexAddress(address) {
+	if (address.startsWith("0x")) return address;
+	return AccAddress.toHex(address);
+}
+function createEvmContractGrpc(context, address, abi) {
+	const evmClient = context.client.evm;
+	async function callContract(input) {
+		const response = await evmClient.call({
+			sender: ZERO_ADDRESS_BECH32,
+			contractAddr: address,
+			input,
+			value: "0",
+			accessList: []
+		});
+		if (response.error) throw new ContractError("evm", 0, response.error);
+		return response.response;
+	}
+	const read = new Proxy({}, { get(_, functionName) {
+		return async (...args) => {
+			return decodeFunctionResult$1({
+				abi,
+				functionName,
+				data: ensureHexPrefix(await callContract(encodeFunctionData$1({
+					abi,
+					functionName,
+					args: convertEvmArgs(abi, functionName, args)
+				})))
+			});
+		};
+	} });
+	return {
+		address,
+		abi,
+		read,
+		write: new Proxy({}, { get(_, functionName) {
+			return (sender, ...args) => {
+				const { fnArgs, value } = extractWriteOptions(abi, functionName, args);
+				return new Message$1(MsgCallSchema, {
+					sender,
+					contractAddr: address,
+					input: encodeFunctionData$1({
+						abi,
+						functionName,
+						args: convertEvmArgs(abi, functionName, fnArgs)
+					}),
+					value,
+					accessList: []
+				});
+			};
+		} }),
+		estimateGas: new Proxy({}, { get(_, functionName) {
+			return async (sender, ...args) => {
+				const { fnArgs, value } = extractWriteOptions(abi, functionName, args);
+				const input = encodeFunctionData$1({
+					abi,
+					functionName,
+					args: convertEvmArgs(abi, functionName, fnArgs)
+				});
+				const response = await evmClient.call({
+					sender,
+					contractAddr: address,
+					input,
+					value,
+					accessList: []
+				});
+				if (response.error) throw new ContractError("evm", 0, response.error);
+				return response.usedGas;
+			};
+		} }),
+		...buildTokenUtils(read)
+	};
+}
+/**
+* Resolve EvmRpcClient from context at runtime.
+* ChainContext<'minievm'> provides `evmRpc` via getter.
+*/
+function resolveEvmRpc(context) {
+	const rpc = context.evmRpc;
+	if (!rpc) throw new Error("JSON-RPC transport requires evmRpc on context.\nUse a ChainContext<'minievm'> which provides evmRpc, or pass a context with evmRpc.");
+	return rpc;
+}
+/**
+* Resolve private key from options or context.signer at runtime.
+*/
+function resolvePrivateKey(context, options) {
+	if (options.privateKey) return options.privateKey;
+	const signer = context.signer;
+	if (signer && typeof signer === "object" && "getPrivateKeyHex" in signer) return signer.getPrivateKeyHex();
+	throw new Error("Private key required for JSON-RPC write.\nProvide privateKey in options or use a context with a Key signer.");
+}
+function createEvmContractJsonRpc(context, address, abi, options) {
+	const rpc = resolveEvmRpc(context);
+	const hexAddress = toHexAddress(address);
+	const read = new Proxy({}, { get(_, functionName) {
+		return async (...args) => {
+			const input = encodeFunctionData$1({
+				abi,
+				functionName,
+				args: convertEvmArgs(abi, functionName, args)
+			});
+			return decodeFunctionResult$1({
+				abi,
+				functionName,
+				data: ensureHexPrefix(await rpc.ethCall({
+					to: hexAddress,
+					data: input
+				}))
+			});
+		};
+	} });
+	const estimateGas = new Proxy({}, { get(_, functionName) {
+		return async (...args) => {
+			const { fnArgs, value } = extractWriteOptions(abi, functionName, args);
+			const input = encodeFunctionData$1({
+				abi,
+				functionName,
+				args: convertEvmArgs(abi, functionName, fnArgs)
+			});
+			let from = ZERO_ADDRESS_HEX;
+			try {
+				const pk = resolvePrivateKey(context, options);
+				const { secp256k1 } = await import("@noble/curves/secp256k1.js");
+				const { hexToBytes, bytesToHex } = await import("@noble/hashes/utils.js");
+				const { keccak256 } = await import("./hash-D40mxOlF.mjs").then((n) => n.t);
+				from = `0x${bytesToHex(keccak256(secp256k1.getPublicKey(hexToBytes(pk.slice(2)), false).slice(1)).slice(12))}`;
+			} catch {}
+			return rpc.estimateGas({
+				from,
+				to: hexAddress,
+				data: input,
+				value: value !== "0" ? `0x${BigInt(value).toString(16)}` : void 0
+			});
+		};
+	} });
+	return {
+		address,
+		abi,
+		read,
+		write: new Proxy({}, { get(_, functionName) {
+			return async (...args) => {
+				const { fnArgs, value } = extractWriteOptions(abi, functionName, args);
+				return sendEvmTx({
+					rpc,
+					privateKey: resolvePrivateKey(context, options),
+					to: hexAddress,
+					data: encodeFunctionData$1({
+						abi,
+						functionName,
+						args: convertEvmArgs(abi, functionName, fnArgs)
+					}),
+					value: value !== "0" ? BigInt(value) : void 0
+				});
+			};
+		} }),
+		estimateGas,
+		...buildTokenUtils(read)
+	};
+}
+/**
+* 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])
+* ```
+*/
+function createDeployEvmContractMsg(sender, options) {
+	const { abi, bytecode, args, value } = options;
+	const hexBytecode = bytecode.startsWith("0x") ? bytecode : `0x${bytecode}`;
+	const constructor = abi.find((item) => item.type === "constructor");
+	let convertedArgs = args;
+	if (convertedArgs && constructor && constructor.type === "constructor") convertedArgs = convertedArgs.map((arg, i) => {
+		const input = constructor.inputs[i];
+		if (!input) return arg;
+		return convertEvmArg(arg, input);
+	});
+	return create(MsgCallSchema, {
+		sender,
+		contractAddr: "",
+		input: encodeDeployData({
+			abi,
+			bytecode: hexBytecode,
+			args: convertedArgs
+		}).slice(2),
+		value: value?.toString() ?? "0",
+		accessList: []
+	});
+}
+/**
+* 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)
+*   }
+* }
+* ```
+*/
+function decodeRevertReason(data, abi) {
+	const hexData = data.startsWith("0x") ? data : `0x${data}`;
+	try {
+		if (abi) {
+			const decoded = decodeErrorResult$1({
+				abi,
+				data: hexData
+			});
+			return `${decoded.errorName}(${decoded.args?.join(", ") ?? ""})`;
+		}
+	} catch {}
+	if (hexData.startsWith("0x08c379a0")) try {
+		const decoded = decodeErrorResult$1({
+			abi: [{
+				type: "error",
+				name: "Error",
+				inputs: [{
+					type: "string",
+					name: "message"
+				}]
+			}],
+			data: hexData
+		});
+		return String(decoded.args?.[0]);
+	} catch {}
+	if (hexData.startsWith("0x4e487b71")) try {
+		const panicCode = decodeErrorResult$1({
+			abi: [{
+				type: "error",
+				name: "Panic",
+				inputs: [{
+					type: "uint256",
+					name: "code"
+				}]
+			}],
+			data: hexData
+		}).args?.[0];
+		return `Panic(${panicCode}): ${getPanicReason(panicCode)}`;
+	} catch {}
+	return `Unknown error: ${hexData}`;
+}
+/**
+* Gets human-readable panic reason.
+*/
+function getPanicReason(code) {
+	return {
+		"0": "Generic compiler panic",
+		"1": "Assert failed",
+		"17": "Arithmetic overflow/underflow",
+		"18": "Division by zero",
+		"33": "Invalid enum value",
+		"34": "Invalid storage access",
+		"49": "Pop on empty array",
+		"50": "Array index out of bounds",
+		"65": "Out of memory",
+		"81": "Call to zero-initialized function"
+	}[code.toString()] ?? "Unknown panic code";
+}
+//#endregion
+//#region src/contracts/evm/abi.ts
+/**
+* EVM ABI Encoding/Decoding Utilities
+*
+* Standalone utilities for ABI operations without creating contract instances.
+* Re-exports viem functions for consistent API.
+*/
+/**
+* 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)
+* ```
+*/
+function encodeEvmCall(signature, args) {
+	const abi = parseAbi([signature.startsWith("function ") ? signature : `function ${signature}`]);
+	const fn = abi[0];
+	if (!fn || fn.type !== "function") throw new Error(`Invalid function signature: ${signature}`);
+	const convertedArgs = convertEvmArgs(abi, fn.name, args);
+	return encodeFunctionData$1({
+		abi,
+		functionName: fn.name,
+		args: convertedArgs
+	});
+}
+/**
+* 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]
+* )
+* ```
+*/
+function encodeEvmParameters(types, values) {
+	const convertedArgs = convertEvmArgs(parseAbi([`function _encode(${types.join(",")})`]), "_encode", values);
+	return encodeAbiParameters$1(types.map((type) => ({ type })), convertedArgs);
+}
+//#endregion
+//#region src/contracts/evm/events.ts
+/**
+* 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)
+* }
+* ```
+*/
+function decodeEvmLog(abi, log) {
+	const topics = log.topics;
+	const data = log.data;
+	const decoded = decodeEventLog$1({
+		abi,
+		data,
+		topics,
+		strict: false
+	});
+	return {
+		log,
+		eventName: decoded.eventName,
+		args: decoded.args,
+		blockNumber: BigInt(log.blockNumber),
+		transactionIndex: parseInt(log.transactionIndex, 16),
+		logIndex: parseInt(log.logIndex, 16)
+	};
+}
+/**
+* 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)
+*   }
+* }
+* ```
+*/
+function decodeEvmLogs(abi, logs, options = {}) {
+	const { skipInvalid = true } = options;
+	const decoded = [];
+	for (const log of logs) try {
+		decoded.push(decodeEvmLog(abi, log));
+	} catch (error) {
+		if (!skipInvalid) throw error;
+	}
+	return decoded;
+}
+/**
+* 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}`)
+* }
+* ```
+*/
+function filterEvmLogsByEvent(abi, logs, eventName) {
+	return decodeEvmLogs(abi, logs, { skipInvalid: true }).filter((d) => d.eventName === eventName);
+}
+/**
+* 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
+* ```
+*/
+function getEventSignature(abi, eventName) {
+	const event = abi.find((item) => item.type === "event" && item.name === eventName);
+	if (!event) return;
+	try {
+		return encodeEventTopics$1({
+			abi: [event],
+			eventName: event.name
+		})[0];
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { EvmRpcClient, 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.mjs.map