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

package/dist/contract-Dpvu4wLO.mjs

@@ -0,0 +1,657 @@
+import { o as ContractError } from "./errors-CN1MFOLv.mjs";
+import { t as Message$1 } from "./types-CSS5rfW1.mjs";
+import { c as tryDecodeBech32, t as AccAddress } from "./address-DwAkzgJk.mjs";
+import { r as jsonStringifyArg } from "./json-CGak0DqP.mjs";
+import { t as UpgradePolicy } from "./types_pb-CrjtO9sB.mjs";
+import { a as MsgScriptJSONSchema, i as MsgPublishSchema, n as MsgExecuteJSONSchema, o as MsgScriptSchema, r as MsgExecuteSchema } from "./tx_pb-DYspoJTt.mjs";
+import { _ as getNonSignerParams, c as parseMoveType, d as findFunction, h as getModuleAbi, o as encodeMoveArgs } from "./bcs-DiRcL4n9.mjs";
+import { n as parseUnits, t as formatUnits } from "./utils-B2carKSi.mjs";
+import { create } from "@bufbuild/protobuf";
+//#region src/contracts/move/contract.ts
+/**
+* Move Contract Factory and Helpers
+*
+* Provides Move module contract interactions via gRPC.
+* Supports entry functions, view functions, resources, and table queries.
+*/
+/** Valid Move identifier pattern: starts with letter or underscore, contains alphanumeric and underscore */
+const MOVE_IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+/**
+* Validates that an address is in a valid format (EVM hex or bech32).
+* @throws Error if address format is invalid
+*/
+function validateModuleAddress(address) {
+	if (address.startsWith("0x")) {
+		if (!/^0x[0-9a-fA-F]+$/.test(address)) throw new Error(`Invalid module address format: ${address}. Expected 0x followed by hex characters.`);
+		return;
+	}
+	if (!tryDecodeBech32(address)) throw new Error(`Invalid module address: ${address}. Expected EVM hex (0x...) or bech32 format.`);
+}
+/**
+* Validates that a module name is a valid Move identifier.
+* @throws Error if module name is invalid
+*/
+function validateModuleName(name) {
+	if (!name) throw new Error("Module name cannot be empty");
+	if (!MOVE_IDENTIFIER_REGEX.test(name)) throw new Error(`Invalid module name: ${name}. Must start with a letter or underscore and contain only alphanumeric characters and underscores.`);
+}
+/**
+* Checks if a Move param type is address-like (address or Object<T>).
+*/
+function isAddressLikeType(moveType) {
+	return moveType === "address" || moveType.startsWith("0x1::object::Object");
+}
+/**
+* Move unsigned integer types with max values for range validation in the JSON fallback path.
+* KNOWN_BCS_BASES covers all BCS-encodable types and gates BCS-vs-JSON path selection.
+*/
+const UINT_MAX = new Map([
+	["u8", (1n << 8n) - 1n],
+	["u16", (1n << 16n) - 1n],
+	["u32", (1n << 32n) - 1n],
+	["u64", (1n << 64n) - 1n],
+	["u128", (1n << 128n) - 1n],
+	["u256", (1n << 256n) - 1n]
+]);
+/**
+* Converts a single arg to a JSON string for the Move VM.
+*
+* - Address params: auto-converts bech32 to hex.
+* - Uint params (u8-u256): validates range, converts bigint/number to quoted string.
+*   Rejects non-numeric/non-string types for uint params.
+* - All other cases: delegates to jsonStringifyArg (bigint-safe fallback).
+*/
+function convertArgToJson(arg, paramType) {
+	if (paramType && isAddressLikeType(paramType) && typeof arg === "string" && !arg.startsWith("0x")) try {
+		return JSON.stringify(AccAddress.toHex(arg));
+	} catch {}
+	const uintMax = paramType ? UINT_MAX.get(paramType) : void 0;
+	if (uintMax !== void 0) {
+		if (typeof arg === "bigint") {
+			if (arg < 0n || arg > uintMax) throw new Error(`Value ${arg} out of range for Move type ${paramType} (0..${uintMax}).`);
+			return JSON.stringify(arg.toString());
+		}
+		if (typeof arg === "number") {
+			if (!Number.isSafeInteger(arg) || arg < 0) throw new Error(`Unsafe number ${arg} for Move type ${paramType}. Expected a non-negative safe integer, or use BigInt.`);
+			if (BigInt(arg) > uintMax) throw new Error(`Value ${arg} out of range for Move type ${paramType} (0..${uintMax}).`);
+			return JSON.stringify(String(arg));
+		}
+		if (typeof arg !== "string") throw new Error(`Invalid argument type ${typeof arg} for Move type ${paramType}. Expected bigint, number, or string.`);
+	}
+	return jsonStringifyArg(arg);
+}
+/**
+* Checks if any param type contains unresolved generic references (T0, T1, ...).
+* Used to fall back to JSON path when BCS encoding is not possible.
+*/
+function hasUnresolvedGenerics(paramTypes) {
+	return paramTypes.some((p) => /\bT\d+\b/.test(p));
+}
+/**
+* Resolves generic type references (T0, T1, ...) in Move type strings
+* using the provided typeArgs array.
+*/
+function resolveGenericTypes(types, typeArgs) {
+	if (typeArgs.length === 0) return types;
+	return types.map((t) => t.replace(/\bT(\d+)\b/g, (match, indexStr) => {
+		const i = parseInt(indexStr);
+		return i < typeArgs.length ? typeArgs[i] : match;
+	}));
+}
+const KNOWN_BCS_BASES = new Set([
+	"bool",
+	"u8",
+	"u16",
+	"u32",
+	"u64",
+	"u128",
+	"u256",
+	"address",
+	"signer",
+	"vector",
+	"string",
+	"0x1::string::String",
+	"0x1::option::Option",
+	"0x1::object::Object",
+	"0x1::object::ObjectCore",
+	"0x1::fixed_point32::FixedPoint32",
+	"0x1::fixed_point64::FixedPoint64",
+	"0x1::decimal128::Decimal128",
+	"0x1::decimal256::Decimal256"
+]);
+/**
+* Checks if all param types can be BCS-encoded by resolveBcsType().
+* Recursively checks type args (e.g., vector<UnknownType> → false).
+*/
+function allTypesResolvable(paramTypes) {
+	function isResolvable(parsed) {
+		if (!KNOWN_BCS_BASES.has(parsed.base)) return false;
+		if (parsed.base === "0x1::object::Object" || parsed.base === "0x1::object::ObjectCore") return true;
+		return parsed.typeArgs.every(isResolvable);
+	}
+	return paramTypes.every((p) => isResolvable(parseMoveType(p)));
+}
+/**
+* Converts a JSON-parsed view response value to a typed value
+* based on the Move return type from the ABI.
+*
+* Only converts types where JSON representation differs from target:
+* - u64/u128/u256 JSON strings → bigint
+* - vector<T> → recursively converts elements
+* - Option<T> → null or recursively converts inner value
+*
+* Types that are already correct (bool, u8/u16/u32, address, string,
+* Object<T>, decimal, fixed_point) pass through unchanged.
+*/
+function convertJsonValue(value, parsed) {
+	const { base, typeArgs } = parsed;
+	switch (base) {
+		case "u64":
+		case "u128":
+		case "u256":
+			if (typeof value === "string") return BigInt(value);
+			if (typeof value === "number") return BigInt(value);
+			return value;
+		case "vector":
+			if (Array.isArray(value) && typeArgs.length === 1) return value.map((v) => convertJsonValue(v, typeArgs[0]));
+			return value;
+		case "0x1::option::Option":
+			if (value === null || value === void 0) return null;
+			if (typeof value === "object" && value !== null && "vec" in value) {
+				const vec = value.vec;
+				if (vec.length === 0) return null;
+				if (vec.length === 1 && typeArgs.length === 1) return convertJsonValue(vec[0], typeArgs[0]);
+			}
+			if (typeArgs.length === 1) return convertJsonValue(value, typeArgs[0]);
+			return value;
+		default: return value;
+	}
+}
+/**
+* Converts a view function's JSON response to typed values.
+*
+* @param jsonParsed - Result of JSON.parse(response.data)
+* @param returnTypes - ABI return types (fn.return)
+* @returns Typed value (single) or typed array (multiple returns)
+*/
+function convertViewResponse(jsonParsed, returnTypes) {
+	if (returnTypes.length === 0) return jsonParsed;
+	if (returnTypes.length === 1) return convertJsonValue(jsonParsed, parseMoveType(returnTypes[0]));
+	if (Array.isArray(jsonParsed)) return jsonParsed.map((val, i) => i < returnTypes.length ? convertJsonValue(val, parseMoveType(returnTypes[i])) : val);
+	return jsonParsed;
+}
+/**
+* Internal sync helper — builds a MoveContract from a resolved ABI.
+* Shared by both the static ABI (sync) and runtime ABI (async) overloads.
+*/
+function buildContract(context, moduleAddress, moduleName, abi) {
+	const moveClient = context.client.move;
+	const decimalsCache = /* @__PURE__ */ new Map();
+	const execute = new Proxy({}, { get(_, functionName) {
+		return (sender, callOptions) => {
+			const fn = findFunction(abi, functionName);
+			if (!fn) throw new ContractError("move", 0, `Function not found: ${functionName}`);
+			if (!fn.is_entry) throw new ContractError("move", 0, `Function is not an entry function: ${functionName}`);
+			const typeArgs = callOptions?.typeArgs ?? [];
+			const args = callOptions?.args ?? [];
+			const resolvedParams = resolveGenericTypes(getNonSignerParams(fn), typeArgs);
+			if (!hasUnresolvedGenerics(resolvedParams) && allTypesResolvable(resolvedParams)) return new Message$1(MsgExecuteSchema, {
+				sender,
+				moduleAddress,
+				moduleName,
+				functionName,
+				typeArgs,
+				args: encodeMoveArgs(args, resolvedParams)
+			});
+			return new Message$1(MsgExecuteJSONSchema, {
+				sender,
+				moduleAddress,
+				moduleName,
+				functionName,
+				typeArgs,
+				args: args.map((arg, i) => convertArgToJson(arg, resolvedParams[i]))
+			});
+		};
+	} });
+	const view = new Proxy({}, { get(_, functionName) {
+		return async (callOptions) => {
+			const fn = findFunction(abi, functionName);
+			if (!fn) throw new ContractError("move", 0, `Function not found: ${functionName}`);
+			if (!fn.is_view) throw new ContractError("move", 0, `Function is not a view function: ${functionName}`);
+			const typeArgs = callOptions?.typeArgs ?? [];
+			const args = callOptions?.args ?? [];
+			const resolvedParams = resolveGenericTypes(getNonSignerParams(fn), typeArgs);
+			const jsonArgs = args.map((arg, i) => convertArgToJson(arg, resolvedParams[i]));
+			const response = await moveClient.viewJSON({
+				address: moduleAddress,
+				moduleName,
+				functionName,
+				typeArgs,
+				args: jsonArgs
+			});
+			try {
+				const parsed = JSON.parse(response.data);
+				const resolvedReturns = resolveGenericTypes(fn.return, typeArgs);
+				if (resolvedReturns.length > 0 && !hasUnresolvedGenerics(resolvedReturns) && allTypesResolvable(resolvedReturns)) return convertViewResponse(parsed, resolvedReturns);
+				return parsed;
+			} catch {
+				return response.data;
+			}
+		};
+	} });
+	async function resource(address, structTag) {
+		const response = await moveClient.resource({
+			address,
+			structTag
+		});
+		if (!response.resource) throw new ContractError("move", 0, `Resource not found: ${structTag}`);
+		try {
+			return JSON.parse(response.resource.moveResource);
+		} catch {
+			return response.resource.moveResource;
+		}
+	}
+	async function tableEntry(tableHandle, key, keyType) {
+		const keyBytes = encodeMoveArgs([key], [keyType])[0];
+		const response = await moveClient.tableEntry({
+			address: tableHandle,
+			keyBytes
+		});
+		if (!response.tableEntry) throw new ContractError("move", 0, `Table entry not found`);
+		try {
+			return JSON.parse(response.tableEntry.value);
+		} catch {
+			return response.tableEntry.value;
+		}
+	}
+	async function getDecimals(coinType) {
+		const cached = decimalsCache.get(coinType);
+		if (cached !== void 0) return cached;
+		const coinInfoTag = `0x1::coin::CoinInfo<${coinType}>`;
+		const coinTypeMatch = coinType.match(/^(0x[0-9a-fA-F]+)::/);
+		const decimals = (await resource(coinTypeMatch ? coinTypeMatch[1] : "0x1", coinInfoTag)).decimals;
+		decimalsCache.set(coinType, decimals);
+		return decimals;
+	}
+	async function parseUnitsForCoin(value, coinType) {
+		return parseUnits(value, await getDecimals(coinType));
+	}
+	async function formatUnitsForCoin(value, coinType) {
+		return formatUnits(value, await getDecimals(coinType));
+	}
+	async function getTokenInfo(coinType) {
+		const coinInfoTag = `0x1::coin::CoinInfo<${coinType}>`;
+		const coinTypeMatch = coinType.match(/^(0x[0-9a-fA-F]+)::/);
+		const coinInfo = await resource(coinTypeMatch ? coinTypeMatch[1] : "0x1", coinInfoTag);
+		decimalsCache.set(coinType, coinInfo.decimals);
+		return {
+			name: coinInfo.name,
+			symbol: coinInfo.symbol,
+			decimals: coinInfo.decimals,
+			totalSupply: coinInfo.supply ? BigInt(coinInfo.supply.value) : void 0
+		};
+	}
+	return {
+		moduleAddress,
+		moduleName,
+		abi,
+		execute,
+		view,
+		resource,
+		tableEntry,
+		parseUnits: parseUnitsForCoin,
+		formatUnits: formatUnitsForCoin,
+		getTokenInfo
+	};
+}
+function createMoveContract(context, abiOrAddress, moduleName, options = {}) {
+	if (typeof abiOrAddress !== "string") {
+		const abi = abiOrAddress;
+		validateModuleAddress(abi.address);
+		validateModuleName(abi.name);
+		return buildContract(context, abi.address, abi.name, abi);
+	}
+	const moduleAddress = abiOrAddress;
+	validateModuleAddress(moduleAddress);
+	validateModuleName(moduleName);
+	return (async () => {
+		return buildContract(context, moduleAddress, moduleName, options.abi ?? await getModuleAbi(context, moduleAddress, moduleName, {
+			useCache: options.useCache,
+			cacheTtl: options.cacheTtl
+		}));
+	})();
+}
+/**
+* Creates a MsgPublish for publishing Move modules.
+*
+* @param options - Publish options
+* @returns MsgPublish message for signing
+*
+* @example
+* ```typescript
+* const msg = createPublishMsg({
+*   sender: 'init1...',
+*   codeBytes: [compiledModule1, compiledModule2],
+*   upgradePolicy: UpgradePolicy.COMPATIBLE,
+* })
+* await ctx.signAndBroadcast([msg])
+* ```
+*/
+function createPublishMsg(options) {
+	return create(MsgPublishSchema, {
+		sender: options.sender,
+		codeBytes: options.codeBytes,
+		upgradePolicy: options.upgradePolicy ?? UpgradePolicy.COMPATIBLE
+	});
+}
+/**
+* Creates a MsgScriptJSON for executing a Move script.
+*
+* @param options - Script execution options
+* @returns MsgScriptJSON message for signing
+*
+* @example
+* ```typescript
+* const msg = createScriptMsg({
+*   sender: 'init1...',
+*   codeBytes: compiledScript,
+*   typeArgs: ['0x1::native_uinit::Coin'],
+*   args: ['1000000'],
+* })
+* await ctx.signAndBroadcast([msg])
+* ```
+*/
+function createScriptMsg(options) {
+	const jsonArgs = (options.args ?? []).map((arg) => {
+		if (arg instanceof Uint8Array) return JSON.stringify(Array.from(arg));
+		return jsonStringifyArg(arg);
+	});
+	return create(MsgScriptJSONSchema, {
+		sender: options.sender,
+		codeBytes: options.codeBytes,
+		typeArgs: options.typeArgs ?? [],
+		args: jsonArgs
+	});
+}
+/**
+* Creates a MsgScript with BCS-encoded arguments.
+*
+* Use this when you have pre-encoded BCS arguments. For simpler JSON arguments,
+* use createScriptMsg() instead.
+*
+* @param options - Script execution options with BCS-encoded args
+* @returns MsgScript message for signing
+*
+* @example
+* ```typescript
+* const msg = createBcsScriptMsg({
+*   sender: 'init1...',
+*   codeBytes: compiledScript,
+*   typeArgs: ['0x1::native_uinit::Coin'],
+*   args: [bcsEncodedAmount], // Pre-encoded BCS bytes
+* })
+* await ctx.signAndBroadcast([msg])
+* ```
+*/
+function createBcsScriptMsg(options) {
+	return create(MsgScriptSchema, {
+		sender: options.sender,
+		codeBytes: options.codeBytes,
+		typeArgs: options.typeArgs ?? [],
+		args: options.args ?? []
+	});
+}
+/**
+* Creates a MsgExecuteJSON directly without a contract instance.
+*
+* @param sender - Sender address
+* @param moduleAddress - Module address
+* @param moduleName - Module name
+* @param functionName - Function name
+* @param typeArgs - Type arguments
+* @param args - Function arguments (will be JSON stringified)
+* @returns MsgExecuteJSON message for signing
+*
+* @example
+* ```typescript
+* const msg = createExecuteMsg(
+*   sender,
+*   '0x1',
+*   'coin',
+*   'transfer',
+*   ['0x1::native_uinit::Coin'],
+*   [recipient, '1000000']
+* )
+* ```
+*/
+function createExecuteMsg(sender, moduleAddress, moduleName, functionName, typeArgs = [], args = []) {
+	return create(MsgExecuteJSONSchema, {
+		sender,
+		moduleAddress,
+		moduleName,
+		functionName,
+		typeArgs,
+		args: args.map(jsonStringifyArg)
+	});
+}
+/**
+* Calls a view function directly without creating a contract instance.
+*
+* @param context - ChainContext with client (must have move service)
+* @param moduleAddress - Module address
+* @param moduleName - Module name
+* @param functionName - Function name
+* @param typeArgs - Type arguments
+* @param args - Function arguments (will be JSON stringified)
+* @returns View function result
+*
+* @example
+* ```typescript
+* const balance = await callViewFunction(
+*   ctx,
+*   '0x1',
+*   'coin',
+*   'balance',
+*   ['0x1::native_uinit::Coin'],
+*   [address]
+* )
+* ```
+*/
+async function callViewFunction(context, moduleAddress, moduleName, functionName, typeArgs = [], args = []) {
+	const moveClient = context.client.move;
+	const jsonArgs = args.map(jsonStringifyArg);
+	const response = await moveClient.viewJSON({
+		address: moduleAddress,
+		moduleName,
+		functionName,
+		typeArgs,
+		args: jsonArgs
+	});
+	try {
+		return JSON.parse(response.data);
+	} catch {
+		return response.data;
+	}
+}
+/**
+* Parse a full Move function identifier into components.
+* @example parseMoveFunction('0x1::coin::transfer')
+* // → { moduleAddress: '0x1', moduleName: 'coin', functionName: 'transfer' }
+*/
+function parseMoveFunction(fn) {
+	const parts = fn.split("::");
+	if (parts.length !== 3) throw new ContractError("move", 0, `Invalid Move function identifier: "${fn}". Expected format: "address::module::function"`);
+	return {
+		moduleAddress: parts[0],
+		moduleName: parts[1],
+		functionName: parts[2]
+	};
+}
+/**
+* Build a Move execute message using a combined function identifier.
+*
+* Without paramTypes: creates MsgExecuteJSON (chain handles type resolution).
+* With paramTypes: attempts BCS encoding (MsgExecute), falls back to JSON with bech32 conversion.
+*
+* @example
+* ```typescript
+* // Simple (JSON path)
+* const msg = buildMoveExecute(sender, {
+*   function: '0x1::coin::transfer',
+*   typeArgs: ['0x1::native_uinit::Coin'],
+*   args: ['0xrecipient', '1000000'],
+* })
+*
+* // With BCS + bech32
+* const msg = buildMoveExecute(sender, {
+*   function: '0x1::coin::transfer',
+*   typeArgs: ['0x1::native_uinit::Coin'],
+*   args: ['init1qwer...', 1000000n],
+*   paramTypes: ['address', 'u64'],
+* })
+* ```
+*/
+function buildMoveExecute(sender, options) {
+	const { moduleAddress, moduleName, functionName } = parseMoveFunction(options.function);
+	const typeArgs = options.typeArgs ?? [];
+	const args = options.args ?? [];
+	if (options.paramTypes) {
+		const resolvedParams = resolveGenericTypes(options.paramTypes, typeArgs);
+		if (!hasUnresolvedGenerics(resolvedParams) && allTypesResolvable(resolvedParams)) return new Message$1(MsgExecuteSchema, {
+			sender,
+			moduleAddress,
+			moduleName,
+			functionName,
+			typeArgs,
+			args: encodeMoveArgs(args, resolvedParams)
+		});
+		return new Message$1(MsgExecuteJSONSchema, {
+			sender,
+			moduleAddress,
+			moduleName,
+			functionName,
+			typeArgs,
+			args: args.map((arg, i) => convertArgToJson(arg, resolvedParams[i]))
+		});
+	}
+	return new Message$1(MsgExecuteJSONSchema, {
+		sender,
+		moduleAddress,
+		moduleName,
+		functionName,
+		typeArgs,
+		args: args.map(jsonStringifyArg)
+	});
+}
+/**
+* Call a Move view function using a combined function identifier.
+*
+* Without returns: returns raw JSON.parse result.
+* With returns: converts response to typed values (u64→bigint, etc.).
+* With paramTypes: applies bech32→hex conversion on args.
+*
+* @example
+* ```typescript
+* // Typed response
+* const balance = await buildMoveView(ctx, {
+*   function: '0x1::coin::balance',
+*   typeArgs: ['0x1::native_uinit::Coin'],
+*   args: ['0xaddress'],
+*   returns: ['u64'],
+* })
+* // balance: bigint
+*
+* // With bech32 args + typed response
+* const balance = await buildMoveView(ctx, {
+*   function: '0x1::coin::balance',
+*   typeArgs: ['0x1::native_uinit::Coin'],
+*   args: ['init1qwer...'],
+*   paramTypes: ['address'],
+*   returns: ['u64'],
+* })
+* ```
+*/
+async function buildMoveView(context, options) {
+	const { moduleAddress, moduleName, functionName } = parseMoveFunction(options.function);
+	const typeArgs = options.typeArgs ?? [];
+	const args = options.args ?? [];
+	let jsonArgs;
+	if (options.paramTypes) {
+		const resolvedParams = resolveGenericTypes(options.paramTypes, typeArgs);
+		jsonArgs = args.map((arg, i) => convertArgToJson(arg, resolvedParams[i]));
+	} else jsonArgs = args.map(jsonStringifyArg);
+	const response = await context.client.move.viewJSON({
+		address: moduleAddress,
+		moduleName,
+		functionName,
+		typeArgs,
+		args: jsonArgs
+	});
+	try {
+		const parsed = JSON.parse(response.data);
+		if (options.returns && options.returns.length > 0) {
+			const resolvedReturns = resolveGenericTypes(options.returns, typeArgs);
+			if (!hasUnresolvedGenerics(resolvedReturns) && allTypesResolvable(resolvedReturns)) return convertViewResponse(parsed, resolvedReturns);
+		}
+		return parsed;
+	} catch {
+		return response.data;
+	}
+}
+/**
+* Queries a Move resource directly.
+*
+* @param context - ChainContext with client (must have move service)
+* @param address - Account address
+* @param structTag - Resource struct tag (e.g., '0x1::coin::CoinStore<0x1::native_uinit::Coin>')
+* @returns Parsed resource data
+*
+* @example
+* ```typescript
+* const resource = await queryResource(ctx, '0x1', '0x1::coin::CoinInfo<...>')
+* ```
+*/
+async function queryResource(context, address, structTag) {
+	const response = await context.client.move.resource({
+		address,
+		structTag
+	});
+	if (!response.resource) throw new ContractError("move", 0, `Resource not found: ${structTag}`);
+	try {
+		return JSON.parse(response.resource.moveResource);
+	} catch {
+		return response.resource.moveResource;
+	}
+}
+/**
+* Queries a Move table entry directly.
+*
+* @param context - ChainContext with client (must have move service)
+* @param tableHandle - Table handle address
+* @param key - Key value
+* @param keyType - Key type for BCS encoding
+* @returns Parsed table entry value
+*
+* @example
+* ```typescript
+* const entry = await queryTableEntry(ctx, tableHandle, key, 'address')
+* ```
+*/
+async function queryTableEntry(context, tableHandle, key, keyType) {
+	const moveClient = context.client.move;
+	const keyBytes = encodeMoveArgs([key], [keyType])[0];
+	const response = await moveClient.tableEntry({
+		address: tableHandle,
+		keyBytes
+	});
+	if (!response.tableEntry) throw new ContractError("move", 0, `Table entry not found`);
+	try {
+		return JSON.parse(response.tableEntry.value);
+	} catch {
+		return response.tableEntry.value;
+	}
+}
+//#endregion
+export { createExecuteMsg as a, createScriptMsg as c, createBcsScriptMsg as i, queryResource as l, buildMoveView as n, createMoveContract as o, callViewFunction as r, createPublishMsg as s, buildMoveExecute as t, queryTableEntry as u };
+
+//# sourceMappingURL=contract-Dpvu4wLO.mjs.map