@haneullabs/haneul 0.1.0 → 2.5.0

package/dist/bcs/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/bcs/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;cA2DM;MAkDL,gBAAA,CAAA;;;EAlDK,GAAA,0BAkDL,CAAA,MAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,EAAA,KAAA,CAAA;EAAA,IAAA,0BAAA,CAAA,MAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,EAAA,MAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ61J,CAAA,EAAA,MAAA,CAAA;EAAA,eAAA,4BAAA,CAAA;IAAA,QAAA,0BAAA,CAAA,MAAA,EAAA,MAAA,aAAA,gBAAA,CAAA,EAAA,WAAA,CAAA;IAAA,OAAA,0BAAA,CAAA,MAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,EAAA,KAAA,CAAA;IAAA,MAAA,0BAAA,CAAA,MAAA,EAAA,MAAA,EAAA,cAAA,CAAA;EAAA,CAAA,EAAA,MAAA,CAAA;EAAA,eAAA,0BAAA,CAAA;IAAA,EAAA,4BAAA,CAAA;MAAA,IAAA,0BAAA,CAAA;QAAA,uBAAA,4BAAA,CAAA;UAAA,MAAA,0BAAA,yCAAA,CAAA;YAAA,IAAA,EAAA;cAAA,KAAA,EAAA,MAAA;YAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+QAAA,gBAAA,CAAA,yCAAA,IAAA,EAAA,aAAA,gBAAA,CAAA,yDAAA,IAAA,EAAA,aAAA,gBAAA,CAAA,yCAAA,QAAA,gBAAA,CAAA,SAAA,GAAA;kCAAA,gBAAA,CAAA"}

package/dist/bcs/index.mjs

@@ -0,0 +1,62 @@
+import { TypeTagSerializer } from "./type-tag-serializer.mjs";
+import { Address, AppId, Argument, CallArg, Command, CompressedSignature, Data, GasData, HaneulObjectRef, Intent, IntentMessage, IntentScope, IntentVersion, MoveObject, MoveObjectType, MovePackage, MultiSig, MultiSigPkMap, MultiSigPublicKey, ObjectArg, ObjectDigest, ObjectInner, Owner, PasskeyAuthenticator, ProgrammableMoveCall, ProgrammableTransaction, PublicKey, SenderSignedData, SenderSignedTransaction, SharedObjectRef, StructTag, TransactionData, TransactionDataV1, TransactionExpiration, TransactionKind, TypeOrigin, TypeTag, UpgradeInfo } from "./bcs.mjs";
+import { TransactionEffects } from "./effects.mjs";
+import { pureBcsSchemaFromTypeName } from "./pure.mjs";
+import { BcsEnum, BcsStruct, BcsTuple, BcsType, bcs, compareBcsBytes } from "@haneullabs/bcs";
+
+//#region src/bcs/index.ts
+const suiBcs = {
+	...bcs,
+	U8: bcs.u8(),
+	U16: bcs.u16(),
+	U32: bcs.u32(),
+	U64: bcs.u64(),
+	U128: bcs.u128(),
+	U256: bcs.u256(),
+	ULEB128: bcs.uleb128(),
+	Bool: bcs.bool(),
+	String: bcs.string(),
+	Address,
+	AppId,
+	Argument,
+	CallArg,
+	Command,
+	CompressedSignature,
+	Data,
+	GasData,
+	Intent,
+	IntentMessage,
+	IntentScope,
+	IntentVersion,
+	MoveObject,
+	MoveObjectType,
+	MovePackage,
+	MultiSig,
+	MultiSigPkMap,
+	MultiSigPublicKey,
+	Object: ObjectInner,
+	ObjectArg,
+	ObjectDigest,
+	Owner,
+	PasskeyAuthenticator,
+	ProgrammableMoveCall,
+	ProgrammableTransaction,
+	PublicKey,
+	SenderSignedData,
+	SenderSignedTransaction,
+	SharedObjectRef,
+	StructTag,
+	HaneulObjectRef,
+	TransactionData,
+	TransactionDataV1,
+	TransactionEffects,
+	TransactionExpiration,
+	TransactionKind,
+	TypeOrigin,
+	TypeTag,
+	UpgradeInfo
+};
+
+//#endregion
+export { BcsEnum, BcsStruct, BcsTuple, BcsType, TypeTagSerializer, suiBcs as bcs, compareBcsBytes, pureBcsSchemaFromTypeName };
+//# sourceMappingURL=index.mjs.map

package/dist/bcs/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/bcs/index.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs } from '@haneullabs/bcs';\n\nimport {\n\tAddress,\n\tAppId,\n\tArgument,\n\tCallArg,\n\tCommand,\n\tCompressedSignature,\n\tData,\n\tGasData,\n\tIntent,\n\tIntentMessage,\n\tIntentScope,\n\tIntentVersion,\n\tMoveObject,\n\tMoveObjectType,\n\tMovePackage,\n\tMultiSig,\n\tMultiSigPkMap,\n\tMultiSigPublicKey,\n\tObjectArg,\n\tObjectDigest,\n\tObjectInner,\n\tOwner,\n\tPasskeyAuthenticator,\n\tProgrammableMoveCall,\n\tProgrammableTransaction,\n\tPublicKey,\n\tSenderSignedData,\n\tSenderSignedTransaction,\n\tSharedObjectRef,\n\tStructTag,\n\tHaneulObjectRef,\n\tTransactionData,\n\tTransactionDataV1,\n\tTransactionExpiration,\n\tTransactionKind,\n\tTypeOrigin,\n\tTypeTag,\n\tUpgradeInfo,\n} from './bcs.js';\nimport { TransactionEffects } from './effects.js';\n\nexport type { TypeTag } from './types.js';\n\nexport { TypeTagSerializer } from './type-tag-serializer.js';\nexport {\n\tBcsType,\n\tBcsStruct,\n\tBcsEnum,\n\tBcsTuple,\n\ttype BcsTypeOptions,\n\tcompareBcsBytes,\n} from '@haneullabs/bcs';\n\nconst suiBcs = {\n\t...bcs,\n\tU8: bcs.u8(),\n\tU16: bcs.u16(),\n\tU32: bcs.u32(),\n\tU64: bcs.u64(),\n\tU128: bcs.u128(),\n\tU256: bcs.u256(),\n\tULEB128: bcs.uleb128(),\n\tBool: bcs.bool(),\n\tString: bcs.string(),\n\tAddress,\n\tAppId,\n\tArgument,\n\tCallArg,\n\tCommand,\n\tCompressedSignature,\n\tData,\n\tGasData,\n\tIntent,\n\tIntentMessage,\n\tIntentScope,\n\tIntentVersion,\n\tMoveObject,\n\tMoveObjectType,\n\tMovePackage,\n\tMultiSig,\n\tMultiSigPkMap,\n\tMultiSigPublicKey,\n\tObject: ObjectInner,\n\tObjectArg,\n\tObjectDigest,\n\tOwner,\n\tPasskeyAuthenticator,\n\tProgrammableMoveCall,\n\tProgrammableTransaction,\n\tPublicKey,\n\tSenderSignedData,\n\tSenderSignedTransaction,\n\tSharedObjectRef,\n\tStructTag,\n\tHaneulObjectRef,\n\tTransactionData,\n\tTransactionDataV1,\n\tTransactionEffects,\n\tTransactionExpiration,\n\tTransactionKind,\n\tTypeOrigin,\n\tTypeTag,\n\tUpgradeInfo,\n};\nexport {\n\tpureBcsSchemaFromTypeName,\n\ttype ShapeFromPureTypeName,\n\ttype PureTypeName,\n} from './pure.js';\n\nexport { suiBcs as bcs };\n"],"mappings":";;;;;;;AA2DA,MAAM,SAAS;CACd,GAAG;CACH,IAAI,IAAI,IAAI;CACZ,KAAK,IAAI,KAAK;CACd,KAAK,IAAI,KAAK;CACd,KAAK,IAAI,KAAK;CACd,MAAM,IAAI,MAAM;CAChB,MAAM,IAAI,MAAM;CAChB,SAAS,IAAI,SAAS;CACtB,MAAM,IAAI,MAAM;CAChB,QAAQ,IAAI,QAAQ;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,QAAQ;CACR;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA"}

package/dist/bcs/pure.d.mts

@@ -0,0 +1,26 @@
+import { BcsType } from "@haneullabs/bcs";
+
+//#region src/bcs/pure.d.ts
+type BasePureType = 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'bool' | 'id' | 'string' | 'address';
+interface PureShapeByType {
+  u8: number;
+  u16: number;
+  u32: number;
+  u64: bigint | string | number;
+  u128: bigint | string | number;
+  u256: bigint | string | number;
+  bool: boolean;
+  string: string;
+  id: string | Uint8Array;
+  address: string | Uint8Array;
+}
+type PureTypeName = BasePureType | `vector<${string}>` | `option<${string}>`;
+type ValidPureTypeName<T extends string> = T extends BasePureType ? PureTypeName : T extends `vector<${infer U}>` ? ValidPureTypeName<U> : T extends `option<${infer U}>` ? ValidPureTypeName<U> : PureTypeValidationError<T>;
+type ShapeFromPureTypeName<T extends PureTypeName> = T extends BasePureType ? PureShapeByType[T] : T extends `vector<${infer U extends PureTypeName}>` ? ShapeFromPureTypeName<U>[] : T extends `option<${infer U extends PureTypeName}>` ? ShapeFromPureTypeName<U> | null : never;
+type PureTypeValidationError<T extends string> = {
+  error: `Invalid Pure type name: ${T}`;
+} & {};
+declare function pureBcsSchemaFromTypeName<T extends PureTypeName>(name: T extends PureTypeName ? ValidPureTypeName<T> : T): BcsType<ShapeFromPureTypeName<T>>;
+//#endregion
+export { PureTypeName, ShapeFromPureTypeName, ValidPureTypeName, pureBcsSchemaFromTypeName };
+//# sourceMappingURL=pure.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pure.d.mts","names":[],"sources":["../../src/bcs/pure.ts"],"sourcesContent":[],"mappings":";;;KAQY,YAAA;UAYF,eAAA;EAZE,EAAA,EAAA,MAAA;EAYF,GAAA,EAAA,MAAA;EAaE,GAAA,EAAA,MAAA;EACA,GAAA,EAAA,MAAA,GAAA,MAAiB,GAAA,MAAA;EAAqB,IAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA;EAAU,IAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA;EACzD,IAAA,EAAA,OAAA;EACA,MAAA,EAAA,MAAA;EACmB,EAAA,EAAA,MAAA,GARR,UAQQ;EAAlB,OAAA,EAAA,MAAA,GAPe,UAOf;;AAEmB,KANX,YAAA,GAAe,YAMJ,GAAA,UAAA,MAAA,GAAA,GAAA,UAAA,MAAA,GAAA;AAAlB,KALO,iBAKP,CAAA,UAAA,MAAA,CAAA,GAL6C,CAK7C,SALuD,YAKvD,GAJF,YAIE,GAHF,CAGE,SAAA,UAAA,KAAA,EAAA,GAAA,GAFD,iBAEC,CAFiB,CAEjB,CAAA,GADD,CACC,SAAA,UAAA,KAAA,EAAA,GAAA,GAAA,iBAAA,CAAkB,CAAlB,CAAA,GACA,uBADA,CACwB,CADxB,CAAA;AACwB,KAEjB,qBAFiB,CAAA,UAEe,YAFf,CAAA,GAE+B,CAF/B,SAEyC,YAFzC,GAG1B,eAH0B,CAGV,CAHU,CAAA,GAI1B,CAJ0B,SAAA,UAAA,KAAA,WAIU,YAJV,GAAA,GAKzB,qBALyB,CAKH,CALG,CAAA,EAAA,GAMzB,CANyB,SAAA,UAAA,KAAA,WAMW,YANX,GAAA,GAOxB,qBAPwB,CAOF,CAPE,CAAA,GAAA,IAAA,GAAA,KAAA;KAUxB,uBAVA,CAAA,UAAA,MAAA,CAAA,GAAA;EAAuB,KAAA,EAAA,2BAWO,CAXP,EAAA;AAE5B,CAAA,GAAY,CAAA,CAAA;AAAgC,iBAY5B,yBAZ4B,CAAA,UAYQ,YAZR,CAAA,CAAA,IAAA,EAarC,CAbqC,SAa3B,YAb2B,GAaZ,iBAbY,CAaM,CAbN,CAAA,GAaW,CAbX,CAAA,EAczC,OAdyC,CAcjC,qBAdiC,CAcX,CAdW,CAAA,CAAA"}

package/dist/bcs/pure.mjs

@@ -0,0 +1,29 @@
+import { Address } from "./bcs.mjs";
+import { bcs } from "@haneullabs/bcs";
+
+//#region src/bcs/pure.ts
+function pureBcsSchemaFromTypeName(name) {
+	switch (name) {
+		case "u8": return bcs.u8();
+		case "u16": return bcs.u16();
+		case "u32": return bcs.u32();
+		case "u64": return bcs.u64();
+		case "u128": return bcs.u128();
+		case "u256": return bcs.u256();
+		case "bool": return bcs.bool();
+		case "string": return bcs.string();
+		case "id":
+		case "address": return Address;
+	}
+	const generic = name.match(/^(vector|option)<(.+)>$/);
+	if (generic) {
+		const [kind, inner] = generic.slice(1);
+		if (kind === "vector") return bcs.vector(pureBcsSchemaFromTypeName(inner));
+		else return bcs.option(pureBcsSchemaFromTypeName(inner));
+	}
+	throw new Error(`Invalid Pure type name: ${name}`);
+}
+
+//#endregion
+export { pureBcsSchemaFromTypeName };
+//# sourceMappingURL=pure.mjs.map

package/dist/bcs/pure.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure.mjs","names":[],"sources":["../../src/bcs/pure.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs } from '@haneullabs/bcs';\nimport type { BcsType } from '@haneullabs/bcs';\n\nimport { Address } from './bcs.js';\n\nexport type BasePureType =\n\t| 'u8'\n\t| 'u16'\n\t| 'u32'\n\t| 'u64'\n\t| 'u128'\n\t| 'u256'\n\t| 'bool'\n\t| 'id'\n\t| 'string'\n\t| 'address';\n\ninterface PureShapeByType {\n\tu8: number;\n\tu16: number;\n\tu32: number;\n\tu64: bigint | string | number;\n\tu128: bigint | string | number;\n\tu256: bigint | string | number;\n\tbool: boolean;\n\tstring: string;\n\tid: string | Uint8Array;\n\taddress: string | Uint8Array;\n}\n\nexport type PureTypeName = BasePureType | `vector<${string}>` | `option<${string}>`;\nexport type ValidPureTypeName<T extends string> = T extends BasePureType\n\t? PureTypeName\n\t: T extends `vector<${infer U}>`\n\t\t? ValidPureTypeName<U>\n\t\t: T extends `option<${infer U}>`\n\t\t\t? ValidPureTypeName<U>\n\t\t\t: PureTypeValidationError<T>;\n\nexport type ShapeFromPureTypeName<T extends PureTypeName> = T extends BasePureType\n\t? PureShapeByType[T]\n\t: T extends `vector<${infer U extends PureTypeName}>`\n\t\t? ShapeFromPureTypeName<U>[]\n\t\t: T extends `option<${infer U extends PureTypeName}>`\n\t\t\t? ShapeFromPureTypeName<U> | null\n\t\t\t: never;\n\ntype PureTypeValidationError<T extends string> = {\n\terror: `Invalid Pure type name: ${T}`;\n} & {};\n\nexport function pureBcsSchemaFromTypeName<T extends PureTypeName>(\n\tname: T extends PureTypeName ? ValidPureTypeName<T> : T,\n): BcsType<ShapeFromPureTypeName<T>> {\n\tswitch (name) {\n\t\tcase 'u8':\n\t\t\treturn bcs.u8() as never;\n\t\tcase 'u16':\n\t\t\treturn bcs.u16() as never;\n\t\tcase 'u32':\n\t\t\treturn bcs.u32() as never;\n\t\tcase 'u64':\n\t\t\treturn bcs.u64() as never;\n\t\tcase 'u128':\n\t\t\treturn bcs.u128() as never;\n\t\tcase 'u256':\n\t\t\treturn bcs.u256() as never;\n\t\tcase 'bool':\n\t\t\treturn bcs.bool() as never;\n\t\tcase 'string':\n\t\t\treturn bcs.string() as never;\n\t\tcase 'id':\n\t\tcase 'address':\n\t\t\treturn Address as never;\n\t}\n\n\tconst generic = (name as string).match(/^(vector|option)<(.+)>$/);\n\tif (generic) {\n\t\tconst [kind, inner] = generic.slice(1);\n\t\tif (kind === 'vector') {\n\t\t\treturn bcs.vector(pureBcsSchemaFromTypeName(inner as PureTypeName)) as never;\n\t\t} else {\n\t\t\treturn bcs.option(pureBcsSchemaFromTypeName(inner as PureTypeName)) as never;\n\t\t}\n\t}\n\n\tthrow new Error(`Invalid Pure type name: ${name}`);\n}\n"],"mappings":";;;;AAsDA,SAAgB,0BACf,MACoC;AACpC,SAAQ,MAAR;EACC,KAAK,KACJ,QAAO,IAAI,IAAI;EAChB,KAAK,MACJ,QAAO,IAAI,KAAK;EACjB,KAAK,MACJ,QAAO,IAAI,KAAK;EACjB,KAAK,MACJ,QAAO,IAAI,KAAK;EACjB,KAAK,OACJ,QAAO,IAAI,MAAM;EAClB,KAAK,OACJ,QAAO,IAAI,MAAM;EAClB,KAAK,OACJ,QAAO,IAAI,MAAM;EAClB,KAAK,SACJ,QAAO,IAAI,QAAQ;EACpB,KAAK;EACL,KAAK,UACJ,QAAO;;CAGT,MAAM,UAAW,KAAgB,MAAM,0BAA0B;AACjE,KAAI,SAAS;EACZ,MAAM,CAAC,MAAM,SAAS,QAAQ,MAAM,EAAE;AACtC,MAAI,SAAS,SACZ,QAAO,IAAI,OAAO,0BAA0B,MAAsB,CAAC;MAEnE,QAAO,IAAI,OAAO,0BAA0B,MAAsB,CAAC;;AAIrE,OAAM,IAAI,MAAM,2BAA2B,OAAO"}

package/dist/bcs/type-tag-serializer.d.mts

@@ -0,0 +1,12 @@
+import { TypeTag } from "./types.mjs";
+
+//#region src/bcs/type-tag-serializer.d.ts
+declare class TypeTagSerializer {
+  static parseFromStr(str: string, normalizeAddress?: boolean): TypeTag;
+  static parseStructTypeArgs(str: string, normalizeAddress?: boolean): TypeTag[];
+  static tagToString(tag: TypeTag): string;
+}
+declare function normalizeTypeTag(type: string): string;
+//#endregion
+export { TypeTagSerializer, normalizeTypeTag };
+//# sourceMappingURL=type-tag-serializer.d.mts.map

package/dist/bcs/type-tag-serializer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-tag-serializer.d.mts","names":[],"sources":["../../src/bcs/type-tag-serializer.ts"],"sourcesContent":[],"mappings":";;;cAWa,iBAAA;gEACgD;EADhD,OAAA,mBAAiB,CAAA,GAAA,EAAA,MAAA,EAAA,gBAAA,CAAA,EAAA,OAAA,CAAA,EAgDsC,OAhDtC,EAAA;EAC+B,OAAA,WAAA,CAAA,GAAA,EAqDpC,OArDoC,CAAA,EAAA,MAAA;;AAqDpC,iBA0CT,gBAAA,CA1CS,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA"}

package/dist/bcs/type-tag-serializer.mjs

@@ -0,0 +1,57 @@
+import { normalizeHaneulAddress } from "../utils/haneul-types.mjs";
+import { splitGenericParameters } from "@haneullabs/bcs";
+
+//#region src/bcs/type-tag-serializer.ts
+const VECTOR_REGEX = /^vector<(.+)>$/;
+const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+var TypeTagSerializer = class TypeTagSerializer {
+	static parseFromStr(str, normalizeAddress = false) {
+		if (str === "address") return { address: null };
+		else if (str === "bool") return { bool: null };
+		else if (str === "u8") return { u8: null };
+		else if (str === "u16") return { u16: null };
+		else if (str === "u32") return { u32: null };
+		else if (str === "u64") return { u64: null };
+		else if (str === "u128") return { u128: null };
+		else if (str === "u256") return { u256: null };
+		else if (str === "signer") return { signer: null };
+		const vectorMatch = str.match(VECTOR_REGEX);
+		if (vectorMatch) return { vector: TypeTagSerializer.parseFromStr(vectorMatch[1], normalizeAddress) };
+		const structMatch = str.match(STRUCT_REGEX);
+		if (structMatch) return { struct: {
+			address: normalizeAddress ? normalizeHaneulAddress(structMatch[1]) : structMatch[1],
+			module: structMatch[2],
+			name: structMatch[3],
+			typeParams: structMatch[5] === void 0 ? [] : TypeTagSerializer.parseStructTypeArgs(structMatch[5], normalizeAddress)
+		} };
+		throw new Error(`Encountered unexpected token when parsing type args for ${str}`);
+	}
+	static parseStructTypeArgs(str, normalizeAddress = false) {
+		return splitGenericParameters(str).map((tok) => TypeTagSerializer.parseFromStr(tok, normalizeAddress));
+	}
+	static tagToString(tag) {
+		if ("bool" in tag) return "bool";
+		if ("u8" in tag) return "u8";
+		if ("u16" in tag) return "u16";
+		if ("u32" in tag) return "u32";
+		if ("u64" in tag) return "u64";
+		if ("u128" in tag) return "u128";
+		if ("u256" in tag) return "u256";
+		if ("address" in tag) return "address";
+		if ("signer" in tag) return "signer";
+		if ("vector" in tag) return `vector<${TypeTagSerializer.tagToString(tag.vector)}>`;
+		if ("struct" in tag) {
+			const struct = tag.struct;
+			const typeParams = struct.typeParams.map(TypeTagSerializer.tagToString).join(", ");
+			return `${struct.address}::${struct.module}::${struct.name}${typeParams ? `<${typeParams}>` : ""}`;
+		}
+		throw new Error("Invalid TypeTag");
+	}
+};
+function normalizeTypeTag(type) {
+	return TypeTagSerializer.tagToString(TypeTagSerializer.parseFromStr(type));
+}
+
+//#endregion
+export { TypeTagSerializer, normalizeTypeTag };
+//# sourceMappingURL=type-tag-serializer.mjs.map

package/dist/bcs/type-tag-serializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-tag-serializer.mjs","names":[],"sources":["../../src/bcs/type-tag-serializer.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { splitGenericParameters } from '@haneullabs/bcs';\n\nimport { normalizeHaneulAddress } from '../utils/haneul-types.js';\nimport type { TypeTag } from './types.js';\n\nconst VECTOR_REGEX = /^vector<(.+)>$/;\nconst STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;\n\nexport class TypeTagSerializer {\n\tstatic parseFromStr(str: string, normalizeAddress = false): TypeTag {\n\t\tif (str === 'address') {\n\t\t\treturn { address: null };\n\t\t} else if (str === 'bool') {\n\t\t\treturn { bool: null };\n\t\t} else if (str === 'u8') {\n\t\t\treturn { u8: null };\n\t\t} else if (str === 'u16') {\n\t\t\treturn { u16: null };\n\t\t} else if (str === 'u32') {\n\t\t\treturn { u32: null };\n\t\t} else if (str === 'u64') {\n\t\t\treturn { u64: null };\n\t\t} else if (str === 'u128') {\n\t\t\treturn { u128: null };\n\t\t} else if (str === 'u256') {\n\t\t\treturn { u256: null };\n\t\t} else if (str === 'signer') {\n\t\t\treturn { signer: null };\n\t\t}\n\n\t\tconst vectorMatch = str.match(VECTOR_REGEX);\n\t\tif (vectorMatch) {\n\t\t\treturn {\n\t\t\t\tvector: TypeTagSerializer.parseFromStr(vectorMatch[1], normalizeAddress),\n\t\t\t};\n\t\t}\n\n\t\tconst structMatch = str.match(STRUCT_REGEX);\n\t\tif (structMatch) {\n\t\t\tconst address = normalizeAddress ? normalizeHaneulAddress(structMatch[1]) : structMatch[1];\n\t\t\treturn {\n\t\t\t\tstruct: {\n\t\t\t\t\taddress,\n\t\t\t\t\tmodule: structMatch[2],\n\t\t\t\t\tname: structMatch[3],\n\t\t\t\t\ttypeParams:\n\t\t\t\t\t\tstructMatch[5] === undefined\n\t\t\t\t\t\t\t? []\n\t\t\t\t\t\t\t: TypeTagSerializer.parseStructTypeArgs(structMatch[5], normalizeAddress),\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\n\t\tthrow new Error(`Encountered unexpected token when parsing type args for ${str}`);\n\t}\n\n\tstatic parseStructTypeArgs(str: string, normalizeAddress = false): TypeTag[] {\n\t\treturn splitGenericParameters(str).map((tok) =>\n\t\t\tTypeTagSerializer.parseFromStr(tok, normalizeAddress),\n\t\t);\n\t}\n\n\tstatic tagToString(tag: TypeTag): string {\n\t\tif ('bool' in tag) {\n\t\t\treturn 'bool';\n\t\t}\n\t\tif ('u8' in tag) {\n\t\t\treturn 'u8';\n\t\t}\n\t\tif ('u16' in tag) {\n\t\t\treturn 'u16';\n\t\t}\n\t\tif ('u32' in tag) {\n\t\t\treturn 'u32';\n\t\t}\n\t\tif ('u64' in tag) {\n\t\t\treturn 'u64';\n\t\t}\n\t\tif ('u128' in tag) {\n\t\t\treturn 'u128';\n\t\t}\n\t\tif ('u256' in tag) {\n\t\t\treturn 'u256';\n\t\t}\n\t\tif ('address' in tag) {\n\t\t\treturn 'address';\n\t\t}\n\t\tif ('signer' in tag) {\n\t\t\treturn 'signer';\n\t\t}\n\t\tif ('vector' in tag) {\n\t\t\treturn `vector<${TypeTagSerializer.tagToString(tag.vector)}>`;\n\t\t}\n\t\tif ('struct' in tag) {\n\t\t\tconst struct = tag.struct;\n\t\t\tconst typeParams = struct.typeParams.map(TypeTagSerializer.tagToString).join(', ');\n\t\t\treturn `${struct.address}::${struct.module}::${struct.name}${\n\t\t\t\ttypeParams ? `<${typeParams}>` : ''\n\t\t\t}`;\n\t\t}\n\t\tthrow new Error('Invalid TypeTag');\n\t}\n}\n\nexport function normalizeTypeTag(type: string): string {\n\treturn TypeTagSerializer.tagToString(TypeTagSerializer.parseFromStr(type));\n}\n"],"mappings":";;;;AAQA,MAAM,eAAe;AACrB,MAAM,eAAe;AAErB,IAAa,oBAAb,MAAa,kBAAkB;CAC9B,OAAO,aAAa,KAAa,mBAAmB,OAAgB;AACnE,MAAI,QAAQ,UACX,QAAO,EAAE,SAAS,MAAM;WACd,QAAQ,OAClB,QAAO,EAAE,MAAM,MAAM;WACX,QAAQ,KAClB,QAAO,EAAE,IAAI,MAAM;WACT,QAAQ,MAClB,QAAO,EAAE,KAAK,MAAM;WACV,QAAQ,MAClB,QAAO,EAAE,KAAK,MAAM;WACV,QAAQ,MAClB,QAAO,EAAE,KAAK,MAAM;WACV,QAAQ,OAClB,QAAO,EAAE,MAAM,MAAM;WACX,QAAQ,OAClB,QAAO,EAAE,MAAM,MAAM;WACX,QAAQ,SAClB,QAAO,EAAE,QAAQ,MAAM;EAGxB,MAAM,cAAc,IAAI,MAAM,aAAa;AAC3C,MAAI,YACH,QAAO,EACN,QAAQ,kBAAkB,aAAa,YAAY,IAAI,iBAAiB,EACxE;EAGF,MAAM,cAAc,IAAI,MAAM,aAAa;AAC3C,MAAI,YAEH,QAAO,EACN,QAAQ;GACP,SAHc,mBAAmB,uBAAuB,YAAY,GAAG,GAAG,YAAY;GAItF,QAAQ,YAAY;GACpB,MAAM,YAAY;GAClB,YACC,YAAY,OAAO,SAChB,EAAE,GACF,kBAAkB,oBAAoB,YAAY,IAAI,iBAAiB;GAC3E,EACD;AAGF,QAAM,IAAI,MAAM,2DAA2D,MAAM;;CAGlF,OAAO,oBAAoB,KAAa,mBAAmB,OAAkB;AAC5E,SAAO,uBAAuB,IAAI,CAAC,KAAK,QACvC,kBAAkB,aAAa,KAAK,iBAAiB,CACrD;;CAGF,OAAO,YAAY,KAAsB;AACxC,MAAI,UAAU,IACb,QAAO;AAER,MAAI,QAAQ,IACX,QAAO;AAER,MAAI,SAAS,IACZ,QAAO;AAER,MAAI,SAAS,IACZ,QAAO;AAER,MAAI,SAAS,IACZ,QAAO;AAER,MAAI,UAAU,IACb,QAAO;AAER,MAAI,UAAU,IACb,QAAO;AAER,MAAI,aAAa,IAChB,QAAO;AAER,MAAI,YAAY,IACf,QAAO;AAER,MAAI,YAAY,IACf,QAAO,UAAU,kBAAkB,YAAY,IAAI,OAAO,CAAC;AAE5D,MAAI,YAAY,KAAK;GACpB,MAAM,SAAS,IAAI;GACnB,MAAM,aAAa,OAAO,WAAW,IAAI,kBAAkB,YAAY,CAAC,KAAK,KAAK;AAClF,UAAO,GAAG,OAAO,QAAQ,IAAI,OAAO,OAAO,IAAI,OAAO,OACrD,aAAa,IAAI,WAAW,KAAK;;AAGnC,QAAM,IAAI,MAAM,kBAAkB;;;AAIpC,SAAgB,iBAAiB,MAAsB;AACtD,QAAO,kBAAkB,YAAY,kBAAkB,aAAa,KAAK,CAAC"}

package/dist/bcs/types.d.mts

@@ -0,0 +1,40 @@
+//#region src/bcs/types.d.ts
+
+/**
+ * Kind of a TypeTag which is represented by a Move type identifier.
+ */
+type StructTag = {
+  address: string;
+  module: string;
+  name: string;
+  typeParams: TypeTag[];
+};
+/**
+ * Haneul TypeTag object. A decoupled `0x...::module::Type<???>` parameter.
+ */
+type TypeTag = {
+  bool: null | true;
+} | {
+  u8: null | true;
+} | {
+  u64: null | true;
+} | {
+  u128: null | true;
+} | {
+  address: null | true;
+} | {
+  signer: null | true;
+} | {
+  vector: TypeTag;
+} | {
+  struct: StructTag;
+} | {
+  u16: null | true;
+} | {
+  u32: null | true;
+} | {
+  u256: null | true;
+};
+//#endregion
+export { TypeTag };
+//# sourceMappingURL=types.d.mts.map

package/dist/bcs/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/bcs/types.ts"],"sourcesContent":[],"mappings":";;;;;KAoFY,SAAA;;;;cAIC;;;;;KAMD,OAAA;;;;;;;;;;;;;UAOC;;UACA"}

package/dist/client/cache.d.mts

@@ -0,0 +1,19 @@
+//#region src/client/cache.d.ts
+interface ClientCacheOptions {
+  prefix?: string[];
+  cache?: Map<string, unknown>;
+}
+declare class ClientCache {
+  #private;
+  constructor({
+    prefix,
+    cache
+  }?: ClientCacheOptions);
+  read<T>(key: [string, ...string[]], load: () => T | Promise<T>): T | Promise<T>;
+  readSync<T>(key: [string, ...string[]], load: () => T): T;
+  clear(prefix?: string[]): void;
+  scope(prefix: string | string[]): ClientCache;
+}
+//#endregion
+export { ClientCache, ClientCacheOptions };
+//# sourceMappingURL=cache.d.mts.map

package/dist/client/cache.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.mts","names":[],"sources":["../../src/client/cache.ts"],"sourcesContent":[],"mappings":";UAGiB,kBAAA;EAAA,MAAA,CAAA,EAAA,MAAA,EAAA;EAKJ,KAAA,CAAA,EAHJ,GAGI,CAAA,MAAW,EAAA,OAAA,CAAA;;AAID,cAJV,WAAA,CAIU;EAAS,CAAA,OAAA;EAKiB,WAAA,CAAA;IAAA,MAAA;IAAA;EAAA,CAAA,CAAA,EALjB,kBAKiB;EAAY,IAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,EAAA,IAAA,EAAA,GAAA,GAAZ,CAAY,GAAR,OAAQ,CAAA,CAAA,CAAA,CAAA,EAAK,CAAL,GAAS,OAAT,CAAiB,CAAjB,CAAA;EAAR,QAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,EAAA,IAAA,EAAA,GAAA,GA0BA,CA1BA,CAAA,EA0BI,CA1BJ;EAAa,KAAA,CAAA,MAAA,CAAA,EAAA,MAAA,EAAA,CAAA,EAAA,IAAA;EAAY,KAAA,CAAA,MAAA,EAAA,MAAA,GAAA,MAAA,EAAA,CAAA,EAsD9C,WAtD8C"}

package/dist/client/cache.mjs

@@ -0,0 +1,48 @@
+//#region src/client/cache.ts
+var ClientCache = class ClientCache {
+	#prefix;
+	#cache;
+	constructor({ prefix, cache } = {}) {
+		this.#prefix = prefix ?? [];
+		this.#cache = cache ?? /* @__PURE__ */ new Map();
+	}
+	read(key, load) {
+		const cacheKey = [this.#prefix, ...key].join(":");
+		if (this.#cache.has(cacheKey)) return this.#cache.get(cacheKey);
+		const result = load();
+		this.#cache.set(cacheKey, result);
+		if (typeof result === "object" && result !== null && "then" in result) return Promise.resolve(result).then((v) => {
+			this.#cache.set(cacheKey, v);
+			return v;
+		}).catch((err) => {
+			this.#cache.delete(cacheKey);
+			throw err;
+		});
+		return result;
+	}
+	readSync(key, load) {
+		const cacheKey = [this.#prefix, ...key].join(":");
+		if (this.#cache.has(cacheKey)) return this.#cache.get(cacheKey);
+		const result = load();
+		this.#cache.set(cacheKey, result);
+		return result;
+	}
+	clear(prefix) {
+		const prefixKey = [...this.#prefix, ...prefix ?? []].join(":");
+		if (!prefixKey) {
+			this.#cache.clear();
+			return;
+		}
+		for (const key of this.#cache.keys()) if (key.startsWith(prefixKey)) this.#cache.delete(key);
+	}
+	scope(prefix) {
+		return new ClientCache({
+			prefix: [...this.#prefix, ...Array.isArray(prefix) ? prefix : [prefix]],
+			cache: this.#cache
+		});
+	}
+};
+
+//#endregion
+export { ClientCache };
+//# sourceMappingURL=cache.mjs.map

package/dist/client/cache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.mjs","names":["#prefix","#cache"],"sources":["../../src/client/cache.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport interface ClientCacheOptions {\n\tprefix?: string[];\n\tcache?: Map<string, unknown>;\n}\n\nexport class ClientCache {\n\t#prefix: string[];\n\t#cache: Map<string, unknown>;\n\n\tconstructor({ prefix, cache }: ClientCacheOptions = {}) {\n\t\tthis.#prefix = prefix ?? [];\n\t\tthis.#cache = cache ?? new Map();\n\t}\n\n\tread<T>(key: [string, ...string[]], load: () => T | Promise<T>): T | Promise<T> {\n\t\tconst cacheKey = [this.#prefix, ...key].join(':');\n\n\t\tif (this.#cache.has(cacheKey)) {\n\t\t\treturn this.#cache.get(cacheKey) as T;\n\t\t}\n\n\t\tconst result = load();\n\n\t\tthis.#cache.set(cacheKey, result);\n\n\t\tif (typeof result === 'object' && result !== null && 'then' in result) {\n\t\t\treturn Promise.resolve(result)\n\t\t\t\t.then((v) => {\n\t\t\t\t\tthis.#cache.set(cacheKey, v);\n\t\t\t\t\treturn v as T;\n\t\t\t\t})\n\t\t\t\t.catch((err) => {\n\t\t\t\t\tthis.#cache.delete(cacheKey);\n\t\t\t\t\tthrow err;\n\t\t\t\t});\n\t\t}\n\n\t\treturn result as T;\n\t}\n\n\treadSync<T>(key: [string, ...string[]], load: () => T): T {\n\t\tconst cacheKey = [this.#prefix, ...key].join(':');\n\n\t\tif (this.#cache.has(cacheKey)) {\n\t\t\treturn this.#cache.get(cacheKey) as T;\n\t\t}\n\n\t\tconst result = load();\n\n\t\tthis.#cache.set(cacheKey, result);\n\n\t\treturn result as T;\n\t}\n\n\tclear(prefix?: string[]) {\n\t\tconst prefixKey = [...this.#prefix, ...(prefix ?? [])].join(':');\n\t\tif (!prefixKey) {\n\t\t\tthis.#cache.clear();\n\t\t\treturn;\n\t\t}\n\n\t\tfor (const key of this.#cache.keys()) {\n\t\t\tif (key.startsWith(prefixKey)) {\n\t\t\t\tthis.#cache.delete(key);\n\t\t\t}\n\t\t}\n\t}\n\n\tscope(prefix: string | string[]) {\n\t\treturn new ClientCache({\n\t\t\tprefix: [...this.#prefix, ...(Array.isArray(prefix) ? prefix : [prefix])],\n\t\t\tcache: this.#cache,\n\t\t});\n\t}\n}\n"],"mappings":";AAQA,IAAa,cAAb,MAAa,YAAY;CACxB;CACA;CAEA,YAAY,EAAE,QAAQ,UAA8B,EAAE,EAAE;AACvD,QAAKA,SAAU,UAAU,EAAE;AAC3B,QAAKC,QAAS,yBAAS,IAAI,KAAK;;CAGjC,KAAQ,KAA4B,MAA4C;EAC/E,MAAM,WAAW,CAAC,MAAKD,QAAS,GAAG,IAAI,CAAC,KAAK,IAAI;AAEjD,MAAI,MAAKC,MAAO,IAAI,SAAS,CAC5B,QAAO,MAAKA,MAAO,IAAI,SAAS;EAGjC,MAAM,SAAS,MAAM;AAErB,QAAKA,MAAO,IAAI,UAAU,OAAO;AAEjC,MAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,UAAU,OAC9D,QAAO,QAAQ,QAAQ,OAAO,CAC5B,MAAM,MAAM;AACZ,SAAKA,MAAO,IAAI,UAAU,EAAE;AAC5B,UAAO;IACN,CACD,OAAO,QAAQ;AACf,SAAKA,MAAO,OAAO,SAAS;AAC5B,SAAM;IACL;AAGJ,SAAO;;CAGR,SAAY,KAA4B,MAAkB;EACzD,MAAM,WAAW,CAAC,MAAKD,QAAS,GAAG,IAAI,CAAC,KAAK,IAAI;AAEjD,MAAI,MAAKC,MAAO,IAAI,SAAS,CAC5B,QAAO,MAAKA,MAAO,IAAI,SAAS;EAGjC,MAAM,SAAS,MAAM;AAErB,QAAKA,MAAO,IAAI,UAAU,OAAO;AAEjC,SAAO;;CAGR,MAAM,QAAmB;EACxB,MAAM,YAAY,CAAC,GAAG,MAAKD,QAAS,GAAI,UAAU,EAAE,CAAE,CAAC,KAAK,IAAI;AAChE,MAAI,CAAC,WAAW;AACf,SAAKC,MAAO,OAAO;AACnB;;AAGD,OAAK,MAAM,OAAO,MAAKA,MAAO,MAAM,CACnC,KAAI,IAAI,WAAW,UAAU,CAC5B,OAAKA,MAAO,OAAO,IAAI;;CAK1B,MAAM,QAA2B;AAChC,SAAO,IAAI,YAAY;GACtB,QAAQ,CAAC,GAAG,MAAKD,QAAS,GAAI,MAAM,QAAQ,OAAO,GAAG,SAAS,CAAC,OAAO,CAAE;GACzE,OAAO,MAAKC;GACZ,CAAC"}

package/dist/client/client.d.mts

@@ -0,0 +1,21 @@
+import { ClientCache } from "./cache.mjs";
+import { ClientWithExtensions, HaneulClientRegistration, HaneulClientTypes } from "./types.mjs";
+import { CoreClient } from "./core.mjs";
+import { Simplify, UnionToIntersection } from "@haneullabs/utils";
+
+//#region src/client/client.d.ts
+declare abstract class BaseClient {
+  network: HaneulClientTypes.Network;
+  cache: ClientCache;
+  base: BaseClient;
+  constructor({
+    network,
+    base,
+    cache
+  }: HaneulClientTypes.HaneulClientOptions);
+  abstract core: CoreClient;
+  $extend<const Registrations extends HaneulClientRegistration<this>[]>(...registrations: Registrations): ClientWithExtensions<Simplify<UnionToIntersection<{ [K in keyof Registrations]: Registrations[K] extends HaneulClientRegistration<this, infer Name extends string, infer Extension> ? { [K2 in Name]: Extension } : never }[number]>>, this>;
+}
+//#endregion
+export { BaseClient };
+//# sourceMappingURL=client.d.mts.map

package/dist/client/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../../src/client/client.ts"],"sourcesContent":[],"mappings":";;;;;;uBAQsB,UAAA;WACZ,iBAAA,CAAkB;EADN,KAAA,EAEd,WAFwB;EACtB,IAAA,EAEH,UAFqB;EACpB,WAAA,CAAA;IAAA,OAAA;IAAA,IAAA;IAAA;EAAA,CAAA,EAOJ,iBAAA,CAAkB,mBAPd;EACD,SAAA,IAAA,EAYS,UAZT;EAGL,OAAA,CAAA,4BAWmC,wBAXnC,CAAA,IAAA,CAAA,EAAA,CAAA,CAAA,GAAA,aAAA,EAYkB,aAZlB,CAAA,EAuCM,oBAvCN,CAwCC,QAxCD,CAyCE,mBAzCF,CAAA,QAAA,MA2CgB,aA3ChB,GA2CgC,aA3ChC,CA2C8C,CA3C9C,CAAA,SA2CyD,wBA3CzD,CAAA,IAAA,EAAA,KAAA,cAAA,MAAA,EAAA,KAAA,UAAA,CAAA,GAAA,SAiDc,IAjDd,GAiDqB,SAjDrB,EAAA,GAAA,KAAA,EAAA,CAAA,MAAA,CAAA,CAAA,CAAA,EAAA,IAAA,CAAA"}

package/dist/client/client.mjs

@@ -0,0 +1,30 @@
+import { ClientCache } from "./cache.mjs";
+
+//#region src/client/client.ts
+var BaseClient = class {
+	constructor({ network, base, cache = base?.cache ?? new ClientCache() }) {
+		this.network = network;
+		this.base = base ?? this;
+		this.cache = cache;
+	}
+	$extend(...registrations) {
+		const extensions = Object.fromEntries(registrations.map((registration) => {
+			return [registration.name, registration.register(this)];
+		}));
+		const methodCache = /* @__PURE__ */ new Map();
+		return new Proxy(this, { get(target, prop, receiver) {
+			if (typeof prop === "string" && prop in extensions) return extensions[prop];
+			const value = Reflect.get(target, prop, receiver);
+			if (typeof value === "function") {
+				if (prop === "$extend") return value.bind(receiver);
+				if (!methodCache.has(prop)) methodCache.set(prop, value.bind(target));
+				return methodCache.get(prop);
+			}
+			return value;
+		} });
+	}
+};
+
+//#endregion
+export { BaseClient };
+//# sourceMappingURL=client.mjs.map

package/dist/client/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../../src/client/client.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Simplify, UnionToIntersection } from '@haneullabs/utils';\nimport { ClientCache } from './cache.js';\nimport type { CoreClient } from './core.js';\nimport type { ClientWithExtensions, HaneulClientTypes, HaneulClientRegistration } from './types.js';\n\nexport abstract class BaseClient {\n\tnetwork: HaneulClientTypes.Network;\n\tcache: ClientCache;\n\tbase: BaseClient;\n\n\tconstructor({\n\t\tnetwork,\n\t\tbase,\n\t\tcache = base?.cache ?? new ClientCache(),\n\t}: HaneulClientTypes.HaneulClientOptions) {\n\t\tthis.network = network;\n\t\tthis.base = base ?? this;\n\t\tthis.cache = cache;\n\t}\n\n\tabstract core: CoreClient;\n\n\t$extend<const Registrations extends HaneulClientRegistration<this>[]>(\n\t\t...registrations: Registrations\n\t) {\n\t\tconst extensions: Record<string, unknown> = Object.fromEntries(\n\t\t\tregistrations.map((registration) => {\n\t\t\t\treturn [registration.name, registration.register(this)];\n\t\t\t}),\n\t\t);\n\n\t\tconst methodCache = new Map<string | symbol, Function>();\n\n\t\treturn new Proxy(this, {\n\t\t\tget(target, prop, receiver) {\n\t\t\t\tif (typeof prop === 'string' && prop in extensions) {\n\t\t\t\t\treturn extensions[prop];\n\t\t\t\t}\n\t\t\t\tconst value = Reflect.get(target, prop, receiver);\n\t\t\t\tif (typeof value === 'function') {\n\t\t\t\t\tif (prop === '$extend') {\n\t\t\t\t\t\treturn value.bind(receiver);\n\t\t\t\t\t}\n\t\t\t\t\tif (!methodCache.has(prop)) {\n\t\t\t\t\t\tmethodCache.set(prop, value.bind(target));\n\t\t\t\t\t}\n\t\t\t\t\treturn methodCache.get(prop);\n\t\t\t\t}\n\t\t\t\treturn value;\n\t\t\t},\n\t\t}) as ClientWithExtensions<\n\t\t\tSimplify<\n\t\t\t\tUnionToIntersection<\n\t\t\t\t\t{\n\t\t\t\t\t\t[K in keyof Registrations]: Registrations[K] extends HaneulClientRegistration<\n\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\tinfer Name extends string,\n\t\t\t\t\t\t\tinfer Extension\n\t\t\t\t\t\t>\n\t\t\t\t\t\t\t? {\n\t\t\t\t\t\t\t\t\t[K2 in Name]: Extension;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t: never;\n\t\t\t\t\t}[number]\n\t\t\t\t>\n\t\t\t>,\n\t\t\tthis\n\t\t>;\n\t}\n}\n"],"mappings":";;;AAQA,IAAsB,aAAtB,MAAiC;CAKhC,YAAY,EACX,SACA,MACA,QAAQ,MAAM,SAAS,IAAI,aAAa,IACC;AACzC,OAAK,UAAU;AACf,OAAK,OAAO,QAAQ;AACpB,OAAK,QAAQ;;CAKd,QACC,GAAG,eACF;EACD,MAAM,aAAsC,OAAO,YAClD,cAAc,KAAK,iBAAiB;AACnC,UAAO,CAAC,aAAa,MAAM,aAAa,SAAS,KAAK,CAAC;IACtD,CACF;EAED,MAAM,8BAAc,IAAI,KAAgC;AAExD,SAAO,IAAI,MAAM,MAAM,EACtB,IAAI,QAAQ,MAAM,UAAU;AAC3B,OAAI,OAAO,SAAS,YAAY,QAAQ,WACvC,QAAO,WAAW;GAEnB,MAAM,QAAQ,QAAQ,IAAI,QAAQ,MAAM,SAAS;AACjD,OAAI,OAAO,UAAU,YAAY;AAChC,QAAI,SAAS,UACZ,QAAO,MAAM,KAAK,SAAS;AAE5B,QAAI,CAAC,YAAY,IAAI,KAAK,CACzB,aAAY,IAAI,MAAM,MAAM,KAAK,OAAO,CAAC;AAE1C,WAAO,YAAY,IAAI,KAAK;;AAE7B,UAAO;KAER,CAAC"}

package/dist/client/core-resolver.d.mts

@@ -0,0 +1,9 @@
+import { TransactionDataBuilder } from "../transactions/TransactionData.mjs";
+import { BuildTransactionOptions } from "../transactions/resolve.mjs";
+import "../transactions/index.mjs";
+
+//#region src/client/core-resolver.d.ts
+declare function coreClientResolveTransactionPlugin(transactionData: TransactionDataBuilder, options: BuildTransactionOptions, next: () => Promise<void>): Promise<void>;
+//#endregion
+export { coreClientResolveTransactionPlugin };
+//# sourceMappingURL=core-resolver.d.mts.map

package/dist/client/core-resolver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-resolver.d.mts","names":[],"sources":["../../src/client/core-resolver.ts"],"sourcesContent":[],"mappings":";;;;;iBAiCsB,kCAAA,kBACJ,iCACR,qCACG,gBAAa"}