wowok 2.1.40 → 2.1.41

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

@@ -1,469 +1 @@
-import { fromBase64, toBase64 } from "@mysten/bcs";
-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"),
-    }),
-]);
-const TransactionExpiration = union([
-    object({ Epoch: pipe(number(), integer()) }),
-    object({ None: nullable(literal(true)) }),
-]);
-const StringEncodedBigint = pipe(union([number(), string(), bigint()]), check((val) => {
-    if (!["string", "number", "bigint"].includes(typeof val))
-        return false;
-    try {
-        BigInt(val);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}));
-export const TypeTag = union([
-    object({ bool: nullable(literal(true)) }),
-    object({ u8: nullable(literal(true)) }),
-    object({ u64: nullable(literal(true)) }),
-    object({ u128: nullable(literal(true)) }),
-    object({ address: nullable(literal(true)) }),
-    object({ signer: nullable(literal(true)) }),
-    object({ vector: lazy(() => TypeTag) }),
-    object({ struct: lazy(() => StructTag) }),
-    object({ u16: nullable(literal(true)) }),
-    object({ u32: nullable(literal(true)) }),
-    object({ u256: nullable(literal(true)) }),
-]);
-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()),
-});
-const 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((target) => target.split("::").length === 3)),
-    typeArguments: array(string()),
-    arguments: array(TransactionArgument),
-});
-const TransferObjectsTransaction = object({
-    kind: literal("TransferObjects"),
-    objects: array(TransactionArgument),
-    address: TransactionArgument,
-});
-const SplitCoinsTransaction = object({
-    kind: literal("SplitCoins"),
-    coin: TransactionArgument,
-    amounts: array(TransactionArgument),
-});
-const MergeCoinsTransaction = object({
-    kind: literal("MergeCoins"),
-    destination: TransactionArgument,
-    sources: array(TransactionArgument),
-});
-const MakeMoveVecTransaction = object({
-    kind: literal("MakeMoveVec"),
-    type: union([
-        object({ Some: TypeTag }),
-        object({ None: nullable(literal(true)) }),
-    ]),
-    objects: array(TransactionArgument),
-});
-const PublishTransaction = object({
-    kind: literal("Publish"),
-    modules: array(array(pipe(number(), integer()))),
-    dependencies: array(string()),
-});
-const UpgradeTransaction = object({
-    kind: literal("Upgrade"),
-    modules: array(array(pipe(number(), integer()))),
-    dependencies: array(string()),
-    packageId: string(),
-    ticket: TransactionArgument,
-});
-const TransactionTypes = [
-    MoveCallTransaction,
-    TransferObjectsTransaction,
-    SplitCoinsTransaction,
-    MergeCoinsTransaction,
-    PublishTransaction,
-    UpgradeTransaction,
-    MakeMoveVecTransaction,
-];
-const TransactionType = union([...TransactionTypes]);
-export const SerializedTransactionDataV1 = object({
-    version: literal(1),
-    sender: optional(string()),
-    expiration: nullish(TransactionExpiration),
-    gasConfig: GasConfig,
-    inputs: array(TransactionInput),
-    transactions: array(TransactionType),
-});
-export function serializeV1TransactionData(transactionData) {
-    const inputs = transactionData.inputs.map((input, index) => {
-        if (input.Object) {
-            return {
-                kind: "Input",
-                index,
-                value: {
-                    Object: input.Object.ImmOrOwnedObject
-                        ? {
-                            ImmOrOwned: input.Object.ImmOrOwnedObject,
-                        }
-                        : input.Object.Receiving
-                            ? {
-                                Receiving: {
-                                    digest: input.Object.Receiving
-                                        .digest,
-                                    version: input.Object.Receiving.version,
-                                    objectId: input.Object.Receiving.objectId,
-                                },
-                            }
-                            : {
-                                Shared: {
-                                    mutable: input.Object.SharedObject
-                                        .mutable,
-                                    initialSharedVersion: input.Object.SharedObject
-                                        .initialSharedVersion,
-                                    objectId: input.Object.SharedObject
-                                        .objectId,
-                                },
-                            },
-                },
-                type: "object",
-            };
-        }
-        if (input.Pure) {
-            return {
-                kind: "Input",
-                index,
-                value: {
-                    Pure: Array.from(fromBase64(input.Pure.bytes)),
-                },
-                type: "pure",
-            };
-        }
-        if (input.UnresolvedPure) {
-            return {
-                kind: "Input",
-                type: "pure",
-                index,
-                value: input.UnresolvedPure.value,
-            };
-        }
-        if (input.UnresolvedObject) {
-            return {
-                kind: "Input",
-                type: "object",
-                index,
-                value: input.UnresolvedObject.objectId,
-            };
-        }
-        throw new Error("Invalid input");
-    });
-    return {
-        version: 1,
-        sender: transactionData.sender ?? undefined,
-        expiration: transactionData.expiration?.$kind === "Epoch"
-            ? { Epoch: Number(transactionData.expiration.Epoch) }
-            : transactionData.expiration
-                ? { None: true }
-                : null,
-        gasConfig: {
-            owner: transactionData.gasData.owner ?? undefined,
-            budget: transactionData.gasData.budget ?? undefined,
-            price: transactionData.gasData.price ?? undefined,
-            payment: transactionData.gasData.payment ?? undefined,
-        },
-        inputs,
-        transactions: transactionData.commands.map((command) => {
-            if (command.MakeMoveVec) {
-                return {
-                    kind: "MakeMoveVec",
-                    type: command.MakeMoveVec.type === null
-                        ? { None: true }
-                        : {
-                            Some: TypeTagSerializer.parseFromStr(command.MakeMoveVec.type),
-                        },
-                    objects: command.MakeMoveVec.elements.map((arg) => convertTransactionArgument(arg, inputs)),
-                };
-            }
-            if (command.MergeCoins) {
-                return {
-                    kind: "MergeCoins",
-                    destination: convertTransactionArgument(command.MergeCoins.destination, inputs),
-                    sources: command.MergeCoins.sources.map((arg) => convertTransactionArgument(arg, inputs)),
-                };
-            }
-            if (command.MoveCall) {
-                return {
-                    kind: "MoveCall",
-                    target: `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`,
-                    typeArguments: command.MoveCall.typeArguments,
-                    arguments: command.MoveCall.arguments.map((arg) => convertTransactionArgument(arg, inputs)),
-                };
-            }
-            if (command.Publish) {
-                return {
-                    kind: "Publish",
-                    modules: command.Publish.modules.map((mod) => Array.from(fromBase64(mod))),
-                    dependencies: command.Publish.dependencies,
-                };
-            }
-            if (command.SplitCoins) {
-                return {
-                    kind: "SplitCoins",
-                    coin: convertTransactionArgument(command.SplitCoins.coin, inputs),
-                    amounts: command.SplitCoins.amounts.map((arg) => convertTransactionArgument(arg, inputs)),
-                };
-            }
-            if (command.TransferObjects) {
-                return {
-                    kind: "TransferObjects",
-                    objects: command.TransferObjects.objects.map((arg) => convertTransactionArgument(arg, inputs)),
-                    address: convertTransactionArgument(command.TransferObjects.address, inputs),
-                };
-            }
-            if (command.Upgrade) {
-                return {
-                    kind: "Upgrade",
-                    modules: command.Upgrade.modules.map((mod) => Array.from(fromBase64(mod))),
-                    dependencies: command.Upgrade.dependencies,
-                    packageId: command.Upgrade.package,
-                    ticket: convertTransactionArgument(command.Upgrade.ticket, inputs),
-                };
-            }
-            throw new Error(`Unknown transaction ${Object.keys(command)}`);
-        }),
-    };
-}
-function convertTransactionArgument(arg, inputs) {
-    if (arg.$kind === "GasCoin") {
-        return { kind: "GasCoin" };
-    }
-    if (arg.$kind === "Result") {
-        return { kind: "Result", index: arg.Result };
-    }
-    if (arg.$kind === "NestedResult") {
-        return {
-            kind: "NestedResult",
-            index: arg.NestedResult[0],
-            resultIndex: arg.NestedResult[1],
-        };
-    }
-    if (arg.$kind === "Input") {
-        return inputs[arg.Input];
-    }
-    throw new Error(`Invalid argument ${Object.keys(arg)}`);
-}
-export function transactionDataFromV1(data) {
-    return parse(TransactionDataSchema, {
-        version: 2,
-        sender: data.sender ?? null,
-        expiration: data.expiration
-            ? "Epoch" in data.expiration
-                ? { Epoch: data.expiration.Epoch }
-                : { None: true }
-            : null,
-        gasData: {
-            owner: data.gasConfig.owner ?? null,
-            budget: data.gasConfig.budget?.toString() ?? null,
-            price: data.gasConfig.price?.toString() ?? null,
-            payment: data.gasConfig.payment?.map((ref) => ({
-                digest: ref.digest,
-                objectId: ref.objectId,
-                version: ref.version.toString(),
-            })) ?? null,
-        },
-        inputs: data.inputs.map((input) => {
-            if (input.kind === "Input") {
-                if (is(NormalizedCallArg, input.value)) {
-                    const value = parse(NormalizedCallArg, input.value);
-                    if (value.Object) {
-                        if (value.Object.ImmOrOwned) {
-                            return {
-                                Object: {
-                                    ImmOrOwnedObject: {
-                                        objectId: value.Object.ImmOrOwned.objectId,
-                                        version: String(value.Object.ImmOrOwned.version),
-                                        digest: value.Object.ImmOrOwned.digest,
-                                    },
-                                },
-                            };
-                        }
-                        if (value.Object.Shared) {
-                            return {
-                                Object: {
-                                    SharedObject: {
-                                        mutable: value.Object.Shared.mutable ?? null,
-                                        initialSharedVersion: value.Object.Shared
-                                            .initialSharedVersion,
-                                        objectId: value.Object.Shared.objectId,
-                                    },
-                                },
-                            };
-                        }
-                        if (value.Object.Receiving) {
-                            return {
-                                Object: {
-                                    Receiving: {
-                                        digest: value.Object.Receiving.digest,
-                                        version: String(value.Object.Receiving.version),
-                                        objectId: value.Object.Receiving.objectId,
-                                    },
-                                },
-                            };
-                        }
-                        throw new Error("Invalid object input");
-                    }
-                    return {
-                        Pure: {
-                            bytes: toBase64(new Uint8Array(value.Pure)),
-                        },
-                    };
-                }
-                if (input.type === "object") {
-                    return {
-                        UnresolvedObject: {
-                            objectId: input.value,
-                        },
-                    };
-                }
-                return {
-                    UnresolvedPure: {
-                        value: input.value,
-                    },
-                };
-            }
-            throw new Error("Invalid input");
-        }),
-        commands: data.transactions.map((transaction) => {
-            switch (transaction.kind) {
-                case "MakeMoveVec":
-                    return {
-                        MakeMoveVec: {
-                            type: "Some" in transaction.type
-                                ? TypeTagSerializer.tagToString(transaction.type.Some)
-                                : null,
-                            elements: transaction.objects.map((arg) => parseV1TransactionArgument(arg)),
-                        },
-                    };
-                case "MergeCoins": {
-                    return {
-                        MergeCoins: {
-                            destination: parseV1TransactionArgument(transaction.destination),
-                            sources: transaction.sources.map((arg) => parseV1TransactionArgument(arg)),
-                        },
-                    };
-                }
-                case "MoveCall": {
-                    const [pkg, mod, fn] = transaction.target.split("::");
-                    return {
-                        MoveCall: {
-                            package: pkg,
-                            module: mod,
-                            function: fn,
-                            typeArguments: transaction.typeArguments,
-                            arguments: transaction.arguments.map((arg) => parseV1TransactionArgument(arg)),
-                        },
-                    };
-                }
-                case "Publish": {
-                    return {
-                        Publish: {
-                            modules: transaction.modules.map((mod) => toBase64(Uint8Array.from(mod))),
-                            dependencies: transaction.dependencies,
-                        },
-                    };
-                }
-                case "SplitCoins": {
-                    return {
-                        SplitCoins: {
-                            coin: parseV1TransactionArgument(transaction.coin),
-                            amounts: transaction.amounts.map((arg) => parseV1TransactionArgument(arg)),
-                        },
-                    };
-                }
-                case "TransferObjects": {
-                    return {
-                        TransferObjects: {
-                            objects: transaction.objects.map((arg) => parseV1TransactionArgument(arg)),
-                            address: parseV1TransactionArgument(transaction.address),
-                        },
-                    };
-                }
-                case "Upgrade": {
-                    return {
-                        Upgrade: {
-                            modules: transaction.modules.map((mod) => toBase64(Uint8Array.from(mod))),
-                            dependencies: transaction.dependencies,
-                            package: transaction.packageId,
-                            ticket: parseV1TransactionArgument(transaction.ticket),
-                        },
-                    };
-                }
-            }
-            throw new Error(`Unknown transaction ${Object.keys(transaction)}`);
-        }),
-    });
-}
-function parseV1TransactionArgument(arg) {
-    switch (arg.kind) {
-        case "GasCoin": {
-            return { GasCoin: true };
-        }
-        case "Result":
-            return { Result: arg.index };
-        case "NestedResult": {
-            return { NestedResult: [arg.index, arg.resultIndex] };
-        }
-        case "Input": {
-            return { Input: arg.index };
-        }
-    }
-}
+import{fromBase64,toBase64}from'@mysten/bcs';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.js

@@ -1,97 +1 @@
-import { array, boolean, integer, literal, nullable, nullish, number, object, optional, pipe, record, string, tuple, union, unknown, } from "valibot";
-import { BCSBytes, JsonU64, ObjectID, ObjectRefSchema, SuiAddress, } from "./internal.js";
-function enumUnion(options) {
-    return union(Object.entries(options).map(([key, value]) => object({ [key]: value })));
-}
-const Argument = enumUnion({
-    GasCoin: literal(true),
-    Input: pipe(number(), integer()),
-    Result: pipe(number(), integer()),
-    NestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())]),
-});
-const GasData = object({
-    budget: nullable(JsonU64),
-    price: nullable(JsonU64),
-    owner: nullable(SuiAddress),
-    payment: nullable(array(ObjectRefSchema)),
-});
-const ProgrammableMoveCall = object({
-    package: ObjectID,
-    module: string(),
-    function: string(),
-    typeArguments: array(string()),
-    arguments: array(Argument),
-});
-const $Intent = object({
-    name: string(),
-    inputs: record(string(), union([Argument, array(Argument)])),
-    data: record(string(), unknown()),
-});
-const 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,
-});
-const ObjectArg = enumUnion({
-    ImmOrOwnedObject: ObjectRefSchema,
-    SharedObject: object({
-        objectId: ObjectID,
-        initialSharedVersion: JsonU64,
-        mutable: boolean(),
-    }),
-    Receiving: ObjectRefSchema,
-});
-const 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())),
-    }),
-});
-const TransactionExpiration = enumUnion({
-    None: literal(true),
-    Epoch: JsonU64,
-});
-export const SerializedTransactionDataV2Schema = object({
-    version: literal(2),
-    sender: nullish(SuiAddress),
-    expiration: nullish(TransactionExpiration),
-    gasData: GasData,
-    inputs: array(CallArg),
-    commands: array(Command),
-    digest: optional(nullable(string())),
-});
+import{array,boolean,integer,literal,nullable,nullish,number,object,optional,pipe,record,string,tuple,union,unknown}from'valibot';import{BCSBytes,JsonU64,ObjectID,ObjectRefSchema,SuiAddress}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(SuiAddress),'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(SuiAddress),'expiration':nullish(TransactionExpiration),'gasData':GasData,'inputs':array(CallArg),'commands':array(Command),'digest':optional(nullable(string()))});

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

@@ -1,65 +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, ...options }) {
-        this.#client = client;
-        this.cache = new ObjectCache(options);
-    }
-    async reset() {
-        await Promise.all([
-            this.cache.clearOwnedObjects(),
-            this.cache.clearCustom(),
-            this.waitForLastTransaction(),
-        ]);
-    }
-    async buildTransaction({ transaction, ...options }) {
-        transaction.addBuildPlugin(this.cache.asPlugin());
-        return transaction.build({
-            client: this.#client,
-            ...options,
-        });
-    }
-    async executeTransaction({ transaction, options, ...input }) {
-        const bytes = isTransaction(transaction)
-            ? await this.buildTransaction({ transaction })
-            : transaction;
-        const results = await this.#client.executeTransactionBlock({
-            ...input,
-            transactionBlock: bytes,
-            options: {
-                ...options,
-                showRawEffects: true,
-            },
-        });
-        if (results.rawEffects) {
-            const effects = bcs.TransactionEffects.parse(Uint8Array.from(results.rawEffects));
-            await this.applyEffects(effects);
-        }
-        return results;
-    }
-    async signAndExecuteTransaction({ options, transaction, ...input }) {
-        transaction.setSenderIfNotSet(input.signer.toWAddress());
-        const bytes = await this.buildTransaction({ transaction });
-        const { signature } = await input.signer.signTransaction(bytes);
-        const results = await this.executeTransaction({
-            transaction: bytes,
-            signature,
-            options,
-        });
-        return results;
-    }
-    async applyEffects(effects) {
-        this.#lastDigest = effects.V2?.transactionDigest ?? null;
-        await this.cache.applyEffects(effects);
-    }
-    async waitForLastTransaction() {
-        if (this.#lastDigest) {
-            await this.#client.waitForTransaction({ digest: this.#lastDigest });
-            this.#lastDigest = null;
-        }
-    }
-}
+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);}}