@wowok/wowok 2.2.16 → 2.3.1

package/dist/esm/transactions/data/internal.js

@@ -1 +0,0 @@
-import{array,boolean,check,integer,lazy,literal,nullable,nullish,number,object,optional,pipe,record,string,transform,tuple,union,unknown}from'valibot';import{isValidWowAddress,normalizeWowAddress}from'../../utils/wow-types.js';export function safeEnum(a){const b=Object['entries'](a)['map'](([c,d])=>object({[c]:d}));return pipe(union(b),transform(c=>({...c,'$kind':Object['keys'](c)[0x0]})));}export const WowAddress=pipe(string(),transform(a=>normalizeWowAddress(a)),check(isValidWowAddress));export const ObjectID=WowAddress;export const BCSBytes=string();export const JsonU64=pipe(union([string(),pipe(number(),integer())]),check(a=>{try{return BigInt(a),BigInt(a)>=0x0&&BigInt(a)<=0xffffffffffffffffn;}catch{return![];}},'Invalid\x20u64'));export const ObjectRefSchema=object({'objectId':WowAddress,'version':JsonU64,'digest':string()});export const ArgumentSchema=pipe(union([object({'GasCoin':literal(!![])}),object({'Input':pipe(number(),integer()),'type':optional(literal('pure'))}),object({'Input':pipe(number(),integer()),'type':optional(literal('object'))}),object({'Result':pipe(number(),integer())}),object({'NestedResult':tuple([pipe(number(),integer()),pipe(number(),integer())])})]),transform(a=>({...a,'$kind':Object['keys'](a)[0x0]})));export const GasDataSchema=object({'budget':nullable(JsonU64),'price':nullable(JsonU64),'owner':nullable(WowAddress),'payment':nullable(array(ObjectRefSchema))});export const StructTagSchema=object({'address':string(),'module':string(),'name':string(),'typeParams':array(string())});export const OpenMoveTypeSignatureBodySchema=union([literal('address'),literal('bool'),literal('u8'),literal('u16'),literal('u32'),literal('u64'),literal('u128'),literal('u256'),object({'vector':lazy(()=>OpenMoveTypeSignatureBodySchema)}),object({'datatype':object({'package':string(),'module':string(),'type':string(),'typeParameters':array(lazy(()=>OpenMoveTypeSignatureBodySchema))})}),object({'typeParameter':pipe(number(),integer())})]);export const OpenMoveTypeSignatureSchema=object({'ref':nullable(union([literal('&'),literal('&mut')])),'body':OpenMoveTypeSignatureBodySchema});const ProgrammableMoveCallSchema=object({'package':ObjectID,'module':string(),'function':string(),'typeArguments':array(string()),'arguments':array(ArgumentSchema),'_argumentTypes':optional(nullable(array(OpenMoveTypeSignatureSchema)))});export const $Intent=object({'name':string(),'inputs':record(string(),union([ArgumentSchema,array(ArgumentSchema)])),'data':record(string(),unknown())});export const CommandSchema=safeEnum({'MoveCall':ProgrammableMoveCallSchema,'TransferObjects':object({'objects':array(ArgumentSchema),'address':ArgumentSchema}),'SplitCoins':object({'coin':ArgumentSchema,'amounts':array(ArgumentSchema)}),'MergeCoins':object({'destination':ArgumentSchema,'sources':array(ArgumentSchema)}),'Publish':object({'modules':array(BCSBytes),'dependencies':array(ObjectID)}),'MakeMoveVec':object({'type':nullable(string()),'elements':array(ArgumentSchema)}),'Upgrade':object({'modules':array(BCSBytes),'dependencies':array(ObjectID),'package':ObjectID,'ticket':ArgumentSchema}),'$Intent':$Intent});export const ObjectArgSchema=safeEnum({'ImmOrOwnedObject':ObjectRefSchema,'SharedObject':object({'objectId':ObjectID,'initialSharedVersion':JsonU64,'mutable':boolean()}),'Receiving':ObjectRefSchema});const CallArgSchema=safeEnum({'Object':ObjectArgSchema,'Pure':object({'bytes':BCSBytes}),'UnresolvedPure':object({'value':unknown()}),'UnresolvedObject':object({'objectId':ObjectID,'version':optional(nullable(JsonU64)),'digest':optional(nullable(string())),'initialSharedVersion':optional(nullable(JsonU64)),'mutable':optional(nullable(boolean()))})});export const NormalizedCallArg=safeEnum({'Object':ObjectArgSchema,'Pure':object({'bytes':BCSBytes})});export const TransactionExpiration=safeEnum({'None':literal(!![]),'Epoch':JsonU64});export const TransactionDataSchema=object({'version':literal(0x2),'sender':nullish(WowAddress),'expiration':nullish(TransactionExpiration),'gasData':GasDataSchema,'inputs':array(CallArgSchema),'commands':array(CommandSchema)});

package/dist/esm/transactions/data/v1.d.ts

@@ -1,312 +0,0 @@
-import type { GenericSchema, InferOutput } from "valibot";
-import type { StructTag as StructTagType, TypeTag as TypeTagType } from "../../bcs/types.js";
-import type { TransactionData } from "./internal.js";
-export declare const ObjectRef: import("valibot").ObjectSchema<{
-    readonly digest: import("valibot").StringSchema<undefined>;
-    readonly objectId: import("valibot").StringSchema<undefined>;
-    readonly version: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>;
-}, undefined>;
-export declare const NormalizedCallArg: import("valibot").BaseSchema<{
-    Object: {
-        Receiving: {
-            digest: string;
-            objectId: string;
-            version: string | number | bigint;
-        };
-    } | {
-        Shared: {
-            objectId: string;
-            initialSharedVersion: string | number;
-            mutable: boolean;
-        };
-    } | {
-        ImmOrOwned: {
-            digest: string;
-            objectId: string;
-            version: string | number | bigint;
-        };
-    };
-} | {
-    Pure: number[];
-}, import("../../_deps/bcs/types.js").EnumOutputShapeWithKeys<{
-    Object: import("../../_deps/bcs/types.js").EnumOutputShapeWithKeys<{
-        ImmOrOwned: {
-            digest: string;
-            objectId: string;
-            version: string | number | bigint;
-        };
-        Shared: {
-            objectId: string;
-            initialSharedVersion: string | number;
-            mutable: boolean;
-        };
-        Receiving: {
-            digest: string;
-            objectId: string;
-            version: string | number | bigint;
-        };
-    }, "Receiving" | "Shared" | "ImmOrOwned">;
-    Pure: number[];
-}, "Object" | "Pure">, import("valibot").BaseIssue<unknown>>;
-export declare const TypeTag: GenericSchema<TypeTagType>;
-export declare const StructTag: GenericSchema<StructTagType>;
-export declare const TransactionArgument: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-    readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-    readonly value: import("valibot").UnknownSchema;
-    readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-    readonly value: import("valibot").UnknownSchema;
-    readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-}, undefined>], undefined>, import("valibot").ObjectSchema<{
-    readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-}, undefined>, import("valibot").ObjectSchema<{
-    readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-    readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-    readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-}, undefined>], undefined>;
-export declare const SerializedTransactionDataV1: import("valibot").ObjectSchema<{
-    readonly version: import("valibot").LiteralSchema<1, undefined>;
-    readonly sender: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly expiration: import("valibot").NullishSchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly Epoch: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly None: import("valibot").NullableSchema<import("valibot").LiteralSchema<true, undefined>, undefined>;
-    }, undefined>], undefined>, undefined>;
-    readonly gasConfig: import("valibot").ObjectSchema<{
-        readonly budget: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").NumberSchema<undefined>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>, import("valibot").CheckAction<string | number | bigint, undefined>]>, undefined>;
-        readonly price: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").NumberSchema<undefined>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>, import("valibot").CheckAction<string | number | bigint, undefined>]>, undefined>;
-        readonly payment: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-            readonly digest: import("valibot").StringSchema<undefined>;
-            readonly objectId: import("valibot").StringSchema<undefined>;
-            readonly version: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, import("valibot").StringSchema<undefined>, import("valibot").BigintSchema<undefined>], undefined>;
-        }, undefined>, undefined>, undefined>;
-        readonly owner: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly inputs: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-        readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        readonly value: import("valibot").UnknownSchema;
-        readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-        readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        readonly value: import("valibot").UnknownSchema;
-        readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-    }, undefined>], undefined>, undefined>;
-    readonly transactions: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"MoveCall", undefined>;
-        readonly target: GenericSchema<`${string}::${string}::${string}`>;
-        readonly typeArguments: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
-        readonly arguments: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"TransferObjects", undefined>;
-        readonly objects: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>, undefined>;
-        readonly address: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"SplitCoins", undefined>;
-        readonly coin: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>;
-        readonly amounts: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"MergeCoins", undefined>;
-        readonly destination: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>;
-        readonly sources: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"Publish", undefined>;
-        readonly modules: import("valibot").ArraySchema<import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, undefined>, undefined>;
-        readonly dependencies: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"Upgrade", undefined>;
-        readonly modules: import("valibot").ArraySchema<import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>, undefined>, undefined>;
-        readonly dependencies: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
-        readonly packageId: import("valibot").StringSchema<undefined>;
-        readonly ticket: import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly kind: import("valibot").LiteralSchema<"MakeMoveVec", undefined>;
-        readonly type: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly Some: GenericSchema<TypeTagType>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly None: import("valibot").NullableSchema<import("valibot").LiteralSchema<true, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly objects: import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").OptionalSchema<import("valibot").LiteralSchema<"object", undefined>, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Input", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly value: import("valibot").UnknownSchema;
-            readonly type: import("valibot").LiteralSchema<"pure", undefined>;
-        }, undefined>], undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"GasCoin", undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"Result", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly kind: import("valibot").LiteralSchema<"NestedResult", undefined>;
-            readonly index: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-            readonly resultIndex: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>;
-        }, undefined>], undefined>, undefined>;
-    }, undefined>], undefined>, undefined>;
-}, undefined>;
-export type SerializedTransactionDataV1 = InferOutput<typeof SerializedTransactionDataV1>;
-export declare function serializeV1TransactionData(transactionData: TransactionData): SerializedTransactionDataV1;
-export declare function transactionDataFromV1(data: SerializedTransactionDataV1): TransactionData;

package/dist/esm/transactions/data/v1.js

@@ -1 +0,0 @@
-import{fromBase64,toBase64}from'../../_deps/bcs/index.js';import{array,bigint,boolean,check,integer,is,lazy,literal,nullable,nullish,number,object,optional,parse,pipe,string,union,unknown}from'valibot';import{TypeTagSerializer}from'../../bcs/index.js';import{JsonU64,ObjectID,safeEnum,TransactionDataSchema}from'./internal.js';export const ObjectRef=object({'digest':string(),'objectId':string(),'version':union([pipe(number(),integer()),string(),bigint()])});const ObjectArg=safeEnum({'ImmOrOwned':ObjectRef,'Shared':object({'objectId':ObjectID,'initialSharedVersion':JsonU64,'mutable':boolean()}),'Receiving':ObjectRef});export const NormalizedCallArg=safeEnum({'Object':ObjectArg,'Pure':array(pipe(number(),integer()))});const TransactionInput=union([object({'kind':literal('Input'),'index':pipe(number(),integer()),'value':unknown(),'type':optional(literal('object'))}),object({'kind':literal('Input'),'index':pipe(number(),integer()),'value':unknown(),'type':literal('pure')})]),TransactionExpiration=union([object({'Epoch':pipe(number(),integer())}),object({'None':nullable(literal(!![]))})]),StringEncodedBigint=pipe(union([number(),string(),bigint()]),check(a=>{if(!['string','number','bigint']['includes'](typeof a))return![];try{return BigInt(a),!![];}catch{return![];}}));export const TypeTag=union([object({'bool':nullable(literal(!![]))}),object({'u8':nullable(literal(!![]))}),object({'u64':nullable(literal(!![]))}),object({'u128':nullable(literal(!![]))}),object({'address':nullable(literal(!![]))}),object({'signer':nullable(literal(!![]))}),object({'vector':lazy(()=>TypeTag)}),object({'struct':lazy(()=>StructTag)}),object({'u16':nullable(literal(!![]))}),object({'u32':nullable(literal(!![]))}),object({'u256':nullable(literal(!![]))})]);export const StructTag=object({'address':string(),'module':string(),'name':string(),'typeParams':array(TypeTag)});const GasConfig=object({'budget':optional(StringEncodedBigint),'price':optional(StringEncodedBigint),'payment':optional(array(ObjectRef)),'owner':optional(string())}),TransactionArgumentTypes=[TransactionInput,object({'kind':literal('GasCoin')}),object({'kind':literal('Result'),'index':pipe(number(),integer())}),object({'kind':literal('NestedResult'),'index':pipe(number(),integer()),'resultIndex':pipe(number(),integer())})];export const TransactionArgument=union([...TransactionArgumentTypes]);const MoveCallTransaction=object({'kind':literal('MoveCall'),'target':pipe(string(),check(a=>a['split']('::')['length']===0x3)),'typeArguments':array(string()),'arguments':array(TransactionArgument)}),TransferObjectsTransaction=object({'kind':literal('TransferObjects'),'objects':array(TransactionArgument),'address':TransactionArgument}),SplitCoinsTransaction=object({'kind':literal('SplitCoins'),'coin':TransactionArgument,'amounts':array(TransactionArgument)}),MergeCoinsTransaction=object({'kind':literal('MergeCoins'),'destination':TransactionArgument,'sources':array(TransactionArgument)}),MakeMoveVecTransaction=object({'kind':literal('MakeMoveVec'),'type':union([object({'Some':TypeTag}),object({'None':nullable(literal(!![]))})]),'objects':array(TransactionArgument)}),PublishTransaction=object({'kind':literal('Publish'),'modules':array(array(pipe(number(),integer()))),'dependencies':array(string())}),UpgradeTransaction=object({'kind':literal('Upgrade'),'modules':array(array(pipe(number(),integer()))),'dependencies':array(string()),'packageId':string(),'ticket':TransactionArgument}),TransactionTypes=[MoveCallTransaction,TransferObjectsTransaction,SplitCoinsTransaction,MergeCoinsTransaction,PublishTransaction,UpgradeTransaction,MakeMoveVecTransaction],TransactionType=union([...TransactionTypes]);export const SerializedTransactionDataV1=object({'version':literal(0x1),'sender':optional(string()),'expiration':nullish(TransactionExpiration),'gasConfig':GasConfig,'inputs':array(TransactionInput),'transactions':array(TransactionType)});export function serializeV1TransactionData(a){const b=a['inputs']['map']((c,d)=>{if(c['Object'])return{'kind':'Input','index':d,'value':{'Object':c['Object']['ImmOrOwnedObject']?{'ImmOrOwned':c['Object']['ImmOrOwnedObject']}:c['Object']['Receiving']?{'Receiving':{'digest':c['Object']['Receiving']['digest'],'version':c['Object']['Receiving']['version'],'objectId':c['Object']['Receiving']['objectId']}}:{'Shared':{'mutable':c['Object']['SharedObject']['mutable'],'initialSharedVersion':c['Object']['SharedObject']['initialSharedVersion'],'objectId':c['Object']['SharedObject']['objectId']}}},'type':'object'};if(c['Pure'])return{'kind':'Input','index':d,'value':{'Pure':Array['from'](fromBase64(c['Pure']['bytes']))},'type':'pure'};if(c['UnresolvedPure'])return{'kind':'Input','type':'pure','index':d,'value':c['UnresolvedPure']['value']};if(c['UnresolvedObject'])return{'kind':'Input','type':'object','index':d,'value':c['UnresolvedObject']['objectId']};throw new Error('Invalid\x20input');});return{'version':0x1,'sender':a['sender']??undefined,'expiration':a['expiration']?.['$kind']==='Epoch'?{'Epoch':Number(a['expiration']['Epoch'])}:a['expiration']?{'None':!![]}:null,'gasConfig':{'owner':a['gasData']['owner']??undefined,'budget':a['gasData']['budget']??undefined,'price':a['gasData']['price']??undefined,'payment':a['gasData']['payment']??undefined},'inputs':b,'transactions':a['commands']['map'](c=>{if(c['MakeMoveVec'])return{'kind':'MakeMoveVec','type':c['MakeMoveVec']['type']===null?{'None':!![]}:{'Some':TypeTagSerializer['parseFromStr'](c['MakeMoveVec']['type'])},'objects':c['MakeMoveVec']['elements']['map'](d=>convertTransactionArgument(d,b))};if(c['MergeCoins'])return{'kind':'MergeCoins','destination':convertTransactionArgument(c['MergeCoins']['destination'],b),'sources':c['MergeCoins']['sources']['map'](d=>convertTransactionArgument(d,b))};if(c['MoveCall'])return{'kind':'MoveCall','target':c['MoveCall']['package']+'::'+c['MoveCall']['module']+'::'+c['MoveCall']['function'],'typeArguments':c['MoveCall']['typeArguments'],'arguments':c['MoveCall']['arguments']['map'](d=>convertTransactionArgument(d,b))};if(c['Publish'])return{'kind':'Publish','modules':c['Publish']['modules']['map'](d=>Array['from'](fromBase64(d))),'dependencies':c['Publish']['dependencies']};if(c['SplitCoins'])return{'kind':'SplitCoins','coin':convertTransactionArgument(c['SplitCoins']['coin'],b),'amounts':c['SplitCoins']['amounts']['map'](d=>convertTransactionArgument(d,b))};if(c['TransferObjects'])return{'kind':'TransferObjects','objects':c['TransferObjects']['objects']['map'](d=>convertTransactionArgument(d,b)),'address':convertTransactionArgument(c['TransferObjects']['address'],b)};if(c['Upgrade'])return{'kind':'Upgrade','modules':c['Upgrade']['modules']['map'](d=>Array['from'](fromBase64(d))),'dependencies':c['Upgrade']['dependencies'],'packageId':c['Upgrade']['package'],'ticket':convertTransactionArgument(c['Upgrade']['ticket'],b)};throw new Error('Unknown\x20transaction\x20'+Object['keys'](c));})};}function convertTransactionArgument(a,b){if(a['$kind']==='GasCoin')return{'kind':'GasCoin'};if(a['$kind']==='Result')return{'kind':'Result','index':a['Result']};if(a['$kind']==='NestedResult')return{'kind':'NestedResult','index':a['NestedResult'][0x0],'resultIndex':a['NestedResult'][0x1]};if(a['$kind']==='Input')return b[a['Input']];throw new Error('Invalid\x20argument\x20'+Object['keys'](a));}export function transactionDataFromV1(a){return parse(TransactionDataSchema,{'version':0x2,'sender':a['sender']??null,'expiration':a['expiration']?'Epoch'in a['expiration']?{'Epoch':a['expiration']['Epoch']}:{'None':!![]}:null,'gasData':{'owner':a['gasConfig']['owner']??null,'budget':a['gasConfig']['budget']?.['toString']()??null,'price':a['gasConfig']['price']?.['toString']()??null,'payment':a['gasConfig']['payment']?.['map'](b=>({'digest':b['digest'],'objectId':b['objectId'],'version':b['version']['toString']()}))??null},'inputs':a['inputs']['map'](b=>{if(b['kind']==='Input'){if(is(NormalizedCallArg,b['value'])){const c=parse(NormalizedCallArg,b['value']);if(c['Object']){if(c['Object']['ImmOrOwned'])return{'Object':{'ImmOrOwnedObject':{'objectId':c['Object']['ImmOrOwned']['objectId'],'version':String(c['Object']['ImmOrOwned']['version']),'digest':c['Object']['ImmOrOwned']['digest']}}};if(c['Object']['Shared'])return{'Object':{'SharedObject':{'mutable':c['Object']['Shared']['mutable']??null,'initialSharedVersion':c['Object']['Shared']['initialSharedVersion'],'objectId':c['Object']['Shared']['objectId']}}};if(c['Object']['Receiving'])return{'Object':{'Receiving':{'digest':c['Object']['Receiving']['digest'],'version':String(c['Object']['Receiving']['version']),'objectId':c['Object']['Receiving']['objectId']}}};throw new Error('Invalid\x20object\x20input');}return{'Pure':{'bytes':toBase64(new Uint8Array(c['Pure']))}};}if(b['type']==='object')return{'UnresolvedObject':{'objectId':b['value']}};return{'UnresolvedPure':{'value':b['value']}};}throw new Error('Invalid\x20input');}),'commands':a['transactions']['map'](b=>{switch(b['kind']){case'MakeMoveVec':return{'MakeMoveVec':{'type':'Some'in b['type']?TypeTagSerializer['tagToString'](b['type']['Some']):null,'elements':b['objects']['map'](c=>parseV1TransactionArgument(c))}};case'MergeCoins':{return{'MergeCoins':{'destination':parseV1TransactionArgument(b['destination']),'sources':b['sources']['map'](c=>parseV1TransactionArgument(c))}};}case'MoveCall':{const [c,d,e]=b['target']['split']('::');return{'MoveCall':{'package':c,'module':d,'function':e,'typeArguments':b['typeArguments'],'arguments':b['arguments']['map'](f=>parseV1TransactionArgument(f))}};}case'Publish':{return{'Publish':{'modules':b['modules']['map'](f=>toBase64(Uint8Array['from'](f))),'dependencies':b['dependencies']}};}case'SplitCoins':{return{'SplitCoins':{'coin':parseV1TransactionArgument(b['coin']),'amounts':b['amounts']['map'](f=>parseV1TransactionArgument(f))}};}case'TransferObjects':{return{'TransferObjects':{'objects':b['objects']['map'](f=>parseV1TransactionArgument(f)),'address':parseV1TransactionArgument(b['address'])}};}case'Upgrade':{return{'Upgrade':{'modules':b['modules']['map'](f=>toBase64(Uint8Array['from'](f))),'dependencies':b['dependencies'],'package':b['packageId'],'ticket':parseV1TransactionArgument(b['ticket'])}};}}throw new Error('Unknown\x20transaction\x20'+Object['keys'](b));})});}function parseV1TransactionArgument(a){switch(a['kind']){case'GasCoin':{return{'GasCoin':!![]};}case'Result':return{'Result':a['index']};case'NestedResult':{return{'NestedResult':[a['index'],a['resultIndex']]};}case'Input':{return{'Input':a['index']};}}}

package/dist/esm/transactions/data/v2.d.ts

@@ -1,153 +0,0 @@
-import type { EnumInputShape } from "../../_deps/bcs/index.js";
-import type { GenericSchema, InferOutput } from "valibot";
-export declare const SerializedTransactionDataV2Schema: import("valibot").ObjectSchema<{
-    readonly version: import("valibot").LiteralSchema<2, undefined>;
-    readonly sender: import("valibot").NullishSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>, undefined>;
-    readonly expiration: import("valibot").NullishSchema<GenericSchema<EnumInputShape<{
-        None: true;
-        Epoch: string | number;
-    }>>, undefined>;
-    readonly gasData: import("valibot").ObjectSchema<{
-        readonly budget: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>, undefined>;
-        readonly price: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>, undefined>;
-        readonly owner: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>, undefined>;
-        readonly payment: import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-            readonly objectId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TransformAction<string, string>, import("valibot").CheckAction<string, undefined>]>;
-            readonly version: import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>]>], undefined>, import("valibot").CheckAction<string | number, "Invalid u64">]>;
-            readonly digest: import("valibot").StringSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>;
-    readonly inputs: import("valibot").ArraySchema<GenericSchema<EnumInputShape<{
-        Object: EnumInputShape<{
-            ImmOrOwnedObject: {
-                objectId: string;
-                version: string | number;
-                digest: string;
-            };
-            SharedObject: {
-                objectId: string;
-                initialSharedVersion: string | number;
-                mutable: boolean;
-            };
-            Receiving: {
-                objectId: string;
-                version: string | number;
-                digest: string;
-            };
-        }>;
-        Pure: {
-            bytes: string;
-        };
-        UnresolvedPure: {
-            value: unknown;
-        };
-        UnresolvedObject: {
-            objectId: string;
-            version?: string | number;
-            digest?: string;
-            initialSharedVersion?: string | number;
-            mutable?: boolean;
-        };
-    }>>, undefined>;
-    readonly commands: import("valibot").ArraySchema<GenericSchema<EnumInputShape<{
-        MoveCall: {
-            package: string;
-            module: string;
-            function: string;
-            typeArguments: string[];
-            arguments: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>[];
-        };
-        TransferObjects: {
-            objects: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>[];
-            address: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>;
-        };
-        SplitCoins: {
-            coin: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>;
-            amounts: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>[];
-        };
-        MergeCoins: {
-            destination: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>;
-            sources: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>[];
-        };
-        Publish: {
-            modules: string[];
-            dependencies: string[];
-        };
-        MakeMoveVec: {
-            type: string;
-            elements: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>[];
-        };
-        Upgrade: {
-            modules: string[];
-            dependencies: string[];
-            package: string;
-            ticket: EnumInputShape<{
-                GasCoin: true;
-                Input: number;
-                Result: number;
-                NestedResult: [number, number];
-            }>;
-        };
-        $Intent: {
-            name: string;
-            inputs: {
-                [x: string]: EnumInputShape<{
-                    GasCoin: true;
-                    Input: number;
-                    Result: number;
-                    NestedResult: [number, number];
-                }> | EnumInputShape<{
-                    GasCoin: true;
-                    Input: number;
-                    Result: number;
-                    NestedResult: [number, number];
-                }>[];
-            };
-            data: {
-                [x: string]: unknown;
-            };
-        };
-    }>>, undefined>;
-    readonly digest: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-export type SerializedTransactionDataV2 = InferOutput<typeof SerializedTransactionDataV2Schema>;

package/dist/esm/transactions/data/v2.js

@@ -1 +0,0 @@
-import{array,boolean,integer,literal,nullable,nullish,number,object,optional,pipe,record,string,tuple,union,unknown}from'valibot';import{BCSBytes,JsonU64,ObjectID,ObjectRefSchema,WowAddress}from'./internal.js';function enumUnion(a){return union(Object['entries'](a)['map'](([b,c])=>object({[b]:c})));}const Argument=enumUnion({'GasCoin':literal(!![]),'Input':pipe(number(),integer()),'Result':pipe(number(),integer()),'NestedResult':tuple([pipe(number(),integer()),pipe(number(),integer())])}),GasData=object({'budget':nullable(JsonU64),'price':nullable(JsonU64),'owner':nullable(WowAddress),'payment':nullable(array(ObjectRefSchema))}),ProgrammableMoveCall=object({'package':ObjectID,'module':string(),'function':string(),'typeArguments':array(string()),'arguments':array(Argument)}),$Intent=object({'name':string(),'inputs':record(string(),union([Argument,array(Argument)])),'data':record(string(),unknown())}),Command=enumUnion({'MoveCall':ProgrammableMoveCall,'TransferObjects':object({'objects':array(Argument),'address':Argument}),'SplitCoins':object({'coin':Argument,'amounts':array(Argument)}),'MergeCoins':object({'destination':Argument,'sources':array(Argument)}),'Publish':object({'modules':array(BCSBytes),'dependencies':array(ObjectID)}),'MakeMoveVec':object({'type':nullable(string()),'elements':array(Argument)}),'Upgrade':object({'modules':array(BCSBytes),'dependencies':array(ObjectID),'package':ObjectID,'ticket':Argument}),'$Intent':$Intent}),ObjectArg=enumUnion({'ImmOrOwnedObject':ObjectRefSchema,'SharedObject':object({'objectId':ObjectID,'initialSharedVersion':JsonU64,'mutable':boolean()}),'Receiving':ObjectRefSchema}),CallArg=enumUnion({'Object':ObjectArg,'Pure':object({'bytes':BCSBytes}),'UnresolvedPure':object({'value':unknown()}),'UnresolvedObject':object({'objectId':ObjectID,'version':optional(nullable(JsonU64)),'digest':optional(nullable(string())),'initialSharedVersion':optional(nullable(JsonU64)),'mutable':optional(nullable(boolean()))})}),TransactionExpiration=enumUnion({'None':literal(!![]),'Epoch':JsonU64});export const SerializedTransactionDataV2Schema=object({'version':literal(0x2),'sender':nullish(WowAddress),'expiration':nullish(TransactionExpiration),'gasData':GasData,'inputs':array(CallArg),'commands':array(Command),'digest':optional(nullable(string()))});

package/dist/esm/transactions/executor/caching.d.ts

@@ -1,27 +0,0 @@
-import { bcs } from "../../bcs/index.js";
-import type { ExecuteTransactionBlockParams, WowClient } from "../../client/index.js";
-import type { Signer } from "../../cryptography/keypair.js";
-import type { BuildTransactionOptions } from "../resolve.js";
-import type { ObjectCacheOptions } from "../ObjectCache.js";
-import { ObjectCache } from "../ObjectCache.js";
-import type { Transaction } from "../Transaction.js";
-export declare class CachingTransactionExecutor {
-    #private;
-    cache: ObjectCache;
-    constructor({ client, ...options }: ObjectCacheOptions & {
-        client: WowClient;
-    });
-    reset(): Promise<void>;
-    buildTransaction({ transaction, ...options }: {
-        transaction: Transaction;
-    } & BuildTransactionOptions): Promise<Uint8Array<ArrayBuffer>>;
-    executeTransaction({ transaction, options, ...input }: {
-        transaction: Transaction | Uint8Array;
-    } & Omit<ExecuteTransactionBlockParams, "transactionBlock">): Promise<import("../../index.js").WowTransactionBlockResponse>;
-    signAndExecuteTransaction({ options, transaction, ...input }: {
-        transaction: Transaction;
-        signer: Signer;
-    } & Omit<ExecuteTransactionBlockParams, "transactionBlock" | "signature">): Promise<import("../../index.js").WowTransactionBlockResponse>;
-    applyEffects(effects: typeof bcs.TransactionEffects.$inferType): Promise<void>;
-    waitForLastTransaction(): Promise<void>;
-}

package/dist/esm/transactions/executor/caching.js

@@ -1 +0,0 @@
-import{bcs}from'../../bcs/index.js';import{ObjectCache}from'../ObjectCache.js';import{isTransaction}from'../Transaction.js';export class CachingTransactionExecutor{#client;#lastDigest=null;['cache'];constructor({client:a,...b}){this.#client=a,this['cache']=new ObjectCache(b);}async['reset'](){await Promise['all']([this['cache']['clearOwnedObjects'](),this['cache']['clearCustom'](),this['waitForLastTransaction']()]);}async['buildTransaction']({transaction:a,...b}){return a['addBuildPlugin'](this['cache']['asPlugin']()),a['build']({'client':this.#client,...b});}async['executeTransaction']({transaction:a,options:b,...c}){const d=isTransaction(a)?await this['buildTransaction']({'transaction':a}):a,e=await this.#client['executeTransactionBlock']({...c,'transactionBlock':d,'options':{...b,'showRawEffects':!![]}});if(e['rawEffects']){const f=bcs['TransactionEffects']['parse'](Uint8Array['from'](e['rawEffects']));await this['applyEffects'](f);}return e;}async['signAndExecuteTransaction']({options:a,transaction:b,...c}){b['setSenderIfNotSet'](c['signer']['toWAddress']());const d=await this['buildTransaction']({'transaction':b}),{signature:e}=await c['signer']['signTransaction'](d),f=await this['executeTransaction']({'transaction':d,'signature':e,'options':a});return f;}async['applyEffects'](a){this.#lastDigest=a['V2']?.['transactionDigest']??null,await this['cache']['applyEffects'](a);}async['waitForLastTransaction'](){this.#lastDigest&&(await this.#client['waitForTransaction']({'digest':this.#lastDigest}),this.#lastDigest=null);}}

package/dist/esm/transactions/executor/parallel.d.ts

@@ -1,26 +0,0 @@
-import type { WowClient, WowTransactionBlockResponse, WowTransactionBlockResponseOptions } from "../../client/index.js";
-import type { Signer } from "../../cryptography/index.js";
-import type { ObjectCacheOptions } from "../ObjectCache.js";
-import { Transaction } from "../Transaction.js";
-export interface ParallelTransactionExecutorOptions extends Omit<ObjectCacheOptions, "address"> {
-    client: WowClient;
-    signer: Signer;
-    coinBatchSize?: number;
-    initialCoinBalance?: bigint;
-    minimumCoinBalance?: bigint;
-    defaultGasBudget?: bigint;
-    epochBoundaryWindow?: number;
-    maxPoolSize?: number;
-    sourceCoins?: string[];
-}
-export declare class ParallelTransactionExecutor {
-    #private;
-    constructor(options: ParallelTransactionExecutorOptions);
-    resetCache(): Promise<void>;
-    waitForLastTransaction(): Promise<void>;
-    executeTransaction(transaction: Transaction, options?: WowTransactionBlockResponseOptions, additionalSignatures?: string[]): Promise<{
-        digest: string;
-        effects: string;
-        data: WowTransactionBlockResponse;
-    }>;
-}