@wowok/wowok 2.2.11

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

@@ -0,0 +1 @@
+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/cjs/transactions/data/v1.d.ts

@@ -0,0 +1,312 @@
+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/cjs/transactions/data/v1.js

@@ -0,0 +1 @@
+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/cjs/transactions/data/v2.d.ts

@@ -0,0 +1,153 @@
+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/cjs/transactions/data/v2.js

@@ -0,0 +1 @@
+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/cjs/transactions/executor/caching.d.ts

@@ -0,0 +1,27 @@
+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("../../client/index.js").WowTransactionBlockResponse>;
+    signAndExecuteTransaction({ options, transaction, ...input }: {
+        transaction: Transaction;
+        signer: Signer;
+    } & Omit<ExecuteTransactionBlockParams, "transactionBlock" | "signature">): Promise<import("../../client/index.js").WowTransactionBlockResponse>;
+    applyEffects(effects: typeof bcs.TransactionEffects.$inferType): Promise<void>;
+    waitForLastTransaction(): Promise<void>;
+}

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

@@ -0,0 +1 @@
+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/cjs/transactions/executor/parallel.d.ts

@@ -0,0 +1,26 @@
+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;
+    }>;
+}