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

package/dist/bcs-DiRcL4n9.mjs

@@ -0,0 +1,533 @@
+import { d as ParseError, o as ContractError } from "./errors-CN1MFOLv.mjs";
+import { t as AccAddress } from "./address-DwAkzgJk.mjs";
+import { t as UpgradePolicy } from "./types_pb-CrjtO9sB.mjs";
+import { bcs } from "@mysten/bcs";
+//#region src/contracts/move/abi-fetcher.ts
+/** In-memory ABI cache */
+const abiCache = /* @__PURE__ */ new Map();
+/** Default cache TTL (5 minutes) */
+const DEFAULT_CACHE_TTL = 300 * 1e3;
+/**
+* Gets the cache key for a module.
+*/
+function getCacheKey(moduleAddress, moduleName) {
+	return `${moduleAddress.toLowerCase()}::${moduleName}`;
+}
+/**
+* Gets a cached ABI if available and not expired.
+*
+* @param moduleAddress - Module address
+* @param moduleName - Module name
+* @param ttl - Cache TTL in milliseconds (ignored for IMMUTABLE modules)
+* @returns Cached ABI or undefined
+*/
+function getCachedAbi(moduleAddress, moduleName, ttl = DEFAULT_CACHE_TTL) {
+	const key = getCacheKey(moduleAddress, moduleName);
+	const entry = abiCache.get(key);
+	if (!entry) return void 0;
+	if (entry.permanent) return entry.abi;
+	if (Date.now() - entry.timestamp > ttl) {
+		abiCache.delete(key);
+		return;
+	}
+	return entry.abi;
+}
+/**
+* Caches a module ABI.
+*
+* @param moduleAddress - Module address
+* @param moduleName - Module name
+* @param abi - Module ABI to cache
+* @param permanent - If true, cache never expires (for IMMUTABLE modules)
+*/
+function cacheModuleAbi(moduleAddress, moduleName, abi, permanent = false) {
+	const key = getCacheKey(moduleAddress, moduleName);
+	abiCache.set(key, {
+		abi,
+		timestamp: Date.now(),
+		permanent
+	});
+}
+/**
+* Clears the ABI cache.
+* Optionally clear only entries for a specific address.
+*
+* @param moduleAddress - Optional address to clear cache for
+*/
+function clearAbiCache(moduleAddress) {
+	if (moduleAddress) {
+		const prefix = moduleAddress.toLowerCase() + "::";
+		for (const key of abiCache.keys()) if (key.startsWith(prefix)) abiCache.delete(key);
+	} else abiCache.clear();
+}
+/**
+* Parses a raw ABI JSON string into a typed MoveModuleAbi.
+*
+* @param abiJson - JSON string from Module.abi
+* @returns Parsed module ABI
+* @throws Error if JSON parsing fails or ABI structure is invalid
+*
+* @example
+* ```typescript
+* const abi = parseModuleAbi('{"address":"0x1","name":"coin",...}')
+* ```
+*/
+function parseModuleAbi(abiJson) {
+	let raw;
+	try {
+		raw = JSON.parse(abiJson);
+	} catch (error) {
+		throw new ParseError("MoveModuleABI", `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!raw.address || !raw.name) throw new ParseError("MoveModuleABI", "Missing required field: address or name");
+	const exposedFunctions = (raw.exposed_functions || []).map((fn) => ({
+		name: fn.name,
+		visibility: parseVisibility(fn.visibility),
+		is_entry: fn.is_entry ?? false,
+		is_view: fn.is_view ?? false,
+		generic_type_params: (fn.generic_type_params || []).map((param) => ({ constraints: param.constraints || [] })),
+		params: fn.params || [],
+		return: fn.return || []
+	}));
+	const structs = (raw.structs || []).map((s) => ({
+		name: s.name,
+		is_native: s.is_native ?? false,
+		abilities: s.abilities || [],
+		generic_type_params: (s.generic_type_params || []).map((param) => ({ constraints: param.constraints || [] })),
+		fields: (s.fields || []).map((f) => ({
+			name: f.name,
+			type: f.type
+		}))
+	}));
+	return {
+		address: raw.address,
+		name: raw.name,
+		friends: raw.friends || [],
+		exposed_functions: exposedFunctions,
+		structs
+	};
+}
+/**
+* Parses visibility string to typed visibility.
+*/
+function parseVisibility(visibility) {
+	switch (visibility.toLowerCase()) {
+		case "public": return "public";
+		case "private": return "private";
+		case "friend": return "friend";
+		default: return "private";
+	}
+}
+/**
+* Fetches and parses a Move module ABI from the chain.
+*
+* **Caching behavior:**
+* - **IMMUTABLE modules**: Cached permanently (staleness impossible)
+* - **COMPATIBLE/upgradeable modules**: Cached with TTL (default 5 minutes)
+*
+* For upgradeable modules, the cache may become stale after upgrades.
+* Use `clearAbiCache(moduleAddress)` after known upgrades, or set
+* `useCache: false` to always fetch fresh data.
+*
+* @param context - ChainContext with client (must have move service)
+* @param moduleAddress - Module address (hex or bech32)
+* @param moduleName - Module name
+* @param options - Fetch options
+* @returns Parsed module ABI
+*
+* @example Basic usage
+* ```typescript
+* const abi = await getModuleAbi(ctx, '0x1', 'coin')
+* console.log(abi.exposed_functions)
+* ```
+*
+* @example Handle upgradeable module
+* ```typescript
+* // After module upgrade, clear cache
+* clearAbiCache('0x1')
+*
+* // Or bypass cache entirely
+* const abi = await getModuleAbi(ctx, '0x1', 'coin', { useCache: false })
+* ```
+*/
+async function getModuleAbi(context, moduleAddress, moduleName, options = {}) {
+	const moveClient = context.client.move;
+	const { useCache = true, cacheTtl = DEFAULT_CACHE_TTL } = options;
+	if (useCache) {
+		const cached = getCachedAbi(moduleAddress, moduleName, cacheTtl);
+		if (cached) return cached;
+	}
+	const response = await moveClient.module({
+		address: moduleAddress,
+		moduleName
+	});
+	if (!response.module) throw new ContractError("move", 0, `Module not found: ${moduleAddress}::${moduleName}`);
+	const abiJson = response.module.abi;
+	if (!abiJson) throw new ContractError("move", 0, `Module ABI not available: ${moduleAddress}::${moduleName}`);
+	const abi = parseModuleAbi(abiJson);
+	cacheModuleAbi(moduleAddress, moduleName, abi, response.module.upgradePolicy === UpgradePolicy.IMMUTABLE);
+	return abi;
+}
+/**
+* Fetches all modules from an address.
+*
+* @param context - ChainContext with client (must have move service)
+* @param address - Account address
+* @returns Array of module ABIs
+*
+* @example
+* ```typescript
+* const modules = await getModulesAbi(ctx, '0x1')
+* ```
+*/
+async function getModulesAbi(context, address) {
+	const response = await context.client.move.modules({ address });
+	const abis = [];
+	for (const mod of response.modules) if (mod.abi) try {
+		const abi = parseModuleAbi(mod.abi);
+		const isImmutable = mod.upgradePolicy === UpgradePolicy.IMMUTABLE;
+		cacheModuleAbi(address, mod.moduleName, abi, isImmutable);
+		abis.push(abi);
+	} catch {}
+	return abis;
+}
+/**
+* Finds a function in the module ABI by name.
+*
+* @param abi - Module ABI
+* @param functionName - Function name to find
+* @returns Function ABI or undefined
+*/
+function findFunction(abi, functionName) {
+	return abi.exposed_functions.find((fn) => fn.name === functionName);
+}
+/**
+* Finds a struct in the module ABI by name.
+*
+* @param abi - Module ABI
+* @param structName - Struct name to find
+* @returns Struct ABI or undefined
+*/
+function findStruct(abi, structName) {
+	return abi.structs.find((s) => s.name === structName);
+}
+/**
+* Gets all entry functions from the module ABI.
+*
+* @param abi - Module ABI
+* @returns Array of entry function ABIs
+*/
+function getEntryFunctions(abi) {
+	return abi.exposed_functions.filter((fn) => fn.is_entry);
+}
+/**
+* Gets all view functions from the module ABI.
+*
+* @param abi - Module ABI
+* @returns Array of view function ABIs
+*/
+function getViewFunctions(abi) {
+	return abi.exposed_functions.filter((fn) => fn.is_view);
+}
+/**
+* Checks if a function requires a signer parameter.
+* Signer params are typically the first param with type '&signer' or 'signer'.
+*
+* @param fn - Function ABI
+* @returns True if function requires signer
+*/
+function requiresSigner(fn) {
+	if (fn.params.length === 0) return false;
+	const firstParam = fn.params[0];
+	return firstParam === "&signer" || firstParam === "signer";
+}
+/**
+* Gets the non-signer parameters of a function.
+*
+* @param fn - Function ABI
+* @returns Parameter types excluding signer
+*/
+function getNonSignerParams(fn) {
+	return fn.params.filter((p) => p !== "&signer" && p !== "signer");
+}
+//#endregion
+//#region src/contracts/move/bcs.ts
+/**
+* Move BCS (Binary Canonical Serialization) Utilities
+*
+* Provides BCS encoding/decoding for Move function arguments and results.
+* Based on @mysten/bcs with Initia-specific type extensions.
+*/
+/**
+* Creates a BCS type for Move addresses (32 bytes).
+* Accepts hex strings (0x...) or bech32 addresses (init1...).
+*/
+const initiaAddress = (options) => bcs.bytes(32, options).transform({
+	input: (val) => {
+		if (!val.startsWith("0x")) try {
+			val = AccAddress.toHex(val);
+		} catch {}
+		if (val.startsWith("0x")) val = val.slice(2);
+		val = val.padStart(64, "0");
+		if (!/^[0-9a-fA-F]+$/.test(val)) throw new Error(`Invalid Move address: ${val}`);
+		const bytes = new Uint8Array(32);
+		for (let i = 0; i < 32; i++) bytes[i] = parseInt(val.slice(i * 2, i * 2 + 2), 16);
+		return bytes;
+	},
+	output: (val) => {
+		return "0x" + Array.from(val).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+});
+/**
+* Creates a BCS type for fixed_point32 (u64 with 32-bit fractional).
+*/
+const fixedPoint32 = (options) => bcs.u64(options).transform({
+	input: (val) => {
+		return BigInt(Math.floor(Number(val) * 4294967296)).toString();
+	},
+	output: (val) => {
+		return (Number(val) / 4294967296).toString();
+	}
+});
+/**
+* Creates a BCS type for fixed_point64 (u128 with 64-bit fractional).
+*/
+const fixedPoint64 = (options) => bcs.u128(options).transform({
+	input: (val) => {
+		const wholePart = BigInt(Math.floor(Number(val)));
+		const fracPart = BigInt(Math.floor((Number(val) - Math.floor(Number(val))) * 0xde0b6b3a7640000));
+		const multiplier = BigInt("18446744073709551616");
+		return (wholePart * multiplier + fracPart * multiplier / BigInt(0xde0b6b3a7640000)).toString();
+	},
+	output: (val) => {
+		const n = BigInt(val);
+		const multiplier = BigInt("18446744073709551616");
+		const whole = n / multiplier;
+		const frac = Number(n % multiplier) / Number(multiplier);
+		return (Number(whole) + frac).toString();
+	}
+});
+/**
+* Creates a BCS type for decimal128 (u128 with 18 decimal places).
+*/
+const decimal128 = (options) => bcs.u128(options).transform({
+	input: (val) => {
+		const multiplier = BigInt("1000000000000000000");
+		const parts = String(val).split(".");
+		const wholePart = BigInt(parts[0] || "0");
+		let fracPart = BigInt(0);
+		if (parts[1]) {
+			const fracStr = parts[1].padEnd(18, "0").slice(0, 18);
+			fracPart = BigInt(fracStr);
+		}
+		return (wholePart * multiplier + fracPart).toString();
+	},
+	output: (val) => {
+		const multiplier = BigInt("1000000000000000000");
+		const n = BigInt(val);
+		const whole = n / multiplier;
+		const frac = n % multiplier;
+		if (frac === BigInt(0)) return whole.toString();
+		return `${whole}.${frac.toString().padStart(18, "0").replace(/0+$/, "")}`;
+	}
+});
+/**
+* Creates a BCS type for decimal256 (u256 with 18 decimal places).
+*/
+const decimal256 = (options) => bcs.u256(options).transform({
+	input: (val) => {
+		const multiplier = BigInt("1000000000000000000");
+		const parts = String(val).split(".");
+		const wholePart = BigInt(parts[0] || "0");
+		let fracPart = BigInt(0);
+		if (parts[1]) {
+			const fracStr = parts[1].padEnd(18, "0").slice(0, 18);
+			fracPart = BigInt(fracStr);
+		}
+		return (wholePart * multiplier + fracPart).toString();
+	},
+	output: (val) => {
+		const multiplier = BigInt("1000000000000000000");
+		const n = BigInt(val);
+		const whole = n / multiplier;
+		const frac = n % multiplier;
+		if (frac === BigInt(0)) return whole.toString();
+		return `${whole}.${frac.toString().padStart(18, "0").replace(/0+$/, "")}`;
+	}
+});
+/**
+* Extended BCS object with Initia-specific types.
+*/
+const bcs$1 = {
+	...bcs,
+	address: initiaAddress,
+	object: initiaAddress,
+	fixed_point32: fixedPoint32,
+	fixed_point64: fixedPoint64,
+	decimal128,
+	decimal256
+};
+/**
+* Parses a Move type string into a structured representation.
+*
+* @param typeStr - Move type string (e.g., 'vector<u8>', '0x1::coin::Coin<T>')
+* @returns Parsed type structure
+*
+* @example
+* ```typescript
+* parseMoveType('u64')                    // { base: 'u64', typeArgs: [] }
+* parseMoveType('vector<u8>')             // { base: 'vector', typeArgs: [{ base: 'u8', typeArgs: [] }] }
+* parseMoveType('0x1::option::Option<u64>') // { base: '0x1::option::Option', typeArgs: [...] }
+* ```
+*/
+function parseMoveType(typeStr) {
+	typeStr = typeStr.trim();
+	const genericStart = typeStr.indexOf("<");
+	if (genericStart === -1) return {
+		base: typeStr,
+		typeArgs: []
+	};
+	const base = typeStr.slice(0, genericStart);
+	const argsStr = typeStr.slice(genericStart + 1, typeStr.lastIndexOf(">"));
+	const typeArgs = [];
+	let depth = 0;
+	let current = "";
+	for (const char of argsStr) if (char === "<") {
+		depth++;
+		current += char;
+	} else if (char === ">") {
+		depth--;
+		current += char;
+	} else if (char === "," && depth === 0) {
+		if (current.trim()) typeArgs.push(parseMoveType(current.trim()));
+		current = "";
+	} else current += char;
+	if (current.trim()) typeArgs.push(parseMoveType(current.trim()));
+	return {
+		base,
+		typeArgs
+	};
+}
+/**
+* Gets a BCS type for a Move type string.
+*
+* @param moveType - Move type string
+* @returns BCS type for serialization/deserialization
+*
+* @example
+* ```typescript
+* const type = getBcsType('u64')
+* const bytes = type.serialize(1000n).toBytes()
+* ```
+*/
+function getBcsType(moveType) {
+	return resolveBcsType(parseMoveType(moveType));
+}
+function resolveBcsType(parsed) {
+	const { base, typeArgs } = parsed;
+	switch (base) {
+		case "bool": return bcs$1.bool();
+		case "u8": return bcs$1.u8();
+		case "u16": return bcs$1.u16();
+		case "u32": return bcs$1.u32();
+		case "u64": return bcs$1.u64();
+		case "u128": return bcs$1.u128();
+		case "u256": return bcs$1.u256();
+		case "address": return bcs$1.address();
+		case "signer": return bcs$1.address();
+		case "vector":
+			if (typeArgs.length !== 1) throw new Error(`vector requires exactly 1 type argument, got ${typeArgs.length}`);
+			if (typeArgs[0].base === "u8" && typeArgs[0].typeArgs.length === 0) return bcs$1.byteVector();
+			return bcs$1.vector(resolveBcsType(typeArgs[0]));
+		case "string":
+		case "0x1::string::String": return bcs$1.string();
+		case "0x1::option::Option":
+			if (typeArgs.length !== 1) throw new Error(`Option requires exactly 1 type argument, got ${typeArgs.length}`);
+			return bcs$1.option(resolveBcsType(typeArgs[0]));
+		case "0x1::fixed_point32::FixedPoint32": return bcs$1.fixed_point32();
+		case "0x1::fixed_point64::FixedPoint64": return bcs$1.fixed_point64();
+		case "0x1::decimal128::Decimal128": return bcs$1.decimal128();
+		case "0x1::decimal256::Decimal256": return bcs$1.decimal256();
+		case "0x1::object::Object":
+		case "0x1::object::ObjectCore": return bcs$1.address();
+		default:
+			if (base.includes("::")) return bcs$1.string();
+			throw new Error(`Unsupported Move type: ${base}`);
+	}
+}
+/**
+* Encodes a single Move argument to BCS bytes.
+*
+* @param value - Value to encode
+* @param moveType - Move type string
+* @returns BCS encoded bytes
+*
+* @example
+* ```typescript
+* encodeMoveArg(1000n, 'u64')           // Uint8Array
+* encodeMoveArg('init1...', 'address')  // Uint8Array
+* encodeMoveArg([1, 2, 3], 'vector<u8>') // Uint8Array
+* ```
+*/
+function encodeMoveArg(value, moveType) {
+	return getBcsType(moveType).serialize(value).toBytes();
+}
+/**
+* Encodes multiple Move arguments to BCS bytes.
+*
+* @param values - Values to encode
+* @param moveTypes - Move type strings for each value
+* @returns Array of BCS encoded bytes
+*
+* @example
+* ```typescript
+* encodeMoveArgs(
+*   ['init1...', 1000n],
+*   ['address', 'u64']
+* )
+* ```
+*/
+function encodeMoveArgs(values, moveTypes) {
+	if (values.length !== moveTypes.length) throw new Error(`Argument count mismatch: ${values.length} values, ${moveTypes.length} types`);
+	return values.map((value, i) => encodeMoveArg(value, moveTypes[i]));
+}
+/**
+* Decodes BCS bytes to a Move value.
+*
+* @param bytes - BCS encoded bytes
+* @param moveType - Move type string
+* @returns Decoded value
+*
+* @example
+* ```typescript
+* decodeMoveResult(bytes, 'u64')      // bigint string
+* decodeMoveResult(bytes, 'address')  // hex string
+* decodeMoveResult(bytes, 'bool')     // boolean
+* ```
+*/
+function decodeMoveResult(bytes, moveType) {
+	return getBcsType(moveType).parse(bytes);
+}
+/**
+* Decodes multiple BCS values from a concatenated byte array.
+* Note: This assumes the values are simply concatenated without length prefixes.
+* For proper multi-value decoding, use separate byte arrays.
+*
+* @param bytesArray - Array of BCS encoded bytes
+* @param moveTypes - Move type strings for each value
+* @returns Array of decoded values
+*/
+function decodeMoveResults(bytesArray, moveTypes) {
+	if (bytesArray.length !== moveTypes.length) throw new Error(`Result count mismatch: ${bytesArray.length} results, ${moveTypes.length} types`);
+	return bytesArray.map((bytes, i) => decodeMoveResult(bytes, moveTypes[i]));
+}
+/**
+* Converts Uint8Array to a hex string.
+*/
+function bytesToHex(bytes) {
+	return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+//#endregion
+export { getNonSignerParams as _, encodeMoveArg as a, requiresSigner as b, parseMoveType as c, findFunction as d, findStruct as f, getModulesAbi as g, getModuleAbi as h, decodeMoveResults as i, cacheModuleAbi as l, getEntryFunctions as m, bytesToHex as n, encodeMoveArgs as o, getCachedAbi as p, decodeMoveResult as r, getBcsType as s, bcs$1 as t, clearAbiCache as u, getViewFunctions as v, parseModuleAbi as y };
+
+//# sourceMappingURL=bcs-DiRcL4n9.mjs.map

package/dist/bcs-DiRcL4n9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bcs-DiRcL4n9.mjs","names":["mystenBcs","bcs"],"sources":["../src/contracts/move/abi-fetcher.ts","../src/contracts/move/bcs.ts"],"sourcesContent":["/**\n * Move Module ABI Fetcher\n *\n * Provides utilities to fetch and parse Move module ABIs from the chain.\n * Uses gRPC to query module info and parse the JSON ABI string.\n *\n * ## Caching Behavior\n *\n * ABIs are cached based on the module's upgrade policy:\n *\n * - **IMMUTABLE modules**: Cached permanently (no staleness possible)\n * - **COMPATIBLE modules**: Cached with TTL (default 5 minutes)\n *\n * For upgradeable modules, the cache may become stale after upgrades.\n * Options to handle this:\n * - Use `useCache: false` to always fetch fresh data\n * - Call `clearAbiCache(moduleAddress)` after known upgrades\n * - Reduce `cacheTtl` for frequently upgraded modules\n */\n\nimport type { Client } from '@connectrpc/connect'\nimport type { Query as MoveQuery } from '@buf/initia-labs_initia.bufbuild_es/initia/move/v1/query_pb'\nimport { UpgradePolicy } from '@buf/initia-labs_initia.bufbuild_es/initia/move/v1/types_pb'\nimport type { HasMoveService } from '../../client/types'\nimport type {\n  MoveModuleAbi,\n  MoveFunctionAbi,\n  MoveStructAbi,\n  MoveFieldAbi,\n  MoveGenericTypeParam,\n  MoveFunctionVisibility,\n} from './types'\nimport { ParseError, ContractError } from '../../errors'\n\n// =============================================================================\n// Types\n// =============================================================================\n\n/**\n * Move gRPC query client type.\n */\nexport type MoveQueryClient = Client<typeof MoveQuery>\n\n/**\n * Cache key for module ABI.\n */\ntype CacheKey = `${string}::${string}`\n\n/**\n * Cached ABI entry with metadata.\n */\ninterface CacheEntry {\n  abi: MoveModuleAbi\n  timestamp: number\n  /** If true, cache never expires (IMMUTABLE modules) */\n  permanent: boolean\n}\n\n// =============================================================================\n// ABI Cache\n// =============================================================================\n\n/** In-memory ABI cache */\nconst abiCache = new Map<CacheKey, CacheEntry>()\n\n/** Default cache TTL (5 minutes) */\nconst DEFAULT_CACHE_TTL = 5 * 60 * 1000\n\n/**\n * Gets the cache key for a module.\n */\nfunction getCacheKey(moduleAddress: string, moduleName: string): CacheKey {\n  return `${moduleAddress.toLowerCase()}::${moduleName}`\n}\n\n/**\n * Gets a cached ABI if available and not expired.\n *\n * @param moduleAddress - Module address\n * @param moduleName - Module name\n * @param ttl - Cache TTL in milliseconds (ignored for IMMUTABLE modules)\n * @returns Cached ABI or undefined\n */\nexport function getCachedAbi(\n  moduleAddress: string,\n  moduleName: string,\n  ttl: number = DEFAULT_CACHE_TTL\n): MoveModuleAbi | undefined {\n  const key = getCacheKey(moduleAddress, moduleName)\n  const entry = abiCache.get(key)\n\n  if (!entry) return undefined\n\n  // Permanent cache (IMMUTABLE modules) never expires\n  if (entry.permanent) {\n    return entry.abi\n  }\n\n  // Check if cache is expired for upgradeable modules\n  if (Date.now() - entry.timestamp > ttl) {\n    abiCache.delete(key)\n    return undefined\n  }\n\n  return entry.abi\n}\n\n/**\n * Caches a module ABI.\n *\n * @param moduleAddress - Module address\n * @param moduleName - Module name\n * @param abi - Module ABI to cache\n * @param permanent - If true, cache never expires (for IMMUTABLE modules)\n */\nexport function cacheModuleAbi(\n  moduleAddress: string,\n  moduleName: string,\n  abi: MoveModuleAbi,\n  permanent: boolean = false\n): void {\n  const key = getCacheKey(moduleAddress, moduleName)\n  abiCache.set(key, {\n    abi,\n    timestamp: Date.now(),\n    permanent,\n  })\n}\n\n/**\n * Clears the ABI cache.\n * Optionally clear only entries for a specific address.\n *\n * @param moduleAddress - Optional address to clear cache for\n */\nexport function clearAbiCache(moduleAddress?: string): void {\n  if (moduleAddress) {\n    const prefix = moduleAddress.toLowerCase() + '::'\n    for (const key of abiCache.keys()) {\n      if (key.startsWith(prefix)) {\n        abiCache.delete(key)\n      }\n    }\n  } else {\n    abiCache.clear()\n  }\n}\n\n// =============================================================================\n// ABI Parsing\n// =============================================================================\n\n/**\n * Raw ABI JSON structure from the chain.\n * This matches the JSON format in Module.abi string.\n */\ninterface RawModuleAbi {\n  address: string\n  name: string\n  friends: string[]\n  exposed_functions: RawFunctionAbi[]\n  structs: RawStructAbi[]\n}\n\ninterface RawFunctionAbi {\n  name: string\n  visibility: string\n  is_entry: boolean\n  is_view: boolean\n  generic_type_params: RawGenericTypeParam[]\n  params: string[]\n  return: string[]\n}\n\ninterface RawStructAbi {\n  name: string\n  is_native: boolean\n  abilities: string[]\n  generic_type_params: RawGenericTypeParam[]\n  fields: RawFieldAbi[]\n}\n\ninterface RawFieldAbi {\n  name: string\n  type: string\n}\n\ninterface RawGenericTypeParam {\n  constraints: string[]\n}\n\n/**\n * Parses a raw ABI JSON string into a typed MoveModuleAbi.\n *\n * @param abiJson - JSON string from Module.abi\n * @returns Parsed module ABI\n * @throws Error if JSON parsing fails or ABI structure is invalid\n *\n * @example\n * ```typescript\n * const abi = parseModuleAbi('{\"address\":\"0x1\",\"name\":\"coin\",...}')\n * ```\n */\nexport function parseModuleAbi(abiJson: string): MoveModuleAbi {\n  let raw: RawModuleAbi\n\n  try {\n    raw = JSON.parse(abiJson) as RawModuleAbi\n  } catch (error) {\n    throw new ParseError(\n      'MoveModuleABI',\n      `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`\n    )\n  }\n\n  // Validate required fields\n  if (!raw.address || !raw.name) {\n    throw new ParseError('MoveModuleABI', 'Missing required field: address or name')\n  }\n\n  // Parse exposed functions\n  const exposedFunctions: MoveFunctionAbi[] = (raw.exposed_functions || []).map(\n    (fn): MoveFunctionAbi => ({\n      name: fn.name,\n      visibility: parseVisibility(fn.visibility),\n      is_entry: fn.is_entry ?? false,\n      is_view: fn.is_view ?? false,\n      generic_type_params: (fn.generic_type_params || []).map(\n        (param): MoveGenericTypeParam => ({\n          constraints: param.constraints || [],\n        })\n      ),\n      params: fn.params || [],\n      return: fn.return || [],\n    })\n  )\n\n  // Parse structs\n  const structs: MoveStructAbi[] = (raw.structs || []).map(\n    (s): MoveStructAbi => ({\n      name: s.name,\n      is_native: s.is_native ?? false,\n      abilities: s.abilities || [],\n      generic_type_params: (s.generic_type_params || []).map(\n        (param): MoveGenericTypeParam => ({\n          constraints: param.constraints || [],\n        })\n      ),\n      fields: (s.fields || []).map(\n        (f): MoveFieldAbi => ({\n          name: f.name,\n          type: f.type,\n        })\n      ),\n    })\n  )\n\n  return {\n    address: raw.address,\n    name: raw.name,\n    friends: raw.friends || [],\n    exposed_functions: exposedFunctions,\n    structs,\n  }\n}\n\n/**\n * Parses visibility string to typed visibility.\n */\nfunction parseVisibility(visibility: string): MoveFunctionVisibility {\n  switch (visibility.toLowerCase()) {\n    case 'public':\n      return 'public'\n    case 'private':\n      return 'private'\n    case 'friend':\n      return 'friend'\n    default:\n      return 'private'\n  }\n}\n\n// =============================================================================\n// ABI Fetching\n// =============================================================================\n\n/**\n * Options for fetching module ABI.\n */\nexport interface FetchAbiOptions {\n  /** Use cached ABI if available (default: true) */\n  useCache?: boolean\n  /** Cache TTL in milliseconds (default: 5 minutes) */\n  cacheTtl?: number\n}\n\n/**\n * Fetches and parses a Move module ABI from the chain.\n *\n * **Caching behavior:**\n * - **IMMUTABLE modules**: Cached permanently (staleness impossible)\n * - **COMPATIBLE/upgradeable modules**: Cached with TTL (default 5 minutes)\n *\n * For upgradeable modules, the cache may become stale after upgrades.\n * Use `clearAbiCache(moduleAddress)` after known upgrades, or set\n * `useCache: false` to always fetch fresh data.\n *\n * @param context - ChainContext with client (must have move service)\n * @param moduleAddress - Module address (hex or bech32)\n * @param moduleName - Module name\n * @param options - Fetch options\n * @returns Parsed module ABI\n *\n * @example Basic usage\n * ```typescript\n * const abi = await getModuleAbi(ctx, '0x1', 'coin')\n * console.log(abi.exposed_functions)\n * ```\n *\n * @example Handle upgradeable module\n * ```typescript\n * // After module upgrade, clear cache\n * clearAbiCache('0x1')\n *\n * // Or bypass cache entirely\n * const abi = await getModuleAbi(ctx, '0x1', 'coin', { useCache: false })\n * ```\n */\nexport async function getModuleAbi(\n  context: HasMoveService,\n  moduleAddress: string,\n  moduleName: string,\n  options: FetchAbiOptions = {}\n): Promise<MoveModuleAbi> {\n  const moveClient = context.client.move\n  const { useCache = true, cacheTtl = DEFAULT_CACHE_TTL } = options\n\n  // Check cache first\n  if (useCache) {\n    const cached = getCachedAbi(moduleAddress, moduleName, cacheTtl)\n    if (cached) {\n      return cached\n    }\n  }\n\n  // Fetch from chain\n  const response = await moveClient.module({\n    address: moduleAddress,\n    moduleName: moduleName,\n  })\n\n  if (!response.module) {\n    throw new ContractError('move', 0, `Module not found: ${moduleAddress}::${moduleName}`)\n  }\n\n  const abiJson = response.module.abi\n  if (!abiJson) {\n    throw new ContractError('move', 0, `Module ABI not available: ${moduleAddress}::${moduleName}`)\n  }\n\n  // Parse ABI\n  const abi = parseModuleAbi(abiJson)\n\n  // Cache the result - IMMUTABLE modules are cached permanently\n  const isImmutable = response.module.upgradePolicy === UpgradePolicy.IMMUTABLE\n  cacheModuleAbi(moduleAddress, moduleName, abi, isImmutable)\n\n  return abi\n}\n\n/**\n * Fetches all modules from an address.\n *\n * @param context - ChainContext with client (must have move service)\n * @param address - Account address\n * @returns Array of module ABIs\n *\n * @example\n * ```typescript\n * const modules = await getModulesAbi(ctx, '0x1')\n * ```\n */\nexport async function getModulesAbi(\n  context: HasMoveService,\n  address: string\n): Promise<MoveModuleAbi[]> {\n  const moveClient = context.client.move\n  const response = await moveClient.modules({\n    address,\n  })\n\n  const abis: MoveModuleAbi[] = []\n\n  for (const mod of response.modules) {\n    if (mod.abi) {\n      try {\n        const abi = parseModuleAbi(mod.abi)\n        const isImmutable = mod.upgradePolicy === UpgradePolicy.IMMUTABLE\n        cacheModuleAbi(address, mod.moduleName, abi, isImmutable)\n        abis.push(abi)\n      } catch {\n        // Skip modules with invalid ABI - silent failure for library usage\n      }\n    }\n  }\n\n  return abis\n}\n\n// =============================================================================\n// ABI Utilities\n// =============================================================================\n\n/**\n * Finds a function in the module ABI by name.\n *\n * @param abi - Module ABI\n * @param functionName - Function name to find\n * @returns Function ABI or undefined\n */\nexport function findFunction(\n  abi: MoveModuleAbi,\n  functionName: string\n): MoveFunctionAbi | undefined {\n  return abi.exposed_functions.find(fn => fn.name === functionName)\n}\n\n/**\n * Finds a struct in the module ABI by name.\n *\n * @param abi - Module ABI\n * @param structName - Struct name to find\n * @returns Struct ABI or undefined\n */\nexport function findStruct(abi: MoveModuleAbi, structName: string): MoveStructAbi | undefined {\n  return abi.structs.find(s => s.name === structName)\n}\n\n/**\n * Gets all entry functions from the module ABI.\n *\n * @param abi - Module ABI\n * @returns Array of entry function ABIs\n */\nexport function getEntryFunctions(abi: MoveModuleAbi): MoveFunctionAbi[] {\n  return abi.exposed_functions.filter(fn => fn.is_entry)\n}\n\n/**\n * Gets all view functions from the module ABI.\n *\n * @param abi - Module ABI\n * @returns Array of view function ABIs\n */\nexport function getViewFunctions(abi: MoveModuleAbi): MoveFunctionAbi[] {\n  return abi.exposed_functions.filter(fn => fn.is_view)\n}\n\n/**\n * Checks if a function requires a signer parameter.\n * Signer params are typically the first param with type '&signer' or 'signer'.\n *\n * @param fn - Function ABI\n * @returns True if function requires signer\n */\nexport function requiresSigner(fn: MoveFunctionAbi): boolean {\n  if (fn.params.length === 0) return false\n  const firstParam = fn.params[0]\n  return firstParam === '&signer' || firstParam === 'signer'\n}\n\n/**\n * Gets the non-signer parameters of a function.\n *\n * @param fn - Function ABI\n * @returns Parameter types excluding signer\n */\nexport function getNonSignerParams(fn: MoveFunctionAbi): string[] {\n  return fn.params.filter(p => p !== '&signer' && p !== 'signer')\n}\n","/**\n * Move BCS (Binary Canonical Serialization) Utilities\n *\n * Provides BCS encoding/decoding for Move function arguments and results.\n * Based on @mysten/bcs with Initia-specific type extensions.\n */\n\nimport { bcs as mystenBcs, type BcsType, type BcsTypeOptions } from '@mysten/bcs'\nimport { AccAddress } from '../../util/address'\n\n// =============================================================================\n// Initia-Specific BCS Types\n// =============================================================================\n\n/**\n * Creates a BCS type for Move addresses (32 bytes).\n * Accepts hex strings (0x...) or bech32 addresses (init1...).\n */\nconst initiaAddress = (options?: BcsTypeOptions<Uint8Array, Iterable<number>>) =>\n  mystenBcs.bytes(32, options).transform({\n    input: (val: string) => {\n      // Convert bech32 to hex if needed (any prefix: init1, noble1, cosmos1, ...)\n      if (!val.startsWith('0x')) {\n        try {\n          val = AccAddress.toHex(val)\n        } catch {\n          // Not bech32 — assume bare hex, validated below\n        }\n      }\n\n      // Remove 0x prefix and pad to 64 hex chars (32 bytes)\n      if (val.startsWith('0x')) {\n        val = val.slice(2)\n      }\n      val = val.padStart(64, '0')\n\n      if (!/^[0-9a-fA-F]+$/.test(val)) {\n        throw new Error(`Invalid Move address: ${val}`)\n      }\n\n      // Convert hex to bytes\n      const bytes = new Uint8Array(32)\n      for (let i = 0; i < 32; i++) {\n        bytes[i] = parseInt(val.slice(i * 2, i * 2 + 2), 16)\n      }\n      return bytes\n    },\n    output: val => {\n      const hex = Array.from<number>(val)\n        .map(b => b.toString(16).padStart(2, '0'))\n        .join('')\n      return '0x' + hex\n    },\n  })\n\n/**\n * Creates a BCS type for fixed_point32 (u64 with 32-bit fractional).\n */\nconst fixedPoint32 = (options?: BcsTypeOptions<string, string | number | bigint>) =>\n  mystenBcs.u64(options).transform({\n    input: (val: number | string) => {\n      const n = BigInt(Math.floor(Number(val) * 4294967296))\n      return n.toString()\n    },\n    output: val => {\n      return (Number(val) / 4294967296).toString()\n    },\n  })\n\n/**\n * Creates a BCS type for fixed_point64 (u128 with 64-bit fractional).\n */\nconst fixedPoint64 = (options?: BcsTypeOptions<string, string | number | bigint>) =>\n  mystenBcs.u128(options).transform({\n    input: (val: number | string) => {\n      // Use BigInt for precision\n      const wholePart = BigInt(Math.floor(Number(val)))\n      const fracPart = BigInt(Math.floor((Number(val) - Math.floor(Number(val))) * 1e18))\n      const multiplier = BigInt('18446744073709551616') // 2^64\n      return (wholePart * multiplier + (fracPart * multiplier) / BigInt(1e18)).toString()\n    },\n    output: val => {\n      const n = BigInt(val)\n      const multiplier = BigInt('18446744073709551616')\n      const whole = n / multiplier\n      const frac = Number(n % multiplier) / Number(multiplier)\n      return (Number(whole) + frac).toString()\n    },\n  })\n\n/**\n * Creates a BCS type for decimal128 (u128 with 18 decimal places).\n */\nconst decimal128 = (options?: BcsTypeOptions<string, string | number | bigint>) =>\n  mystenBcs.u128(options).transform({\n    input: (val: number | string) => {\n      const multiplier = BigInt('1000000000000000000') // 10^18\n      const parts = String(val).split('.')\n      const wholePart = BigInt(parts[0] || '0')\n      let fracPart = BigInt(0)\n      if (parts[1]) {\n        const fracStr = parts[1].padEnd(18, '0').slice(0, 18)\n        fracPart = BigInt(fracStr)\n      }\n      return (wholePart * multiplier + fracPart).toString()\n    },\n    output: val => {\n      const multiplier = BigInt('1000000000000000000')\n      const n = BigInt(val)\n      const whole = n / multiplier\n      const frac = n % multiplier\n      if (frac === BigInt(0)) {\n        return whole.toString()\n      }\n      const fracStr = frac.toString().padStart(18, '0').replace(/0+$/, '')\n      return `${whole}.${fracStr}`\n    },\n  })\n\n/**\n * Creates a BCS type for decimal256 (u256 with 18 decimal places).\n */\nconst decimal256 = (options?: BcsTypeOptions<string, string | number | bigint>) =>\n  mystenBcs.u256(options).transform({\n    input: (val: number | string) => {\n      const multiplier = BigInt('1000000000000000000')\n      const parts = String(val).split('.')\n      const wholePart = BigInt(parts[0] || '0')\n      let fracPart = BigInt(0)\n      if (parts[1]) {\n        const fracStr = parts[1].padEnd(18, '0').slice(0, 18)\n        fracPart = BigInt(fracStr)\n      }\n      return (wholePart * multiplier + fracPart).toString()\n    },\n    output: val => {\n      const multiplier = BigInt('1000000000000000000')\n      const n = BigInt(val)\n      const whole = n / multiplier\n      const frac = n % multiplier\n      if (frac === BigInt(0)) {\n        return whole.toString()\n      }\n      const fracStr = frac.toString().padStart(18, '0').replace(/0+$/, '')\n      return `${whole}.${fracStr}`\n    },\n  })\n\n// =============================================================================\n// Combined BCS Object\n// =============================================================================\n\n/**\n * Extended BCS object with Initia-specific types.\n */\nexport const bcs: typeof mystenBcs & {\n  address: typeof initiaAddress\n  object: typeof initiaAddress\n  fixed_point32: typeof fixedPoint32\n  fixed_point64: typeof fixedPoint64\n  decimal128: typeof decimal128\n  decimal256: typeof decimal256\n} = {\n  ...mystenBcs,\n  address: initiaAddress,\n  object: initiaAddress,\n  fixed_point32: fixedPoint32,\n  fixed_point64: fixedPoint64,\n  decimal128: decimal128,\n  decimal256: decimal256,\n}\n\n// =============================================================================\n// Move Type String Parsing\n// =============================================================================\n\n/**\n * Parsed Move type representation.\n */\nexport interface ParsedMoveType {\n  /** Base type name (e.g., 'vector', 'u64', 'address') */\n  base: string\n  /** Type arguments for generic types */\n  typeArgs: ParsedMoveType[]\n}\n\n/**\n * Parses a Move type string into a structured representation.\n *\n * @param typeStr - Move type string (e.g., 'vector<u8>', '0x1::coin::Coin<T>')\n * @returns Parsed type structure\n *\n * @example\n * ```typescript\n * parseMoveType('u64')                    // { base: 'u64', typeArgs: [] }\n * parseMoveType('vector<u8>')             // { base: 'vector', typeArgs: [{ base: 'u8', typeArgs: [] }] }\n * parseMoveType('0x1::option::Option<u64>') // { base: '0x1::option::Option', typeArgs: [...] }\n * ```\n */\nexport function parseMoveType(typeStr: string): ParsedMoveType {\n  typeStr = typeStr.trim()\n\n  // Find the first '<' that starts type arguments\n  const genericStart = typeStr.indexOf('<')\n\n  if (genericStart === -1) {\n    // Simple type without generics\n    return { base: typeStr, typeArgs: [] }\n  }\n\n  // Extract base type and type arguments\n  const base = typeStr.slice(0, genericStart)\n  const argsStr = typeStr.slice(genericStart + 1, typeStr.lastIndexOf('>'))\n\n  // Parse type arguments (handle nested generics)\n  const typeArgs: ParsedMoveType[] = []\n  let depth = 0\n  let current = ''\n\n  for (const char of argsStr) {\n    if (char === '<') {\n      depth++\n      current += char\n    } else if (char === '>') {\n      depth--\n      current += char\n    } else if (char === ',' && depth === 0) {\n      if (current.trim()) {\n        typeArgs.push(parseMoveType(current.trim()))\n      }\n      current = ''\n    } else {\n      current += char\n    }\n  }\n\n  if (current.trim()) {\n    typeArgs.push(parseMoveType(current.trim()))\n  }\n\n  return { base, typeArgs }\n}\n\n// =============================================================================\n// BCS Type Resolution\n// =============================================================================\n\n/**\n * Gets a BCS type for a Move type string.\n *\n * @param moveType - Move type string\n * @returns BCS type for serialization/deserialization\n *\n * @example\n * ```typescript\n * const type = getBcsType('u64')\n * const bytes = type.serialize(1000n).toBytes()\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getBcsType(moveType: string): BcsType<any, any> {\n  const parsed = parseMoveType(moveType)\n  return resolveBcsType(parsed)\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction resolveBcsType(parsed: ParsedMoveType): BcsType<any, any> {\n  const { base, typeArgs } = parsed\n\n  // Primitive types\n  switch (base) {\n    case 'bool':\n      return bcs.bool()\n    case 'u8':\n      return bcs.u8()\n    case 'u16':\n      return bcs.u16()\n    case 'u32':\n      return bcs.u32()\n    case 'u64':\n      return bcs.u64()\n    case 'u128':\n      return bcs.u128()\n    case 'u256':\n      return bcs.u256()\n    case 'address':\n      return bcs.address()\n    case 'signer':\n      // Signer is encoded as address\n      return bcs.address()\n    case 'vector':\n      if (typeArgs.length !== 1) {\n        throw new Error(`vector requires exactly 1 type argument, got ${typeArgs.length}`)\n      }\n      // Special case: vector<u8> is more efficient as byteVector\n      if (typeArgs[0].base === 'u8' && typeArgs[0].typeArgs.length === 0) {\n        return bcs.byteVector()\n      }\n      return bcs.vector(resolveBcsType(typeArgs[0]))\n    case 'string':\n    case '0x1::string::String':\n      return bcs.string()\n    case '0x1::option::Option':\n      if (typeArgs.length !== 1) {\n        throw new Error(`Option requires exactly 1 type argument, got ${typeArgs.length}`)\n      }\n      return bcs.option(resolveBcsType(typeArgs[0]))\n    case '0x1::fixed_point32::FixedPoint32':\n      return bcs.fixed_point32()\n    case '0x1::fixed_point64::FixedPoint64':\n      return bcs.fixed_point64()\n    case '0x1::decimal128::Decimal128':\n      return bcs.decimal128()\n    case '0x1::decimal256::Decimal256':\n      return bcs.decimal256()\n    case '0x1::object::Object':\n    case '0x1::object::ObjectCore':\n      return bcs.address()\n    default:\n      // For struct types without specific handling, treat as opaque bytes\n      // This is a fallback - specific struct types should be handled by the caller\n      if (base.includes('::')) {\n        // Unknown module type - return string for now\n        // In practice, the caller should provide custom handling\n        return bcs.string()\n      }\n      throw new Error(`Unsupported Move type: ${base}`)\n  }\n}\n\n// =============================================================================\n// Encoding/Decoding Functions\n// =============================================================================\n\n/**\n * Encodes a single Move argument to BCS bytes.\n *\n * @param value - Value to encode\n * @param moveType - Move type string\n * @returns BCS encoded bytes\n *\n * @example\n * ```typescript\n * encodeMoveArg(1000n, 'u64')           // Uint8Array\n * encodeMoveArg('init1...', 'address')  // Uint8Array\n * encodeMoveArg([1, 2, 3], 'vector<u8>') // Uint8Array\n * ```\n */\nexport function encodeMoveArg(value: unknown, moveType: string): Uint8Array {\n  const bcsType = getBcsType(moveType)\n  return bcsType.serialize(value).toBytes()\n}\n\n/**\n * Encodes multiple Move arguments to BCS bytes.\n *\n * @param values - Values to encode\n * @param moveTypes - Move type strings for each value\n * @returns Array of BCS encoded bytes\n *\n * @example\n * ```typescript\n * encodeMoveArgs(\n *   ['init1...', 1000n],\n *   ['address', 'u64']\n * )\n * ```\n */\nexport function encodeMoveArgs(values: unknown[], moveTypes: string[]): Uint8Array[] {\n  if (values.length !== moveTypes.length) {\n    throw new Error(`Argument count mismatch: ${values.length} values, ${moveTypes.length} types`)\n  }\n  return values.map((value, i) => encodeMoveArg(value, moveTypes[i]))\n}\n\n/**\n * Decodes BCS bytes to a Move value.\n *\n * @param bytes - BCS encoded bytes\n * @param moveType - Move type string\n * @returns Decoded value\n *\n * @example\n * ```typescript\n * decodeMoveResult(bytes, 'u64')      // bigint string\n * decodeMoveResult(bytes, 'address')  // hex string\n * decodeMoveResult(bytes, 'bool')     // boolean\n * ```\n */\nexport function decodeMoveResult(bytes: Uint8Array, moveType: string): unknown {\n  const bcsType = getBcsType(moveType)\n  return bcsType.parse(bytes)\n}\n\n/**\n * Decodes multiple BCS values from a concatenated byte array.\n * Note: This assumes the values are simply concatenated without length prefixes.\n * For proper multi-value decoding, use separate byte arrays.\n *\n * @param bytesArray - Array of BCS encoded bytes\n * @param moveTypes - Move type strings for each value\n * @returns Array of decoded values\n */\nexport function decodeMoveResults(bytesArray: Uint8Array[], moveTypes: string[]): unknown[] {\n  if (bytesArray.length !== moveTypes.length) {\n    throw new Error(\n      `Result count mismatch: ${bytesArray.length} results, ${moveTypes.length} types`\n    )\n  }\n  return bytesArray.map((bytes, i) => decodeMoveResult(bytes, moveTypes[i]))\n}\n\n// =============================================================================\n// Utility Functions\n// =============================================================================\n\nexport { hexToBytes } from '../../util/hex'\n\n/**\n * Converts Uint8Array to a hex string.\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  return (\n    '0x' +\n    Array.from(bytes)\n      .map(b => b.toString(16).padStart(2, '0'))\n      .join('')\n  )\n}\n"],"mappings":"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"}