@haneullabs/haneul 0.1.0 → 2.5.0

package/dist/transactions/pure.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure.d.mts","names":[],"sources":["../../src/transactions/pure.ts"],"sourcesContent":[],"mappings":";;;;iBAUgB,gCAAgC,0BAA0B,eAAe;gBAC7D,oBACpB,aAAa,eAAe,kBAAkB,QAAQ,aACrD,sBAAsB,QAC3B;EAJY,CAAA,KAAA,EAWP,aAXiB,CAAA,GAAA,EAAA,GAAA,CAAA,GAWS,UAXT,CAAA,EAYtB,CAZsB;EAAsB,EAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EA6BvB,CA7BuB;EAA0B,GAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EA8BhD,CA9BgD;EAAe,GAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EA+B/D,CA/B+D;EAC7D,GAAA,CAAA,KAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,CAAA,EA+BgB,CA/BhB;EACpB,IAAA,CAAA,KAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,CAAA,EA+BqC,CA/BrC;EAAa,IAAA,CAAA,KAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,CAAA,EAgCwB,CAhCxB;EAAiC,IAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAiC1B,CAjC0B;EAAlB,MAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAkCP,CAlCO;EAA0B,OAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAmChC,CAnCgC;EAC/B,EAAA,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GAkCD,CAlCC;EAAtB,MAAA,CAAA,aAoCoB,YApCpB,CAAA,CAAA,IAAA,EAqCD,IArCC,SAqCY,YArCZ,GAqC2B,iBArC3B,CAqC6C,IArC7C,CAAA,GAqCqD,IArCrD,EAAA,KAAA,EAsCA,QAtCA,CAsCS,qBAtCT,CAsC+B,IAtC/B,CAAA,CAAA,GAAA;IACL,MAAA,EAAA,MAAA;EAOK,CAAA,CAAA,EA8B0D,CA9B1D;EAA0B,MAAA,CAAA,aAoCN,YApCM,CAAA,CAAA,IAAA,EAqC3B,IArC2B,SAqCd,YArCc,GAqCC,iBArCD,CAqCmB,IArCnB,CAAA,GAqC2B,IArC3B,EAAA,KAAA,EAsC1B,qBAtC0B,CAsCJ,IAtCI,CAAA,GAAA,IAAA,GAAA,SAAA,CAAA,EAsCoB,CAtCpB;CAC/B"}

package/dist/transactions/pure.mjs

@@ -0,0 +1,33 @@
+import { pureBcsSchemaFromTypeName } from "../bcs/pure.mjs";
+import { bcs as suiBcs } from "../bcs/index.mjs";
+import { isSerializedBcs } from "@haneullabs/bcs";
+
+//#region src/transactions/pure.ts
+function createPure(makePure) {
+	function pure(typeOrSerializedValue, value) {
+		if (typeof typeOrSerializedValue === "string") return makePure(pureBcsSchemaFromTypeName(typeOrSerializedValue).serialize(value));
+		if (typeOrSerializedValue instanceof Uint8Array || isSerializedBcs(typeOrSerializedValue)) return makePure(typeOrSerializedValue);
+		throw new Error("tx.pure must be called either a bcs type name, or a serialized bcs value");
+	}
+	pure.u8 = (value) => makePure(suiBcs.U8.serialize(value));
+	pure.u16 = (value) => makePure(suiBcs.U16.serialize(value));
+	pure.u32 = (value) => makePure(suiBcs.U32.serialize(value));
+	pure.u64 = (value) => makePure(suiBcs.U64.serialize(value));
+	pure.u128 = (value) => makePure(suiBcs.U128.serialize(value));
+	pure.u256 = (value) => makePure(suiBcs.U256.serialize(value));
+	pure.bool = (value) => makePure(suiBcs.Bool.serialize(value));
+	pure.string = (value) => makePure(suiBcs.String.serialize(value));
+	pure.address = (value) => makePure(suiBcs.Address.serialize(value));
+	pure.id = pure.address;
+	pure.vector = (type, value) => {
+		return makePure(suiBcs.vector(pureBcsSchemaFromTypeName(type)).serialize(value));
+	};
+	pure.option = (type, value) => {
+		return makePure(suiBcs.option(pureBcsSchemaFromTypeName(type)).serialize(value));
+	};
+	return pure;
+}
+
+//#endregion
+export { createPure };
+//# sourceMappingURL=pure.mjs.map

package/dist/transactions/pure.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure.mjs","names":["bcs"],"sources":["../../src/transactions/pure.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { isSerializedBcs } from '@haneullabs/bcs';\nimport type { SerializedBcs } from '@haneullabs/bcs';\n\nimport { bcs } from '../bcs/index.js';\nimport { pureBcsSchemaFromTypeName } from '../bcs/pure.js';\nimport type { PureTypeName, ShapeFromPureTypeName, ValidPureTypeName } from '../bcs/pure.js';\n\nexport function createPure<T>(makePure: (value: SerializedBcs<any, any> | Uint8Array) => T) {\n\tfunction pure<Type extends PureTypeName>(\n\t\ttype: Type extends PureTypeName ? ValidPureTypeName<Type> : Type,\n\t\tvalue: ShapeFromPureTypeName<Type>,\n\t): T;\n\n\tfunction pure(\n\t\t/**\n\t\t * The pure value, serialized to BCS. If this is a Uint8Array, then the value\n\t\t * is assumed to be raw bytes, and will be used directly.\n\t\t */\n\t\tvalue: SerializedBcs<any, any> | Uint8Array,\n\t): T;\n\n\tfunction pure(\n\t\ttypeOrSerializedValue?: PureTypeName | SerializedBcs<any, any> | Uint8Array,\n\t\tvalue?: unknown,\n\t): T {\n\t\tif (typeof typeOrSerializedValue === 'string') {\n\t\t\treturn makePure(pureBcsSchemaFromTypeName(typeOrSerializedValue).serialize(value as never));\n\t\t}\n\n\t\tif (typeOrSerializedValue instanceof Uint8Array || isSerializedBcs(typeOrSerializedValue)) {\n\t\t\treturn makePure(typeOrSerializedValue);\n\t\t}\n\n\t\tthrow new Error('tx.pure must be called either a bcs type name, or a serialized bcs value');\n\t}\n\n\tpure.u8 = (value: number) => makePure(bcs.U8.serialize(value));\n\tpure.u16 = (value: number) => makePure(bcs.U16.serialize(value));\n\tpure.u32 = (value: number) => makePure(bcs.U32.serialize(value));\n\tpure.u64 = (value: bigint | number | string) => makePure(bcs.U64.serialize(value));\n\tpure.u128 = (value: bigint | number | string) => makePure(bcs.U128.serialize(value));\n\tpure.u256 = (value: bigint | number | string) => makePure(bcs.U256.serialize(value));\n\tpure.bool = (value: boolean) => makePure(bcs.Bool.serialize(value));\n\tpure.string = (value: string) => makePure(bcs.String.serialize(value));\n\tpure.address = (value: string) => makePure(bcs.Address.serialize(value));\n\tpure.id = pure.address;\n\tpure.vector = <Type extends PureTypeName>(\n\t\ttype: Type extends PureTypeName ? ValidPureTypeName<Type> : Type,\n\t\tvalue: Iterable<ShapeFromPureTypeName<Type>> & { length: number },\n\t) => {\n\t\treturn makePure(\n\t\t\tbcs.vector(pureBcsSchemaFromTypeName(type as PureTypeName)).serialize(value as never),\n\t\t);\n\t};\n\tpure.option = <Type extends PureTypeName>(\n\t\ttype: Type extends PureTypeName ? ValidPureTypeName<Type> : Type,\n\t\tvalue: ShapeFromPureTypeName<Type> | null | undefined,\n\t) => {\n\t\treturn makePure(bcs.option(pureBcsSchemaFromTypeName(type)).serialize(value as never));\n\t};\n\n\treturn pure;\n}\n"],"mappings":";;;;;AAUA,SAAgB,WAAc,UAA8D;CAc3F,SAAS,KACR,uBACA,OACI;AACJ,MAAI,OAAO,0BAA0B,SACpC,QAAO,SAAS,0BAA0B,sBAAsB,CAAC,UAAU,MAAe,CAAC;AAG5F,MAAI,iCAAiC,cAAc,gBAAgB,sBAAsB,CACxF,QAAO,SAAS,sBAAsB;AAGvC,QAAM,IAAI,MAAM,2EAA2E;;AAG5F,MAAK,MAAM,UAAkB,SAASA,OAAI,GAAG,UAAU,MAAM,CAAC;AAC9D,MAAK,OAAO,UAAkB,SAASA,OAAI,IAAI,UAAU,MAAM,CAAC;AAChE,MAAK,OAAO,UAAkB,SAASA,OAAI,IAAI,UAAU,MAAM,CAAC;AAChE,MAAK,OAAO,UAAoC,SAASA,OAAI,IAAI,UAAU,MAAM,CAAC;AAClF,MAAK,QAAQ,UAAoC,SAASA,OAAI,KAAK,UAAU,MAAM,CAAC;AACpF,MAAK,QAAQ,UAAoC,SAASA,OAAI,KAAK,UAAU,MAAM,CAAC;AACpF,MAAK,QAAQ,UAAmB,SAASA,OAAI,KAAK,UAAU,MAAM,CAAC;AACnE,MAAK,UAAU,UAAkB,SAASA,OAAI,OAAO,UAAU,MAAM,CAAC;AACtE,MAAK,WAAW,UAAkB,SAASA,OAAI,QAAQ,UAAU,MAAM,CAAC;AACxE,MAAK,KAAK,KAAK;AACf,MAAK,UACJ,MACA,UACI;AACJ,SAAO,SACNA,OAAI,OAAO,0BAA0B,KAAqB,CAAC,CAAC,UAAU,MAAe,CACrF;;AAEF,MAAK,UACJ,MACA,UACI;AACJ,SAAO,SAASA,OAAI,OAAO,0BAA0B,KAAK,CAAC,CAAC,UAAU,MAAe,CAAC;;AAGvF,QAAO"}

package/dist/transactions/resolve.d.mts

@@ -0,0 +1,16 @@
+import { TransactionDataBuilder } from "./TransactionData.mjs";
+import { ClientWithCoreApi } from "../client/core.mjs";
+import "../client/index.mjs";
+
+//#region src/transactions/resolve.d.ts
+interface BuildTransactionOptions {
+  client?: ClientWithCoreApi;
+  onlyTransactionKind?: boolean;
+}
+interface SerializeTransactionOptions extends BuildTransactionOptions {
+  supportedIntents?: string[];
+}
+type TransactionPlugin = (transactionData: TransactionDataBuilder, options: BuildTransactionOptions, next: () => Promise<void>) => Promise<void>;
+//#endregion
+export { BuildTransactionOptions, SerializeTransactionOptions, TransactionPlugin };
+//# sourceMappingURL=resolve.d.mts.map

package/dist/transactions/resolve.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.mts","names":[],"sources":["../../src/transactions/resolve.ts"],"sourcesContent":[],"mappings":";;;;;UAYiB,uBAAA;WACP;;AADV;AAKiB,UAAA,2BAAA,SAAoC,uBAAuB,CAAA;EAIhE,gBAAA,CAAA,EAAA,MAAiB,EAAA;;AAEnB,KAFE,iBAAA,GAEF,CAAA,eAAA,EADQ,sBACR,EAAA,OAAA,EAAA,uBAAA,EAAA,IAAA,EAAA,GAAA,GACG,OADH,CAAA,IAAA,CAAA,EAAA,GAEL,OAFK,CAAA,IAAA,CAAA"}

package/dist/transactions/resolve.mjs

@@ -0,0 +1,57 @@
+import { bcs as suiBcs } from "../bcs/index.mjs";
+import { Inputs } from "./Inputs.mjs";
+import { coreClientResolveTransactionPlugin } from "../client/core-resolver.mjs";
+
+//#region src/transactions/resolve.ts
+function needsTransactionResolution(data, options) {
+	if (data.inputs.some((input) => {
+		return input.UnresolvedObject || input.UnresolvedPure;
+	})) return true;
+	if (!options.onlyTransactionKind) {
+		if (!data.gasData.price || !data.gasData.budget || !data.gasData.payment) return true;
+		if (data.gasData.payment.length === 0 && !data.expiration) return true;
+	}
+	return false;
+}
+async function resolveTransactionPlugin(transactionData, options, next) {
+	normalizeRawArguments(transactionData);
+	if (!needsTransactionResolution(transactionData, options)) {
+		await validate(transactionData);
+		return next();
+	}
+	return (getClient(options).core?.resolveTransactionPlugin() ?? coreClientResolveTransactionPlugin)(transactionData, options, async () => {
+		await validate(transactionData);
+		await next();
+	});
+}
+function validate(transactionData) {
+	transactionData.inputs.forEach((input, index) => {
+		if (input.$kind !== "Object" && input.$kind !== "Pure" && input.$kind !== "FundsWithdrawal") throw new Error(`Input at index ${index} has not been resolved.  Expected a Pure, Object, or FundsWithdrawal input, but found ${JSON.stringify(input)}`);
+	});
+}
+function getClient(options) {
+	if (!options.client) throw new Error(`No haneul client passed to Transaction#build, but transaction data was not sufficient to build offline.`);
+	return options.client;
+}
+function normalizeRawArguments(transactionData) {
+	for (const command of transactionData.commands) switch (command.$kind) {
+		case "SplitCoins":
+			command.SplitCoins.amounts.forEach((amount) => {
+				normalizeRawArgument(amount, suiBcs.U64, transactionData);
+			});
+			break;
+		case "TransferObjects":
+			normalizeRawArgument(command.TransferObjects.address, suiBcs.Address, transactionData);
+			break;
+	}
+}
+function normalizeRawArgument(arg, schema, transactionData) {
+	if (arg.$kind !== "Input") return;
+	const input = transactionData.inputs[arg.Input];
+	if (input.$kind !== "UnresolvedPure") return;
+	transactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value));
+}
+
+//#endregion
+export { needsTransactionResolution, resolveTransactionPlugin };
+//# sourceMappingURL=resolve.mjs.map

package/dist/transactions/resolve.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.mjs","names":["bcs"],"sources":["../../src/transactions/resolve.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Argument } from './data/internal.js';\n\nimport type { ClientWithCoreApi } from '../client/index.js';\nimport type { TransactionDataBuilder } from './TransactionData.js';\nimport type { BcsType } from '@haneullabs/bcs';\nimport { Inputs } from './Inputs.js';\nimport { bcs } from '../bcs/index.js';\nimport { coreClientResolveTransactionPlugin } from '../client/core-resolver.js';\n\nexport interface BuildTransactionOptions {\n\tclient?: ClientWithCoreApi;\n\tonlyTransactionKind?: boolean;\n}\n\nexport interface SerializeTransactionOptions extends BuildTransactionOptions {\n\tsupportedIntents?: string[];\n}\n\nexport type TransactionPlugin = (\n\ttransactionData: TransactionDataBuilder,\n\toptions: BuildTransactionOptions,\n\tnext: () => Promise<void>,\n) => Promise<void>;\n\nexport function needsTransactionResolution(\n\tdata: TransactionDataBuilder,\n\toptions: BuildTransactionOptions,\n): boolean {\n\tif (\n\t\tdata.inputs.some((input) => {\n\t\t\treturn input.UnresolvedObject || input.UnresolvedPure;\n\t\t})\n\t) {\n\t\treturn true;\n\t}\n\n\tif (!options.onlyTransactionKind) {\n\t\tif (!data.gasData.price || !data.gasData.budget || !data.gasData.payment) {\n\t\t\treturn true;\n\t\t}\n\n\t\tif (data.gasData.payment.length === 0 && !data.expiration) {\n\t\t\treturn true;\n\t\t}\n\t}\n\n\treturn false;\n}\n\nexport async function resolveTransactionPlugin(\n\ttransactionData: TransactionDataBuilder,\n\toptions: BuildTransactionOptions,\n\tnext: () => Promise<void>,\n) {\n\tnormalizeRawArguments(transactionData);\n\tif (!needsTransactionResolution(transactionData, options)) {\n\t\tawait validate(transactionData);\n\t\treturn next();\n\t}\n\n\tconst client = getClient(options);\n\tconst plugin = client.core?.resolveTransactionPlugin() ?? coreClientResolveTransactionPlugin;\n\n\treturn plugin(transactionData, options, async () => {\n\t\tawait validate(transactionData);\n\t\tawait next();\n\t});\n}\n\nfunction validate(transactionData: TransactionDataBuilder) {\n\ttransactionData.inputs.forEach((input, index) => {\n\t\tif (input.$kind !== 'Object' && input.$kind !== 'Pure' && input.$kind !== 'FundsWithdrawal') {\n\t\t\tthrow new Error(\n\t\t\t\t`Input at index ${index} has not been resolved.  Expected a Pure, Object, or FundsWithdrawal input, but found ${JSON.stringify(\n\t\t\t\t\tinput,\n\t\t\t\t)}`,\n\t\t\t);\n\t\t}\n\t});\n}\n\nexport function getClient(options: BuildTransactionOptions) {\n\tif (!options.client) {\n\t\tthrow new Error(\n\t\t\t`No haneul client passed to Transaction#build, but transaction data was not sufficient to build offline.`,\n\t\t);\n\t}\n\n\treturn options.client;\n}\n\nfunction normalizeRawArguments(transactionData: TransactionDataBuilder) {\n\tfor (const command of transactionData.commands) {\n\t\tswitch (command.$kind) {\n\t\t\tcase 'SplitCoins':\n\t\t\t\tcommand.SplitCoins.amounts.forEach((amount) => {\n\t\t\t\t\tnormalizeRawArgument(amount, bcs.U64, transactionData);\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t\tcase 'TransferObjects':\n\t\t\t\tnormalizeRawArgument(command.TransferObjects.address, bcs.Address, transactionData);\n\t\t\t\tbreak;\n\t\t}\n\t}\n}\n\nfunction normalizeRawArgument(\n\targ: Argument,\n\tschema: BcsType<any>,\n\ttransactionData: TransactionDataBuilder,\n) {\n\tif (arg.$kind !== 'Input') {\n\t\treturn;\n\t}\n\tconst input = transactionData.inputs[arg.Input];\n\n\tif (input.$kind !== 'UnresolvedPure') {\n\t\treturn;\n\t}\n\n\ttransactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value));\n}\n"],"mappings":";;;;;AA2BA,SAAgB,2BACf,MACA,SACU;AACV,KACC,KAAK,OAAO,MAAM,UAAU;AAC3B,SAAO,MAAM,oBAAoB,MAAM;GACtC,CAEF,QAAO;AAGR,KAAI,CAAC,QAAQ,qBAAqB;AACjC,MAAI,CAAC,KAAK,QAAQ,SAAS,CAAC,KAAK,QAAQ,UAAU,CAAC,KAAK,QAAQ,QAChE,QAAO;AAGR,MAAI,KAAK,QAAQ,QAAQ,WAAW,KAAK,CAAC,KAAK,WAC9C,QAAO;;AAIT,QAAO;;AAGR,eAAsB,yBACrB,iBACA,SACA,MACC;AACD,uBAAsB,gBAAgB;AACtC,KAAI,CAAC,2BAA2B,iBAAiB,QAAQ,EAAE;AAC1D,QAAM,SAAS,gBAAgB;AAC/B,SAAO,MAAM;;AAMd,SAHe,UAAU,QAAQ,CACX,MAAM,0BAA0B,IAAI,oCAE5C,iBAAiB,SAAS,YAAY;AACnD,QAAM,SAAS,gBAAgB;AAC/B,QAAM,MAAM;GACX;;AAGH,SAAS,SAAS,iBAAyC;AAC1D,iBAAgB,OAAO,SAAS,OAAO,UAAU;AAChD,MAAI,MAAM,UAAU,YAAY,MAAM,UAAU,UAAU,MAAM,UAAU,kBACzE,OAAM,IAAI,MACT,kBAAkB,MAAM,wFAAwF,KAAK,UACpH,MACA,GACD;GAED;;AAGH,SAAgB,UAAU,SAAkC;AAC3D,KAAI,CAAC,QAAQ,OACZ,OAAM,IAAI,MACT,0GACA;AAGF,QAAO,QAAQ;;AAGhB,SAAS,sBAAsB,iBAAyC;AACvE,MAAK,MAAM,WAAW,gBAAgB,SACrC,SAAQ,QAAQ,OAAhB;EACC,KAAK;AACJ,WAAQ,WAAW,QAAQ,SAAS,WAAW;AAC9C,yBAAqB,QAAQA,OAAI,KAAK,gBAAgB;KACrD;AACF;EACD,KAAK;AACJ,wBAAqB,QAAQ,gBAAgB,SAASA,OAAI,SAAS,gBAAgB;AACnF;;;AAKJ,SAAS,qBACR,KACA,QACA,iBACC;AACD,KAAI,IAAI,UAAU,QACjB;CAED,MAAM,QAAQ,gBAAgB,OAAO,IAAI;AAEzC,KAAI,MAAM,UAAU,iBACnB;AAGD,iBAAgB,OAAO,IAAI,SAAS,OAAO,KAAK,OAAO,UAAU,MAAM,eAAe,MAAM,CAAC"}

package/dist/transactions/serializer.d.mts

@@ -0,0 +1,11 @@
+import { HaneulMoveNormalizedType } from "../jsonRpc/types/generated.mjs";
+import { HaneulClientTypes } from "../client/types.mjs";
+import "../jsonRpc/index.mjs";
+import { BcsType } from "@haneullabs/bcs";
+
+//#region src/transactions/serializer.d.ts
+declare function getPureBcsSchema(typeSignature: HaneulClientTypes.OpenSignatureBody): BcsType<any> | null;
+declare function normalizedTypeToMoveTypeSignature(type: HaneulMoveNormalizedType): HaneulClientTypes.OpenSignature;
+//#endregion
+export { getPureBcsSchema, normalizedTypeToMoveTypeSignature };
+//# sourceMappingURL=serializer.d.mts.map

package/dist/transactions/serializer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.mts","names":[],"sources":["../../src/transactions/serializer.ts"],"sourcesContent":[],"mappings":";;;;;;iBAoCgB,gBAAA,gBACA,iBAAA,CAAkB,oBAC/B;iBA4Da,iCAAA,OACT,2BACJ,iBAAA,CAAkB"}

package/dist/transactions/serializer.mjs

@@ -0,0 +1,107 @@
+import { normalizeHaneulAddress } from "../utils/haneul-types.mjs";
+import { bcs as suiBcs } from "../bcs/index.mjs";
+import { HANEUL_FRAMEWORK_ADDRESS, MOVE_STDLIB_ADDRESS } from "../utils/constants.mjs";
+
+//#region src/transactions/serializer.ts
+/**
+* Parses a type name like "0x2::tx_context::TxContext" into package, module, and name parts.
+*/
+function parseTypeName(typeName) {
+	const parts = typeName.split("::");
+	if (parts.length !== 3) throw new Error(`Invalid type name format: ${typeName}`);
+	return {
+		package: parts[0],
+		module: parts[1],
+		name: parts[2]
+	};
+}
+function isTxContext(param) {
+	if (param.body.$kind !== "datatype") return false;
+	const { package: pkg, module, name } = parseTypeName(param.body.datatype.typeName);
+	return normalizeHaneulAddress(pkg) === HANEUL_FRAMEWORK_ADDRESS && module === "tx_context" && name === "TxContext";
+}
+function getPureBcsSchema(typeSignature) {
+	switch (typeSignature.$kind) {
+		case "address": return suiBcs.Address;
+		case "bool": return suiBcs.Bool;
+		case "u8": return suiBcs.U8;
+		case "u16": return suiBcs.U16;
+		case "u32": return suiBcs.U32;
+		case "u64": return suiBcs.U64;
+		case "u128": return suiBcs.U128;
+		case "u256": return suiBcs.U256;
+		case "vector": {
+			if (typeSignature.vector.$kind === "u8") return suiBcs.byteVector().transform({
+				input: (val) => typeof val === "string" ? new TextEncoder().encode(val) : val,
+				output: (val) => val
+			});
+			const type = getPureBcsSchema(typeSignature.vector);
+			return type ? suiBcs.vector(type) : null;
+		}
+		case "datatype": {
+			const { package: pkg, module, name } = parseTypeName(typeSignature.datatype.typeName);
+			const normalizedPkg = normalizeHaneulAddress(pkg);
+			if (normalizedPkg === MOVE_STDLIB_ADDRESS) {
+				if (module === "ascii" && name === "String") return suiBcs.String;
+				if (module === "string" && name === "String") return suiBcs.String;
+				if (module === "option" && name === "Option") {
+					const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);
+					return type ? suiBcs.vector(type) : null;
+				}
+			}
+			if (normalizedPkg === HANEUL_FRAMEWORK_ADDRESS) {
+				if (module === "object" && name === "ID") return suiBcs.Address;
+			}
+			return null;
+		}
+		case "typeParameter":
+		case "unknown": return null;
+	}
+}
+function normalizedTypeToMoveTypeSignature(type) {
+	if (typeof type === "object" && "Reference" in type) return {
+		reference: "immutable",
+		body: normalizedTypeToMoveTypeSignatureBody(type.Reference)
+	};
+	if (typeof type === "object" && "MutableReference" in type) return {
+		reference: "mutable",
+		body: normalizedTypeToMoveTypeSignatureBody(type.MutableReference)
+	};
+	return {
+		reference: null,
+		body: normalizedTypeToMoveTypeSignatureBody(type)
+	};
+}
+function normalizedTypeToMoveTypeSignatureBody(type) {
+	if (typeof type === "string") switch (type) {
+		case "Address": return { $kind: "address" };
+		case "Bool": return { $kind: "bool" };
+		case "U8": return { $kind: "u8" };
+		case "U16": return { $kind: "u16" };
+		case "U32": return { $kind: "u32" };
+		case "U64": return { $kind: "u64" };
+		case "U128": return { $kind: "u128" };
+		case "U256": return { $kind: "u256" };
+		default: throw new Error(`Unexpected type ${type}`);
+	}
+	if ("Vector" in type) return {
+		$kind: "vector",
+		vector: normalizedTypeToMoveTypeSignatureBody(type.Vector)
+	};
+	if ("Struct" in type) return {
+		$kind: "datatype",
+		datatype: {
+			typeName: `${type.Struct.address}::${type.Struct.module}::${type.Struct.name}`,
+			typeParameters: type.Struct.typeArguments.map(normalizedTypeToMoveTypeSignatureBody)
+		}
+	};
+	if ("TypeParameter" in type) return {
+		$kind: "typeParameter",
+		index: type.TypeParameter
+	};
+	throw new Error(`Unexpected type ${JSON.stringify(type)}`);
+}
+
+//#endregion
+export { getPureBcsSchema, isTxContext, normalizedTypeToMoveTypeSignature };
+//# sourceMappingURL=serializer.mjs.map

package/dist/transactions/serializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.mjs","names":["bcs"],"sources":["../../src/transactions/serializer.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BcsType } from '@haneullabs/bcs';\n\nimport { bcs } from '../bcs/index.js';\nimport type { HaneulMoveNormalizedType } from '../jsonRpc/index.js';\nimport { MOVE_STDLIB_ADDRESS, HANEUL_FRAMEWORK_ADDRESS } from '../utils/index.js';\nimport { normalizeHaneulAddress } from '../utils/haneul-types.js';\nimport type { HaneulClientTypes } from '../client/types.js';\n\n/**\n * Parses a type name like \"0x2::tx_context::TxContext\" into package, module, and name parts.\n */\nfunction parseTypeName(typeName: string): { package: string; module: string; name: string } {\n\tconst parts = typeName.split('::');\n\tif (parts.length !== 3) {\n\t\tthrow new Error(`Invalid type name format: ${typeName}`);\n\t}\n\treturn { package: parts[0], module: parts[1], name: parts[2] };\n}\n\nexport function isTxContext(param: HaneulClientTypes.OpenSignature): boolean {\n\tif (param.body.$kind !== 'datatype') {\n\t\treturn false;\n\t}\n\n\tconst { package: pkg, module, name } = parseTypeName(param.body.datatype.typeName);\n\n\treturn (\n\t\tnormalizeHaneulAddress(pkg) === HANEUL_FRAMEWORK_ADDRESS &&\n\t\tmodule === 'tx_context' &&\n\t\tname === 'TxContext'\n\t);\n}\n\nexport function getPureBcsSchema(\n\ttypeSignature: HaneulClientTypes.OpenSignatureBody,\n): BcsType<any> | null {\n\tswitch (typeSignature.$kind) {\n\t\tcase 'address':\n\t\t\treturn bcs.Address;\n\t\tcase 'bool':\n\t\t\treturn bcs.Bool;\n\t\tcase 'u8':\n\t\t\treturn bcs.U8;\n\t\tcase 'u16':\n\t\t\treturn bcs.U16;\n\t\tcase 'u32':\n\t\t\treturn bcs.U32;\n\t\tcase 'u64':\n\t\t\treturn bcs.U64;\n\t\tcase 'u128':\n\t\t\treturn bcs.U128;\n\t\tcase 'u256':\n\t\t\treturn bcs.U256;\n\t\tcase 'vector': {\n\t\t\tif (typeSignature.vector.$kind === 'u8') {\n\t\t\t\treturn bcs.byteVector().transform({\n\t\t\t\t\tinput: (val: string | Uint8Array) =>\n\t\t\t\t\t\ttypeof val === 'string' ? new TextEncoder().encode(val) : val,\n\t\t\t\t\toutput: (val) => val,\n\t\t\t\t});\n\t\t\t}\n\t\t\tconst type = getPureBcsSchema(typeSignature.vector);\n\t\t\treturn type ? bcs.vector(type) : null;\n\t\t}\n\t\tcase 'datatype': {\n\t\t\tconst { package: pkg, module, name } = parseTypeName(typeSignature.datatype.typeName);\n\t\t\tconst normalizedPkg = normalizeHaneulAddress(pkg);\n\n\t\t\tif (normalizedPkg === MOVE_STDLIB_ADDRESS) {\n\t\t\t\tif (module === 'ascii' && name === 'String') {\n\t\t\t\t\treturn bcs.String;\n\t\t\t\t}\n\t\t\t\tif (module === 'string' && name === 'String') {\n\t\t\t\t\treturn bcs.String;\n\t\t\t\t}\n\t\t\t\tif (module === 'option' && name === 'Option') {\n\t\t\t\t\tconst type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);\n\t\t\t\t\treturn type ? bcs.vector(type) : null;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (normalizedPkg === HANEUL_FRAMEWORK_ADDRESS) {\n\t\t\t\tif (module === 'object' && name === 'ID') {\n\t\t\t\t\treturn bcs.Address;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn null;\n\t\t}\n\t\tcase 'typeParameter':\n\t\tcase 'unknown':\n\t\t\treturn null;\n\t}\n}\n\nexport function normalizedTypeToMoveTypeSignature(\n\ttype: HaneulMoveNormalizedType,\n): HaneulClientTypes.OpenSignature {\n\tif (typeof type === 'object' && 'Reference' in type) {\n\t\treturn {\n\t\t\treference: 'immutable',\n\t\t\tbody: normalizedTypeToMoveTypeSignatureBody(type.Reference),\n\t\t};\n\t}\n\tif (typeof type === 'object' && 'MutableReference' in type) {\n\t\treturn {\n\t\t\treference: 'mutable',\n\t\t\tbody: normalizedTypeToMoveTypeSignatureBody(type.MutableReference),\n\t\t};\n\t}\n\n\treturn {\n\t\treference: null,\n\t\tbody: normalizedTypeToMoveTypeSignatureBody(type),\n\t};\n}\n\nfunction normalizedTypeToMoveTypeSignatureBody(\n\ttype: HaneulMoveNormalizedType,\n): HaneulClientTypes.OpenSignatureBody {\n\tif (typeof type === 'string') {\n\t\tswitch (type) {\n\t\t\tcase 'Address':\n\t\t\t\treturn { $kind: 'address' };\n\t\t\tcase 'Bool':\n\t\t\t\treturn { $kind: 'bool' };\n\t\t\tcase 'U8':\n\t\t\t\treturn { $kind: 'u8' };\n\t\t\tcase 'U16':\n\t\t\t\treturn { $kind: 'u16' };\n\t\t\tcase 'U32':\n\t\t\t\treturn { $kind: 'u32' };\n\t\t\tcase 'U64':\n\t\t\t\treturn { $kind: 'u64' };\n\t\t\tcase 'U128':\n\t\t\t\treturn { $kind: 'u128' };\n\t\t\tcase 'U256':\n\t\t\t\treturn { $kind: 'u256' };\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Unexpected type ${type}`);\n\t\t}\n\t}\n\n\tif ('Vector' in type) {\n\t\treturn { $kind: 'vector', vector: normalizedTypeToMoveTypeSignatureBody(type.Vector) };\n\t}\n\n\tif ('Struct' in type) {\n\t\treturn {\n\t\t\t$kind: 'datatype',\n\t\t\tdatatype: {\n\t\t\t\ttypeName: `${type.Struct.address}::${type.Struct.module}::${type.Struct.name}`,\n\t\t\t\ttypeParameters: type.Struct.typeArguments.map(normalizedTypeToMoveTypeSignatureBody),\n\t\t\t},\n\t\t};\n\t}\n\n\tif ('TypeParameter' in type) {\n\t\treturn { $kind: 'typeParameter', index: type.TypeParameter };\n\t}\n\n\tthrow new Error(`Unexpected type ${JSON.stringify(type)}`);\n}\n\nexport function pureBcsSchemaFromOpenSignatureBody(\n\ttypeSignature: HaneulClientTypes.OpenSignatureBody,\n): BcsType<any> {\n\tswitch (typeSignature.$kind) {\n\t\tcase 'address':\n\t\t\treturn bcs.Address;\n\t\tcase 'bool':\n\t\t\treturn bcs.Bool;\n\t\tcase 'u8':\n\t\t\treturn bcs.U8;\n\t\tcase 'u16':\n\t\t\treturn bcs.U16;\n\t\tcase 'u32':\n\t\t\treturn bcs.U32;\n\t\tcase 'u64':\n\t\t\treturn bcs.U64;\n\t\tcase 'u128':\n\t\t\treturn bcs.U128;\n\t\tcase 'u256':\n\t\t\treturn bcs.U256;\n\t\tcase 'vector':\n\t\t\treturn bcs.vector(pureBcsSchemaFromOpenSignatureBody(typeSignature.vector));\n\t\tdefault:\n\t\t\tthrow new Error(`Expected pure typeSignature, but got ${JSON.stringify(typeSignature)}`);\n\t}\n}\n"],"mappings":"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"}

package/dist/transactions/utils.d.mts

@@ -0,0 +1,9 @@
+import { Argument } from "./data/internal.mjs";
+import "../jsonRpc/index.mjs";
+
+//#region src/transactions/utils.d.ts
+
+declare function isArgument(value: unknown): value is Argument;
+//#endregion
+export { isArgument };
+//# sourceMappingURL=utils.d.mts.map

package/dist/transactions/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../src/transactions/utils.ts"],"sourcesContent":[],"mappings":";;;;;iBAsEgB,UAAA,2BAAqC"}

package/dist/transactions/utils.mjs

@@ -0,0 +1,82 @@
+import { normalizeHaneulAddress } from "../utils/haneul-types.mjs";
+import { ArgumentSchema } from "./data/internal.mjs";
+import { is } from "valibot";
+
+//#region src/transactions/utils.ts
+function getIdFromCallArg(arg) {
+	if (typeof arg === "string") return normalizeHaneulAddress(arg);
+	if (arg.Object) {
+		if (arg.Object.ImmOrOwnedObject) return normalizeHaneulAddress(arg.Object.ImmOrOwnedObject.objectId);
+		if (arg.Object.Receiving) return normalizeHaneulAddress(arg.Object.Receiving.objectId);
+		return normalizeHaneulAddress(arg.Object.SharedObject.objectId);
+	}
+	if (arg.UnresolvedObject) return normalizeHaneulAddress(arg.UnresolvedObject.objectId);
+}
+function isArgument(value) {
+	return is(ArgumentSchema, value);
+}
+function remapCommandArguments(command, inputMapping, commandMapping) {
+	const remapArg = (arg) => {
+		switch (arg.$kind) {
+			case "Input": {
+				const newInputIndex = inputMapping.get(arg.Input);
+				if (newInputIndex === void 0) throw new Error(`Input ${arg.Input} not found in input mapping`);
+				return {
+					...arg,
+					Input: newInputIndex
+				};
+			}
+			case "Result": {
+				const newCommandIndex = commandMapping.get(arg.Result);
+				if (newCommandIndex !== void 0) return {
+					...arg,
+					Result: newCommandIndex
+				};
+				return arg;
+			}
+			case "NestedResult": {
+				const newCommandIndex = commandMapping.get(arg.NestedResult[0]);
+				if (newCommandIndex !== void 0) return {
+					...arg,
+					NestedResult: [newCommandIndex, arg.NestedResult[1]]
+				};
+				return arg;
+			}
+			default: return arg;
+		}
+	};
+	switch (command.$kind) {
+		case "MoveCall":
+			command.MoveCall.arguments = command.MoveCall.arguments.map(remapArg);
+			break;
+		case "TransferObjects":
+			command.TransferObjects.objects = command.TransferObjects.objects.map(remapArg);
+			command.TransferObjects.address = remapArg(command.TransferObjects.address);
+			break;
+		case "SplitCoins":
+			command.SplitCoins.coin = remapArg(command.SplitCoins.coin);
+			command.SplitCoins.amounts = command.SplitCoins.amounts.map(remapArg);
+			break;
+		case "MergeCoins":
+			command.MergeCoins.destination = remapArg(command.MergeCoins.destination);
+			command.MergeCoins.sources = command.MergeCoins.sources.map(remapArg);
+			break;
+		case "MakeMoveVec":
+			command.MakeMoveVec.elements = command.MakeMoveVec.elements.map(remapArg);
+			break;
+		case "Upgrade":
+			command.Upgrade.ticket = remapArg(command.Upgrade.ticket);
+			break;
+		case "$Intent": {
+			const inputs = command.$Intent.inputs;
+			command.$Intent.inputs = {};
+			for (const [key, value] of Object.entries(inputs)) command.$Intent.inputs[key] = Array.isArray(value) ? value.map(remapArg) : remapArg(value);
+			break;
+		}
+		case "Publish": break;
+	}
+}
+
+//#endregion
+export { getIdFromCallArg, isArgument, remapCommandArguments };
+//# sourceMappingURL=utils.mjs.map

package/dist/transactions/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../src/transactions/utils.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { is } from 'valibot';\n\nimport type { HaneulMoveNormalizedType } from '../jsonRpc/index.js';\nimport { normalizeHaneulAddress } from '../utils/haneul-types.js';\nimport { ArgumentSchema } from './data/internal.js';\nimport type { Argument, CallArg, Command } from './data/internal.js';\n\nexport function extractMutableReference(\n\tnormalizedType: HaneulMoveNormalizedType,\n): HaneulMoveNormalizedType | undefined {\n\treturn typeof normalizedType === 'object' && 'MutableReference' in normalizedType\n\t\t? normalizedType.MutableReference\n\t\t: undefined;\n}\n\nexport function extractReference(\n\tnormalizedType: HaneulMoveNormalizedType,\n): HaneulMoveNormalizedType | undefined {\n\treturn typeof normalizedType === 'object' && 'Reference' in normalizedType\n\t\t? normalizedType.Reference\n\t\t: undefined;\n}\n\nexport function extractStructTag(\n\tnormalizedType: HaneulMoveNormalizedType,\n): Extract<HaneulMoveNormalizedType, { Struct: unknown }> | undefined {\n\tif (typeof normalizedType === 'object' && 'Struct' in normalizedType) {\n\t\treturn normalizedType;\n\t}\n\n\tconst ref = extractReference(normalizedType);\n\tconst mutRef = extractMutableReference(normalizedType);\n\n\tif (typeof ref === 'object' && 'Struct' in ref) {\n\t\treturn ref;\n\t}\n\n\tif (typeof mutRef === 'object' && 'Struct' in mutRef) {\n\t\treturn mutRef;\n\t}\n\treturn undefined;\n}\n\nexport function getIdFromCallArg(arg: string | CallArg) {\n\tif (typeof arg === 'string') {\n\t\treturn normalizeHaneulAddress(arg);\n\t}\n\n\tif (arg.Object) {\n\t\tif (arg.Object.ImmOrOwnedObject) {\n\t\t\treturn normalizeHaneulAddress(arg.Object.ImmOrOwnedObject.objectId);\n\t\t}\n\n\t\tif (arg.Object.Receiving) {\n\t\t\treturn normalizeHaneulAddress(arg.Object.Receiving.objectId);\n\t\t}\n\n\t\treturn normalizeHaneulAddress(arg.Object.SharedObject.objectId);\n\t}\n\n\tif (arg.UnresolvedObject) {\n\t\treturn normalizeHaneulAddress(arg.UnresolvedObject.objectId);\n\t}\n\n\treturn undefined;\n}\n\nexport function isArgument(value: unknown): value is Argument {\n\treturn is(ArgumentSchema, value);\n}\n\nexport function remapCommandArguments(\n\tcommand: Command,\n\tinputMapping: Map<number, number>,\n\tcommandMapping: Map<number, number>,\n) {\n\tconst remapArg = (arg: Argument): Argument => {\n\t\tswitch (arg.$kind) {\n\t\t\tcase 'Input': {\n\t\t\t\tconst newInputIndex = inputMapping.get(arg.Input);\n\t\t\t\tif (newInputIndex === undefined) {\n\t\t\t\t\tthrow new Error(`Input ${arg.Input} not found in input mapping`);\n\t\t\t\t}\n\t\t\t\treturn { ...arg, Input: newInputIndex };\n\t\t\t}\n\t\t\tcase 'Result': {\n\t\t\t\tconst newCommandIndex = commandMapping.get(arg.Result);\n\t\t\t\tif (newCommandIndex !== undefined) {\n\t\t\t\t\treturn { ...arg, Result: newCommandIndex };\n\t\t\t\t}\n\t\t\t\treturn arg;\n\t\t\t}\n\t\t\tcase 'NestedResult': {\n\t\t\t\tconst newCommandIndex = commandMapping.get(arg.NestedResult[0]);\n\t\t\t\tif (newCommandIndex !== undefined) {\n\t\t\t\t\treturn { ...arg, NestedResult: [newCommandIndex, arg.NestedResult[1]] };\n\t\t\t\t}\n\t\t\t\treturn arg;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t\treturn arg;\n\t\t}\n\t};\n\n\tswitch (command.$kind) {\n\t\tcase 'MoveCall':\n\t\t\tcommand.MoveCall.arguments = command.MoveCall.arguments.map(remapArg);\n\t\t\tbreak;\n\t\tcase 'TransferObjects':\n\t\t\tcommand.TransferObjects.objects = command.TransferObjects.objects.map(remapArg);\n\t\t\tcommand.TransferObjects.address = remapArg(command.TransferObjects.address);\n\t\t\tbreak;\n\t\tcase 'SplitCoins':\n\t\t\tcommand.SplitCoins.coin = remapArg(command.SplitCoins.coin);\n\t\t\tcommand.SplitCoins.amounts = command.SplitCoins.amounts.map(remapArg);\n\t\t\tbreak;\n\t\tcase 'MergeCoins':\n\t\t\tcommand.MergeCoins.destination = remapArg(command.MergeCoins.destination);\n\t\t\tcommand.MergeCoins.sources = command.MergeCoins.sources.map(remapArg);\n\t\t\tbreak;\n\t\tcase 'MakeMoveVec':\n\t\t\tcommand.MakeMoveVec.elements = command.MakeMoveVec.elements.map(remapArg);\n\t\t\tbreak;\n\t\tcase 'Upgrade':\n\t\t\tcommand.Upgrade.ticket = remapArg(command.Upgrade.ticket);\n\t\t\tbreak;\n\t\tcase '$Intent': {\n\t\t\tconst inputs = command.$Intent.inputs;\n\t\t\tcommand.$Intent.inputs = {};\n\n\t\t\tfor (const [key, value] of Object.entries(inputs)) {\n\t\t\t\tcommand.$Intent.inputs[key] = Array.isArray(value) ? value.map(remapArg) : remapArg(value);\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tcase 'Publish':\n\t\t\tbreak;\n\t}\n}\n"],"mappings":";;;;;AA8CA,SAAgB,iBAAiB,KAAuB;AACvD,KAAI,OAAO,QAAQ,SAClB,QAAO,uBAAuB,IAAI;AAGnC,KAAI,IAAI,QAAQ;AACf,MAAI,IAAI,OAAO,iBACd,QAAO,uBAAuB,IAAI,OAAO,iBAAiB,SAAS;AAGpE,MAAI,IAAI,OAAO,UACd,QAAO,uBAAuB,IAAI,OAAO,UAAU,SAAS;AAG7D,SAAO,uBAAuB,IAAI,OAAO,aAAa,SAAS;;AAGhE,KAAI,IAAI,iBACP,QAAO,uBAAuB,IAAI,iBAAiB,SAAS;;AAM9D,SAAgB,WAAW,OAAmC;AAC7D,QAAO,GAAG,gBAAgB,MAAM;;AAGjC,SAAgB,sBACf,SACA,cACA,gBACC;CACD,MAAM,YAAY,QAA4B;AAC7C,UAAQ,IAAI,OAAZ;GACC,KAAK,SAAS;IACb,MAAM,gBAAgB,aAAa,IAAI,IAAI,MAAM;AACjD,QAAI,kBAAkB,OACrB,OAAM,IAAI,MAAM,SAAS,IAAI,MAAM,6BAA6B;AAEjE,WAAO;KAAE,GAAG;KAAK,OAAO;KAAe;;GAExC,KAAK,UAAU;IACd,MAAM,kBAAkB,eAAe,IAAI,IAAI,OAAO;AACtD,QAAI,oBAAoB,OACvB,QAAO;KAAE,GAAG;KAAK,QAAQ;KAAiB;AAE3C,WAAO;;GAER,KAAK,gBAAgB;IACpB,MAAM,kBAAkB,eAAe,IAAI,IAAI,aAAa,GAAG;AAC/D,QAAI,oBAAoB,OACvB,QAAO;KAAE,GAAG;KAAK,cAAc,CAAC,iBAAiB,IAAI,aAAa,GAAG;KAAE;AAExE,WAAO;;GAER,QACC,QAAO;;;AAIV,SAAQ,QAAQ,OAAhB;EACC,KAAK;AACJ,WAAQ,SAAS,YAAY,QAAQ,SAAS,UAAU,IAAI,SAAS;AACrE;EACD,KAAK;AACJ,WAAQ,gBAAgB,UAAU,QAAQ,gBAAgB,QAAQ,IAAI,SAAS;AAC/E,WAAQ,gBAAgB,UAAU,SAAS,QAAQ,gBAAgB,QAAQ;AAC3E;EACD,KAAK;AACJ,WAAQ,WAAW,OAAO,SAAS,QAAQ,WAAW,KAAK;AAC3D,WAAQ,WAAW,UAAU,QAAQ,WAAW,QAAQ,IAAI,SAAS;AACrE;EACD,KAAK;AACJ,WAAQ,WAAW,cAAc,SAAS,QAAQ,WAAW,YAAY;AACzE,WAAQ,WAAW,UAAU,QAAQ,WAAW,QAAQ,IAAI,SAAS;AACrE;EACD,KAAK;AACJ,WAAQ,YAAY,WAAW,QAAQ,YAAY,SAAS,IAAI,SAAS;AACzE;EACD,KAAK;AACJ,WAAQ,QAAQ,SAAS,SAAS,QAAQ,QAAQ,OAAO;AACzD;EACD,KAAK,WAAW;GACf,MAAM,SAAS,QAAQ,QAAQ;AAC/B,WAAQ,QAAQ,SAAS,EAAE;AAE3B,QAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAChD,SAAQ,QAAQ,OAAO,OAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,IAAI,SAAS,GAAG,SAAS,MAAM;AAE3F;;EAED,KAAK,UACJ"}

package/dist/utils/constants.d.mts

@@ -0,0 +1,15 @@
+//#region src/utils/constants.d.ts
+declare const HANEUL_DECIMALS = 9;
+declare const GEUNHWA_PER_HANEUL: bigint;
+declare const MOVE_STDLIB_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000001";
+declare const HANEUL_FRAMEWORK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002";
+declare const HANEUL_SYSTEM_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000003";
+declare const HANEUL_CLOCK_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+declare const HANEUL_SYSTEM_MODULE_NAME = "haneul_system";
+declare const HANEUL_TYPE_ARG = "0x0000000000000000000000000000000000000000000000000000000000000002::haneul::HANEUL";
+declare const HANEUL_SYSTEM_STATE_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000005";
+declare const HANEUL_RANDOM_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000008";
+declare const HANEUL_DENY_LIST_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000403";
+//#endregion
+export { GEUNHWA_PER_HANEUL, HANEUL_CLOCK_OBJECT_ID, HANEUL_DECIMALS, HANEUL_DENY_LIST_OBJECT_ID, HANEUL_FRAMEWORK_ADDRESS, HANEUL_RANDOM_OBJECT_ID, HANEUL_SYSTEM_ADDRESS, HANEUL_SYSTEM_MODULE_NAME, HANEUL_SYSTEM_STATE_OBJECT_ID, HANEUL_TYPE_ARG, MOVE_STDLIB_ADDRESS };
+//# sourceMappingURL=constants.d.mts.map

package/dist/utils/constants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../../src/utils/constants.ts"],"sourcesContent":[],"mappings":";cAGa,eAAA;AAAA,cACA,kBADe,EAAA,MAAA;AACf,cAEA,mBAAA,GAFuC,oEAAA;AAEvC,cAEA,wBAAA,GAFmB,oEAAA;AAEnB,cAEA,qBAAA,GAFwB,oEAAA;AAExB,cAEA,sBAAA,GAFqB,oEAAA;AAErB,cAEA,yBAAA,GAFsB,eAAA;AAEtB,cACA,eAAA,GADyB,oFAAA;AACzB,cACA,6BAAA,GADe,oEAAA;AACf,cAEA,uBAAA,GAF6B,oEAAA;AAE7B,cAEA,0BAAA,GAFuB,oEAAA"}

package/dist/utils/constants.mjs

@@ -0,0 +1,16 @@
+//#region src/utils/constants.ts
+const HANEUL_DECIMALS = 9;
+const GEUNHWA_PER_HANEUL = BigInt(1e9);
+const MOVE_STDLIB_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000001";
+const HANEUL_FRAMEWORK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002";
+const HANEUL_SYSTEM_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000003";
+const HANEUL_CLOCK_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+const HANEUL_SYSTEM_MODULE_NAME = "haneul_system";
+const HANEUL_TYPE_ARG = `${HANEUL_FRAMEWORK_ADDRESS}::haneul::HANEUL`;
+const HANEUL_SYSTEM_STATE_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000005";
+const HANEUL_RANDOM_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000008";
+const HANEUL_DENY_LIST_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000403";
+
+//#endregion
+export { GEUNHWA_PER_HANEUL, HANEUL_CLOCK_OBJECT_ID, HANEUL_DECIMALS, HANEUL_DENY_LIST_OBJECT_ID, HANEUL_FRAMEWORK_ADDRESS, HANEUL_RANDOM_OBJECT_ID, HANEUL_SYSTEM_ADDRESS, HANEUL_SYSTEM_MODULE_NAME, HANEUL_SYSTEM_STATE_OBJECT_ID, HANEUL_TYPE_ARG, MOVE_STDLIB_ADDRESS };
+//# sourceMappingURL=constants.mjs.map

package/dist/utils/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../src/utils/constants.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport const HANEUL_DECIMALS = 9;\nexport const GEUNHWA_PER_HANEUL = BigInt(1000000000);\n\nexport const MOVE_STDLIB_ADDRESS =\n\t'0x0000000000000000000000000000000000000000000000000000000000000001';\nexport const HANEUL_FRAMEWORK_ADDRESS =\n\t'0x0000000000000000000000000000000000000000000000000000000000000002';\nexport const HANEUL_SYSTEM_ADDRESS =\n\t'0x0000000000000000000000000000000000000000000000000000000000000003';\nexport const HANEUL_CLOCK_OBJECT_ID =\n\t'0x0000000000000000000000000000000000000000000000000000000000000006';\nexport const HANEUL_SYSTEM_MODULE_NAME = 'haneul_system';\nexport const HANEUL_TYPE_ARG = `${HANEUL_FRAMEWORK_ADDRESS}::haneul::HANEUL`;\nexport const HANEUL_SYSTEM_STATE_OBJECT_ID =\n\t'0x0000000000000000000000000000000000000000000000000000000000000005';\nexport const HANEUL_RANDOM_OBJECT_ID =\n\t'0x0000000000000000000000000000000000000000000000000000000000000008';\nexport const HANEUL_DENY_LIST_OBJECT_ID =\n\t'0x0000000000000000000000000000000000000000000000000000000000000403';\n"],"mappings":";AAGA,MAAa,kBAAkB;AAC/B,MAAa,qBAAqB,OAAO,IAAW;AAEpD,MAAa,sBACZ;AACD,MAAa,2BACZ;AACD,MAAa,wBACZ;AACD,MAAa,yBACZ;AACD,MAAa,4BAA4B;AACzC,MAAa,kBAAkB,GAAG,yBAAyB;AAC3D,MAAa,gCACZ;AACD,MAAa,0BACZ;AACD,MAAa,6BACZ"}

package/dist/utils/derived-objects.d.mts

@@ -0,0 +1,11 @@
+import { TypeTag } from "../bcs/bcs.mjs";
+
+//#region src/utils/derived-objects.d.ts
+
+/**
+ * Derive the ID of an object that has been created through `derived_object`.
+ */
+declare function deriveObjectID(parentId: string, typeTag: typeof TypeTag.$inferInput, key: Uint8Array): string;
+//#endregion
+export { deriveObjectID };
+//# sourceMappingURL=derived-objects.d.mts.map

package/dist/utils/derived-objects.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived-objects.d.mts","names":[],"sources":["../../src/utils/derived-objects.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;iBAAgB,cAAA,mCAEC,OAAA,CAAQ,kBACnB"}

package/dist/utils/derived-objects.mjs

@@ -0,0 +1,14 @@
+import { TypeTagSerializer } from "../bcs/type-tag-serializer.mjs";
+import { deriveDynamicFieldID } from "./dynamic-fields.mjs";
+
+//#region src/utils/derived-objects.ts
+/**
+* Derive the ID of an object that has been created through `derived_object`.
+*/
+function deriveObjectID(parentId, typeTag, key) {
+	return deriveDynamicFieldID(parentId, `0x2::derived_object::DerivedObjectKey<${typeof typeTag === "string" ? typeTag : TypeTagSerializer.tagToString(typeTag)}>`, key);
+}
+
+//#endregion
+export { deriveObjectID };
+//# sourceMappingURL=derived-objects.mjs.map

package/dist/utils/derived-objects.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived-objects.mjs","names":[],"sources":["../../src/utils/derived-objects.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { TypeTag } from '../bcs/bcs.js';\nimport { TypeTagSerializer } from '../bcs/type-tag-serializer.js';\nimport { deriveDynamicFieldID } from './dynamic-fields.js';\n\n/**\n * Derive the ID of an object that has been created through `derived_object`.\n */\nexport function deriveObjectID(\n\tparentId: string,\n\ttypeTag: typeof TypeTag.$inferInput,\n\tkey: Uint8Array,\n) {\n\tconst typeTagStr = typeof typeTag === 'string' ? typeTag : TypeTagSerializer.tagToString(typeTag);\n\treturn deriveDynamicFieldID(\n\t\tparentId,\n\t\t`0x2::derived_object::DerivedObjectKey<${typeTagStr}>`,\n\t\tkey,\n\t);\n}\n"],"mappings":";;;;;;;AAUA,SAAgB,eACf,UACA,SACA,KACC;AAED,QAAO,qBACN,UACA,yCAHkB,OAAO,YAAY,WAAW,UAAU,kBAAkB,YAAY,QAAQ,CAG5C,IACpD,IACA"}

package/dist/utils/dynamic-fields.d.mts

@@ -0,0 +1,7 @@
+import { TypeTag } from "../bcs/bcs.mjs";
+
+//#region src/utils/dynamic-fields.d.ts
+declare function deriveDynamicFieldID(parentId: string, typeTag: typeof TypeTag.$inferInput, key: Uint8Array): string;
+//#endregion
+export { deriveDynamicFieldID };
+//# sourceMappingURL=dynamic-fields.d.mts.map

package/dist/utils/dynamic-fields.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-fields.d.mts","names":[],"sources":["../../src/utils/dynamic-fields.ts"],"sourcesContent":[],"mappings":";;;iBASgB,oBAAA,mCAEC,OAAA,CAAQ,kBACnB"}

package/dist/utils/dynamic-fields.mjs

@@ -0,0 +1,21 @@
+import { bcs as suiBcs } from "../bcs/index.mjs";
+import { toHex } from "@haneullabs/bcs";
+import { blake2b } from "@noble/hashes/blake2.js";
+
+//#region src/utils/dynamic-fields.ts
+function deriveDynamicFieldID(parentId, typeTag, key) {
+	const address = suiBcs.Address.serialize(parentId).toBytes();
+	const tag = suiBcs.TypeTag.serialize(typeTag).toBytes();
+	const keyLength = suiBcs.u64().serialize(key.length).toBytes();
+	const hash = blake2b.create({ dkLen: 32 });
+	hash.update(new Uint8Array([240]));
+	hash.update(address);
+	hash.update(keyLength);
+	hash.update(key);
+	hash.update(tag);
+	return `0x${toHex(hash.digest().slice(0, 32))}`;
+}
+
+//#endregion
+export { deriveDynamicFieldID };
+//# sourceMappingURL=dynamic-fields.mjs.map

package/dist/utils/dynamic-fields.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-fields.mjs","names":["bcs"],"sources":["../../src/utils/dynamic-fields.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { toHex } from '@haneullabs/bcs';\nimport { blake2b } from '@noble/hashes/blake2.js';\n\nimport type { TypeTag } from '../bcs/bcs.js';\nimport { bcs } from '../bcs/index.js';\n\nexport function deriveDynamicFieldID(\n\tparentId: string,\n\ttypeTag: typeof TypeTag.$inferInput,\n\tkey: Uint8Array,\n) {\n\tconst address = bcs.Address.serialize(parentId).toBytes();\n\tconst tag = bcs.TypeTag.serialize(typeTag).toBytes();\n\tconst keyLength = bcs.u64().serialize(key.length).toBytes();\n\n\tconst hash = blake2b.create({\n\t\tdkLen: 32,\n\t});\n\n\thash.update(new Uint8Array([0xf0]));\n\thash.update(address);\n\thash.update(keyLength);\n\thash.update(key);\n\thash.update(tag);\n\n\treturn `0x${toHex(hash.digest().slice(0, 32))}`;\n}\n"],"mappings":";;;;;AASA,SAAgB,qBACf,UACA,SACA,KACC;CACD,MAAM,UAAUA,OAAI,QAAQ,UAAU,SAAS,CAAC,SAAS;CACzD,MAAM,MAAMA,OAAI,QAAQ,UAAU,QAAQ,CAAC,SAAS;CACpD,MAAM,YAAYA,OAAI,KAAK,CAAC,UAAU,IAAI,OAAO,CAAC,SAAS;CAE3D,MAAM,OAAO,QAAQ,OAAO,EAC3B,OAAO,IACP,CAAC;AAEF,MAAK,OAAO,IAAI,WAAW,CAAC,IAAK,CAAC,CAAC;AACnC,MAAK,OAAO,QAAQ;AACpB,MAAK,OAAO,UAAU;AACtB,MAAK,OAAO,IAAI;AAChB,MAAK,OAAO,IAAI;AAEhB,QAAO,KAAK,MAAM,KAAK,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC"}

package/dist/utils/format.d.mts

@@ -0,0 +1,6 @@
+//#region src/utils/format.d.ts
+declare function formatAddress(address: string): string;
+declare function formatDigest(digest: string): string;
+//#endregion
+export { formatAddress, formatDigest };
+//# sourceMappingURL=format.d.mts.map

package/dist/utils/format.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.mts","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":[],"mappings":";iBAKgB,aAAA;AAAA,iBAUA,YAAA,CAVa,MAAA,EAAA,MAAA,CAAA,EAAA,MAAA"}

package/dist/utils/format.mjs

@@ -0,0 +1,14 @@
+//#region src/utils/format.ts
+const ELLIPSIS = "…";
+function formatAddress(address) {
+	if (address.length <= 6) return address;
+	const offset = address.startsWith("0x") ? 2 : 0;
+	return `0x${address.slice(offset, offset + 4)}${ELLIPSIS}${address.slice(-4)}`;
+}
+function formatDigest(digest) {
+	return `${digest.slice(0, 10)}${ELLIPSIS}`;
+}
+
+//#endregion
+export { formatAddress, formatDigest };
+//# sourceMappingURL=format.mjs.map

package/dist/utils/format.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.mjs","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nconst ELLIPSIS = '\\u{2026}';\n\nexport function formatAddress(address: string) {\n\tif (address.length <= 6) {\n\t\treturn address;\n\t}\n\n\tconst offset = address.startsWith('0x') ? 2 : 0;\n\n\treturn `0x${address.slice(offset, offset + 4)}${ELLIPSIS}${address.slice(-4)}`;\n}\n\nexport function formatDigest(digest: string) {\n\t// Use 10 first characters\n\treturn `${digest.slice(0, 10)}${ELLIPSIS}`;\n}\n"],"mappings":";AAGA,MAAM,WAAW;AAEjB,SAAgB,cAAc,SAAiB;AAC9C,KAAI,QAAQ,UAAU,EACrB,QAAO;CAGR,MAAM,SAAS,QAAQ,WAAW,KAAK,GAAG,IAAI;AAE9C,QAAO,KAAK,QAAQ,MAAM,QAAQ,SAAS,EAAE,GAAG,WAAW,QAAQ,MAAM,GAAG;;AAG7E,SAAgB,aAAa,QAAgB;AAE5C,QAAO,GAAG,OAAO,MAAM,GAAG,GAAG,GAAG"}

package/dist/utils/haneul-types.d.mts

@@ -0,0 +1,31 @@
+//#region src/utils/haneul-types.d.ts
+/** Returns whether the tx digest is valid based on the serialization format */
+declare function isValidTransactionDigest(value: string): value is string;
+declare const HANEUL_ADDRESS_LENGTH = 32;
+declare function isValidHaneulAddress(value: string): value is string;
+declare function isValidHaneulObjectId(value: string): boolean;
+declare function isValidStructTag(type: string): boolean;
+type StructTag = {
+  address: string;
+  module: string;
+  name: string;
+  typeParams: (string | StructTag)[];
+};
+declare function parseStructTag(type: string): StructTag;
+declare function normalizeStructTag(type: string | StructTag): string;
+/**
+ * Perform the following operations:
+ * 1. Make the address lower case
+ * 2. Prepend `0x` if the string does not start with `0x`.
+ * 3. Add more zeros if the length of the address(excluding `0x`) is less than `HANEUL_ADDRESS_LENGTH`
+ *
+ * WARNING: if the address value itself starts with `0x`, e.g., `0x0x`, the default behavior
+ * is to treat the first `0x` not as part of the address. The default behavior can be overridden by
+ * setting `forceAdd0x` to true
+ *
+ */
+declare function normalizeHaneulAddress(value: string, forceAdd0x?: boolean): string;
+declare function normalizeHaneulObjectId(value: string, forceAdd0x?: boolean): string;
+//#endregion
+export { HANEUL_ADDRESS_LENGTH, isValidHaneulAddress, isValidHaneulObjectId, isValidStructTag, isValidTransactionDigest, normalizeHaneulAddress, normalizeHaneulObjectId, normalizeStructTag, parseStructTag };
+//# sourceMappingURL=haneul-types.d.mts.map

package/dist/utils/haneul-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"haneul-types.d.mts","names":[],"sources":["../../src/utils/haneul-types.ts"],"sourcesContent":[],"mappings":";;AAUgB,iBAAA,wBAAA,CAAwB,KAAA,EAAA,MAAA,CAAA,EAAA,KAAA,IAAA,MAAA;AAe3B,cAAA,qBAAA,GAAqB,EAAA;AAClB,iBAAA,oBAAA,CAAoB,KAAA,EAAA,MAAA,CAAA,EAAA,KAAA,IAAA,MAAA;AAIpB,iBAAA,qBAAA,CAAqB,KAAA,EAAA,MAAA,CAAA,EAAA,OAAA;AA6DzB,iBATI,gBAAA,CAagB,IAAA,EAAA,MAAA,CAAA,EAAA,OAAA;AAShB,KAbJ,SAAA,GAakB;EA0Bd,OAAA,EAAA,MAAA;EA2BA,MAAA,EAAA,MAAA;EAQA,IAAA,EAAA,MAAA;wBAtEO;;iBASP,cAAA,gBAA8B;iBA0B9B,kBAAA,gBAAkC;;;;;;;;;;;;iBA2BlC,sBAAA;iBAQA,uBAAA"}