wowok 2.1.39 → 2.1.41

package/dist/esm/jsonRpc/core.js

@@ -1,590 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-import { fromBase64 } from "@mysten/bcs";
-import { bcs } from "../bcs/index.js";
-import { Transaction } from "../transactions/Transaction.js";
-import { jsonRpcClientResolveTransactionPlugin } from "./json-rpc-resolver.js";
-import { TransactionDataBuilder } from "../transactions/TransactionData.js";
-import { chunk } from "@mysten/utils";
-import { normalizeWowAddress } from "../utils/sui-types.js";
-import { Experimental_CoreClient } from "../experimental/core.js";
-import { ObjectError } from "../experimental/errors.js";
-import { parseTransactionBcs, parseTransactionEffectsBcs, } from "../experimental/index.js";
-export class JSONRpcCoreClient extends Experimental_CoreClient {
-    #jsonRpcClient;
-    constructor({ jsonRpcClient }) {
-        super({ network: jsonRpcClient.network, base: jsonRpcClient });
-        this.#jsonRpcClient = jsonRpcClient;
-    }
-    async getObjects(options) {
-        const batches = chunk(options.objectIds, 50);
-        const results = [];
-        for (const batch of batches) {
-            const objects = await this.#jsonRpcClient.multiGetObjects({
-                ids: batch,
-                options: {
-                    showOwner: true,
-                    showType: true,
-                    showBcs: true,
-                    showPreviousTransaction: true,
-                },
-                signal: options.signal,
-            });
-            for (const [idx, object] of objects.entries()) {
-                if (object.error) {
-                    results.push(ObjectError.fromResponse(object.error, batch[idx]));
-                }
-                else {
-                    results.push(parseObject(object.data));
-                }
-            }
-        }
-        return {
-            objects: results,
-        };
-    }
-    async getOwnedObjects(options) {
-        const objects = await this.#jsonRpcClient.getOwnedObjects({
-            owner: options.address,
-            limit: options.limit,
-            cursor: options.cursor,
-            options: {
-                showOwner: true,
-                showType: true,
-                showBcs: true,
-                showPreviousTransaction: true,
-            },
-            filter: options.type ? { StructType: options.type } : null,
-            signal: options.signal,
-        });
-        return {
-            objects: objects.data.map((result) => {
-                if (result.error) {
-                    throw ObjectError.fromResponse(result.error);
-                }
-                return parseObject(result.data);
-            }),
-            hasNextPage: objects.hasNextPage,
-            cursor: objects.nextCursor ?? null,
-        };
-    }
-    async getCoins(options) {
-        const coins = await this.#jsonRpcClient.getCoins({
-            owner: options.address,
-            coinType: options.coinType,
-            limit: options.limit,
-            cursor: options.cursor,
-            signal: options.signal,
-        });
-        return {
-            objects: coins.data.map((coin) => {
-                return {
-                    id: coin.coinObjectId,
-                    version: coin.version,
-                    digest: coin.digest,
-                    balance: coin.balance,
-                    type: `0x2::coin::Coin<${coin.coinType}>`,
-                    content: Promise.resolve(Coin.serialize({
-                        id: coin.coinObjectId,
-                        balance: {
-                            value: coin.balance,
-                        },
-                    }).toBytes()),
-                    owner: {
-                        $kind: "ObjectOwner",
-                        ObjectOwner: options.address,
-                    },
-                    previousTransaction: coin.previousTransaction,
-                };
-            }),
-            hasNextPage: coins.hasNextPage,
-            cursor: coins.nextCursor ?? null,
-        };
-    }
-    async getBalance(options) {
-        const balance = await this.#jsonRpcClient.getBalance({
-            owner: options.address,
-            coinType: options.coinType,
-            signal: options.signal,
-        });
-        return {
-            balance: {
-                coinType: balance.coinType,
-                balance: balance.totalBalance,
-            },
-        };
-    }
-    async getAllBalances(options) {
-        const balances = await this.#jsonRpcClient.getAllBalances({
-            owner: options.address,
-            signal: options.signal,
-        });
-        return {
-            balances: balances.map((balance) => ({
-                coinType: balance.coinType,
-                balance: balance.totalBalance,
-            })),
-            hasNextPage: false,
-            cursor: null,
-        };
-    }
-    async getTransaction(options) {
-        const transaction = await this.#jsonRpcClient.getTransactionBlock({
-            digest: options.digest,
-            options: {
-                showRawInput: true,
-                showObjectChanges: true,
-                showRawEffects: true,
-                showEvents: true,
-                showEffects: true,
-                showBalanceChanges: true,
-            },
-            signal: options.signal,
-        });
-        return {
-            transaction: parseTransaction(transaction),
-        };
-    }
-    async executeTransaction(options) {
-        const transaction = await this.#jsonRpcClient.executeTransactionBlock({
-            transactionBlock: options.transaction,
-            signature: options.signatures,
-            options: {
-                showRawEffects: true,
-                showEvents: true,
-                showObjectChanges: true,
-                showRawInput: true,
-                showEffects: true,
-                showBalanceChanges: true,
-            },
-            signal: options.signal,
-        });
-        return {
-            transaction: parseTransaction(transaction),
-        };
-    }
-    async dryRunTransaction(options) {
-        const tx = Transaction.from(options.transaction);
-        const result = await this.#jsonRpcClient.dryRunTransactionBlock({
-            transactionBlock: options.transaction,
-            signal: options.signal,
-        });
-        const { effects, objectTypes } = parseTransactionEffectsJson({
-            effects: result.effects,
-            objectChanges: result.objectChanges,
-        });
-        return {
-            transaction: {
-                digest: await tx.getDigest(),
-                epoch: null,
-                effects,
-                objectTypes: Promise.resolve(objectTypes),
-                signatures: [],
-                transaction: parseTransactionBcs(options.transaction),
-                balanceChanges: result.balanceChanges.map((change) => ({
-                    coinType: change.coinType,
-                    address: parseOwnerAddress(change.owner),
-                    amount: change.amount,
-                })),
-            },
-        };
-    }
-    async getReferenceGasPrice(options) {
-        const referenceGasPrice = await this.#jsonRpcClient.getReferenceGasPrice({
-            signal: options?.signal,
-        });
-        return {
-            referenceGasPrice: String(referenceGasPrice),
-        };
-    }
-    async getDynamicFields(options) {
-        const dynamicFields = await this.#jsonRpcClient.getDynamicFields({
-            parentId: options.parentId,
-            limit: options.limit,
-            cursor: options.cursor,
-        });
-        return {
-            dynamicFields: dynamicFields.data.map((dynamicField) => {
-                return {
-                    id: dynamicField.objectId,
-                    type: dynamicField.objectType,
-                    name: {
-                        type: dynamicField.name.type,
-                        bcs: fromBase64(dynamicField.bcsName),
-                    },
-                };
-            }),
-            hasNextPage: dynamicFields.hasNextPage,
-            cursor: dynamicFields.nextCursor,
-        };
-    }
-    resolveTransactionPlugin() {
-        return jsonRpcClientResolveTransactionPlugin(this.#jsonRpcClient);
-    }
-    async getMoveFunction(options) {
-        const result = await this.#jsonRpcClient.getNormalizedMoveFunction({
-            package: options.packageId,
-            module: options.moduleName,
-            function: options.name,
-        });
-        return {
-            function: {
-                packageId: normalizeWowAddress(options.packageId),
-                moduleName: options.moduleName,
-                name: options.name,
-                visibility: parseVisibility(result.visibility),
-                isEntry: result.isEntry,
-                typeParameters: result.typeParameters.map((abilities) => ({
-                    isPhantom: false,
-                    constraints: parseAbilities(abilities),
-                })),
-                parameters: result.parameters.map((param) => parseNormalizedSuiMoveType(param)),
-                returns: result.return.map((ret) => parseNormalizedSuiMoveType(ret)),
-            },
-        };
-    }
-}
-function parseObject(object) {
-    return {
-        id: object.objectId,
-        version: object.version,
-        digest: object.digest,
-        type: object.type,
-        content: Promise.resolve(object.bcs?.dataType === "moveObject"
-            ? fromBase64(object.bcs.bcsBytes)
-            : new Uint8Array()),
-        owner: parseOwner(object.owner),
-        previousTransaction: object.previousTransaction ?? null,
-    };
-}
-function parseOwner(owner) {
-    if (owner === "Immutable") {
-        return {
-            $kind: "Immutable",
-            Immutable: true,
-        };
-    }
-    if ("ConsensusAddressOwner" in owner) {
-        return {
-            $kind: "ConsensusAddressOwner",
-            ConsensusAddressOwner: {
-                owner: owner.ConsensusAddressOwner.owner,
-                startVersion: owner.ConsensusAddressOwner.start_version,
-            },
-        };
-    }
-    if ("AddressOwner" in owner) {
-        return {
-            $kind: "AddressOwner",
-            AddressOwner: owner.AddressOwner,
-        };
-    }
-    if ("ObjectOwner" in owner) {
-        return {
-            $kind: "ObjectOwner",
-            ObjectOwner: owner.ObjectOwner,
-        };
-    }
-    if ("Shared" in owner) {
-        return {
-            $kind: "Shared",
-            Shared: {
-                initialSharedVersion: owner.Shared.initial_shared_version,
-            },
-        };
-    }
-    throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
-}
-function parseOwnerAddress(owner) {
-    if (owner === "Immutable") {
-        return null;
-    }
-    if ("ConsensusAddressOwner" in owner) {
-        return owner.ConsensusAddressOwner.owner;
-    }
-    if ("AddressOwner" in owner) {
-        return owner.AddressOwner;
-    }
-    if ("ObjectOwner" in owner) {
-        return owner.ObjectOwner;
-    }
-    if ("Shared" in owner) {
-        return null;
-    }
-    throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
-}
-function parseTransaction(transaction) {
-    const parsedTx = bcs.SenderSignedData.parse(fromBase64(transaction.rawTransaction))[0];
-    const objectTypes = {};
-    transaction.objectChanges?.forEach((change) => {
-        if (change.type !== "published") {
-            objectTypes[change.objectId] = change.objectType;
-        }
-    });
-    const bytes = bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes();
-    const data = TransactionDataBuilder.restore({
-        version: 2,
-        sender: parsedTx.intentMessage.value.V1.sender,
-        expiration: parsedTx.intentMessage.value.V1.expiration,
-        gasData: parsedTx.intentMessage.value.V1.gasData,
-        inputs: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction
-            .inputs,
-        commands: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction
-            .commands,
-    });
-    return {
-        digest: transaction.digest,
-        epoch: transaction.effects?.executedEpoch ?? null,
-        effects: parseTransactionEffectsBcs(new Uint8Array(transaction.rawEffects)),
-        objectTypes: Promise.resolve(objectTypes),
-        transaction: {
-            ...data,
-            bcs: bytes,
-        },
-        signatures: parsedTx.txSignatures,
-        balanceChanges: transaction.balanceChanges?.map((change) => ({
-            coinType: change.coinType,
-            address: parseOwnerAddress(change.owner),
-            amount: change.amount,
-        })) ?? [],
-    };
-}
-function parseTransactionEffectsJson({ bytes, effects, objectChanges, }) {
-    const changedObjects = [];
-    const unchangedConsensusObjects = [];
-    const objectTypes = {};
-    objectChanges?.forEach((change) => {
-        switch (change.type) {
-            case "published":
-                changedObjects.push({
-                    id: change.packageId,
-                    inputState: "DoesNotExist",
-                    inputVersion: null,
-                    inputDigest: null,
-                    inputOwner: null,
-                    outputState: "PackageWrite",
-                    outputVersion: change.version,
-                    outputDigest: change.digest,
-                    outputOwner: null,
-                    idOperation: "Created",
-                });
-                break;
-            case "transferred":
-                changedObjects.push({
-                    id: change.objectId,
-                    inputState: "Exists",
-                    inputVersion: change.version,
-                    inputDigest: change.digest,
-                    inputOwner: {
-                        $kind: "AddressOwner",
-                        AddressOwner: change.sender,
-                    },
-                    outputState: "ObjectWrite",
-                    outputVersion: change.version,
-                    outputDigest: change.digest,
-                    outputOwner: parseOwner(change.recipient),
-                    idOperation: "None",
-                });
-                objectTypes[change.objectId] = change.objectType;
-                break;
-            case "mutated":
-                changedObjects.push({
-                    id: change.objectId,
-                    inputState: "Exists",
-                    inputVersion: change.previousVersion,
-                    inputDigest: null,
-                    inputOwner: parseOwner(change.owner),
-                    outputState: "ObjectWrite",
-                    outputVersion: change.version,
-                    outputDigest: change.digest,
-                    outputOwner: parseOwner(change.owner),
-                    idOperation: "None",
-                });
-                objectTypes[change.objectId] = change.objectType;
-                break;
-            case "deleted":
-                changedObjects.push({
-                    id: change.objectId,
-                    inputState: "Exists",
-                    inputVersion: change.version,
-                    inputDigest: effects.deleted?.find((d) => d.objectId === change.objectId)?.digest ?? null,
-                    inputOwner: null,
-                    outputState: "DoesNotExist",
-                    outputVersion: null,
-                    outputDigest: null,
-                    outputOwner: null,
-                    idOperation: "Deleted",
-                });
-                objectTypes[change.objectId] = change.objectType;
-                break;
-            case "wrapped":
-                changedObjects.push({
-                    id: change.objectId,
-                    inputState: "Exists",
-                    inputVersion: change.version,
-                    inputDigest: null,
-                    inputOwner: {
-                        $kind: "AddressOwner",
-                        AddressOwner: change.sender,
-                    },
-                    outputState: "ObjectWrite",
-                    outputVersion: change.version,
-                    outputDigest: effects.wrapped?.find((w) => w.objectId === change.objectId)?.digest ?? null,
-                    outputOwner: {
-                        $kind: "ObjectOwner",
-                        ObjectOwner: change.sender,
-                    },
-                    idOperation: "None",
-                });
-                objectTypes[change.objectId] = change.objectType;
-                break;
-            case "created":
-                changedObjects.push({
-                    id: change.objectId,
-                    inputState: "DoesNotExist",
-                    inputVersion: null,
-                    inputDigest: null,
-                    inputOwner: null,
-                    outputState: "ObjectWrite",
-                    outputVersion: change.version,
-                    outputDigest: change.digest,
-                    outputOwner: parseOwner(change.owner),
-                    idOperation: "Created",
-                });
-                objectTypes[change.objectId] = change.objectType;
-                break;
-        }
-    });
-    return {
-        objectTypes,
-        effects: {
-            bcs: bytes ?? null,
-            digest: effects.transactionDigest,
-            version: 2,
-            status: effects.status.status === "success"
-                ? { success: true, error: null }
-                : { success: false, error: effects.status.error },
-            gasUsed: effects.gasUsed,
-            transactionDigest: effects.transactionDigest,
-            gasObject: {
-                id: effects.gasObject?.reference.objectId,
-                inputState: "Exists",
-                inputVersion: null,
-                inputDigest: null,
-                inputOwner: null,
-                outputState: "ObjectWrite",
-                outputVersion: effects.gasObject.reference.version,
-                outputDigest: effects.gasObject.reference.digest,
-                outputOwner: parseOwner(effects.gasObject.owner),
-                idOperation: "None",
-            },
-            eventsDigest: effects.eventsDigest ?? null,
-            dependencies: effects.dependencies ?? [],
-            lamportVersion: effects.gasObject.reference.version,
-            changedObjects,
-            unchangedConsensusObjects,
-            auxiliaryDataDigest: null,
-        },
-    };
-}
-const Balance = bcs.struct("Balance", {
-    value: bcs.u64(),
-});
-const Coin = bcs.struct("Coin", {
-    id: bcs.Address,
-    balance: Balance,
-});
-function parseNormalizedSuiMoveType(type) {
-    if (typeof type !== "string") {
-        if ("Reference" in type) {
-            return {
-                reference: "immutable",
-                body: parseNormalizedSuiMoveTypeBody(type.Reference),
-            };
-        }
-        if ("MutableReference" in type) {
-            return {
-                reference: "mutable",
-                body: parseNormalizedSuiMoveTypeBody(type.MutableReference),
-            };
-        }
-    }
-    return {
-        reference: null,
-        body: parseNormalizedSuiMoveTypeBody(type),
-    };
-}
-function parseNormalizedSuiMoveTypeBody(type) {
-    switch (type) {
-        case "Address":
-            return { $kind: "address" };
-        case "Bool":
-            return { $kind: "bool" };
-        case "U8":
-            return { $kind: "u8" };
-        case "U16":
-            return { $kind: "u16" };
-        case "U32":
-            return { $kind: "u32" };
-        case "U64":
-            return { $kind: "u64" };
-        case "U128":
-            return { $kind: "u128" };
-        case "U256":
-            return { $kind: "u256" };
-    }
-    if (typeof type === "string") {
-        throw new Error(`Unknown type: ${type}`);
-    }
-    if ("Vector" in type) {
-        return {
-            $kind: "vector",
-            vector: parseNormalizedSuiMoveTypeBody(type.Vector),
-        };
-    }
-    if ("Struct" in type) {
-        return {
-            $kind: "datatype",
-            datatype: {
-                typeName: `${normalizeWowAddress(type.Struct.address)}::${type.Struct.module}::${type.Struct.name}`,
-                typeParameters: type.Struct.typeArguments.map((t) => parseNormalizedSuiMoveTypeBody(t)),
-            },
-        };
-    }
-    if ("TypeParameter" in type) {
-        return {
-            $kind: "typeParameter",
-            index: type.TypeParameter,
-        };
-    }
-    throw new Error(`Unknown type: ${JSON.stringify(type)}`);
-}
-function parseAbilities(abilitySet) {
-    return abilitySet.abilities.map((ability) => {
-        switch (ability) {
-            case "Copy":
-                return "copy";
-            case "Drop":
-                return "drop";
-            case "Store":
-                return "store";
-            case "Key":
-                return "key";
-            default:
-                return "unknown";
-        }
-    });
-}
-function parseVisibility(visibility) {
-    switch (visibility) {
-        case "Public":
-            return "public";
-        case "Private":
-            return "private";
-        case "Friend":
-            return "friend";
-        default:
-            return "unknown";
-    }
-}
-//# sourceMappingURL=core.js.map
+import{fromBase64}from'@mysten/bcs';import{bcs}from'../bcs/index.js';import{Transaction}from'../transactions/Transaction.js';import{jsonRpcClientResolveTransactionPlugin}from'./json-rpc-resolver.js';import{TransactionDataBuilder}from'../transactions/TransactionData.js';import{chunk}from'@mysten/utils';import{normalizeWowAddress}from'../utils/sui-types.js';import{Experimental_CoreClient}from'../experimental/core.js';import{ObjectError}from'../experimental/errors.js';import{parseTransactionBcs,parseTransactionEffectsBcs}from'../experimental/index.js';export class JSONRpcCoreClient extends Experimental_CoreClient{#jsonRpcClient;constructor({jsonRpcClient:a}){super({'network':a['network'],'base':a}),this.#jsonRpcClient=a;}async['getObjects'](a){const b=chunk(a['objectIds'],0x32),c=[];for(const d of b){const e=await this.#jsonRpcClient['multiGetObjects']({'ids':d,'options':{'showOwner':!![],'showType':!![],'showBcs':!![],'showPreviousTransaction':!![]},'signal':a['signal']});for(const [f,g]of e['entries']()){g['error']?c['push'](ObjectError['fromResponse'](g['error'],d[f])):c['push'](parseObject(g['data']));}}return{'objects':c};}async['getOwnedObjects'](a){const b=await this.#jsonRpcClient['getOwnedObjects']({'owner':a['address'],'limit':a['limit'],'cursor':a['cursor'],'options':{'showOwner':!![],'showType':!![],'showBcs':!![],'showPreviousTransaction':!![]},'filter':a['type']?{'StructType':a['type']}:null,'signal':a['signal']});return{'objects':b['data']['map'](c=>{if(c['error'])throw ObjectError['fromResponse'](c['error']);return parseObject(c['data']);}),'hasNextPage':b['hasNextPage'],'cursor':b['nextCursor']??null};}async['getCoins'](a){const b=await this.#jsonRpcClient['getCoins']({'owner':a['address'],'coinType':a['coinType'],'limit':a['limit'],'cursor':a['cursor'],'signal':a['signal']});return{'objects':b['data']['map'](c=>{return{'id':c['coinObjectId'],'version':c['version'],'digest':c['digest'],'balance':c['balance'],'type':'0x2::coin::Coin<'+c['coinType']+'>','content':Promise['resolve'](Coin['serialize']({'id':c['coinObjectId'],'balance':{'value':c['balance']}})['toBytes']()),'owner':{'$kind':'ObjectOwner','ObjectOwner':a['address']},'previousTransaction':c['previousTransaction']};}),'hasNextPage':b['hasNextPage'],'cursor':b['nextCursor']??null};}async['getBalance'](a){const b=await this.#jsonRpcClient['getBalance']({'owner':a['address'],'coinType':a['coinType'],'signal':a['signal']});return{'balance':{'coinType':b['coinType'],'balance':b['totalBalance']}};}async['getAllBalances'](a){const b=await this.#jsonRpcClient['getAllBalances']({'owner':a['address'],'signal':a['signal']});return{'balances':b['map'](c=>({'coinType':c['coinType'],'balance':c['totalBalance']})),'hasNextPage':![],'cursor':null};}async['getTransaction'](a){const b=await this.#jsonRpcClient['getTransactionBlock']({'digest':a['digest'],'options':{'showRawInput':!![],'showObjectChanges':!![],'showRawEffects':!![],'showEvents':!![],'showEffects':!![],'showBalanceChanges':!![]},'signal':a['signal']});return{'transaction':parseTransaction(b)};}async['executeTransaction'](a){const b=await this.#jsonRpcClient['executeTransactionBlock']({'transactionBlock':a['transaction'],'signature':a['signatures'],'options':{'showRawEffects':!![],'showEvents':!![],'showObjectChanges':!![],'showRawInput':!![],'showEffects':!![],'showBalanceChanges':!![]},'signal':a['signal']});return{'transaction':parseTransaction(b)};}async['dryRunTransaction'](a){const b=Transaction['from'](a['transaction']),c=await this.#jsonRpcClient['dryRunTransactionBlock']({'transactionBlock':a['transaction'],'signal':a['signal']}),{effects:d,objectTypes:e}=parseTransactionEffectsJson({'effects':c['effects'],'objectChanges':c['objectChanges']});return{'transaction':{'digest':await b['getDigest'](),'epoch':null,'effects':d,'objectTypes':Promise['resolve'](e),'signatures':[],'transaction':parseTransactionBcs(a['transaction']),'balanceChanges':c['balanceChanges']['map'](f=>({'coinType':f['coinType'],'address':parseOwnerAddress(f['owner']),'amount':f['amount']}))}};}async['getReferenceGasPrice'](a){const b=await this.#jsonRpcClient['getReferenceGasPrice']({'signal':a?.['signal']});return{'referenceGasPrice':String(b)};}async['getDynamicFields'](a){const b=await this.#jsonRpcClient['getDynamicFields']({'parentId':a['parentId'],'limit':a['limit'],'cursor':a['cursor']});return{'dynamicFields':b['data']['map'](c=>{return{'id':c['objectId'],'type':c['objectType'],'name':{'type':c['name']['type'],'bcs':fromBase64(c['bcsName'])}};}),'hasNextPage':b['hasNextPage'],'cursor':b['nextCursor']};}['resolveTransactionPlugin'](){return jsonRpcClientResolveTransactionPlugin(this.#jsonRpcClient);}async['getMoveFunction'](a){const b=await this.#jsonRpcClient['getNormalizedMoveFunction']({'package':a['packageId'],'module':a['moduleName'],'function':a['name']});return{'function':{'packageId':normalizeWowAddress(a['packageId']),'moduleName':a['moduleName'],'name':a['name'],'visibility':parseVisibility(b['visibility']),'isEntry':b['isEntry'],'typeParameters':b['typeParameters']['map'](c=>({'isPhantom':![],'constraints':parseAbilities(c)})),'parameters':b['parameters']['map'](c=>parseNormalizedSuiMoveType(c)),'returns':b['return']['map'](c=>parseNormalizedSuiMoveType(c))}};}}function parseObject(a){return{'id':a['objectId'],'version':a['version'],'digest':a['digest'],'type':a['type'],'content':Promise['resolve'](a['bcs']?.['dataType']==='moveObject'?fromBase64(a['bcs']['bcsBytes']):new Uint8Array()),'owner':parseOwner(a['owner']),'previousTransaction':a['previousTransaction']??null};}function parseOwner(a){if(a==='Immutable')return{'$kind':'Immutable','Immutable':!![]};if('ConsensusAddressOwner'in a)return{'$kind':'ConsensusAddressOwner','ConsensusAddressOwner':{'owner':a['ConsensusAddressOwner']['owner'],'startVersion':a['ConsensusAddressOwner']['start_version']}};if('AddressOwner'in a)return{'$kind':'AddressOwner','AddressOwner':a['AddressOwner']};if('ObjectOwner'in a)return{'$kind':'ObjectOwner','ObjectOwner':a['ObjectOwner']};if('Shared'in a)return{'$kind':'Shared','Shared':{'initialSharedVersion':a['Shared']['initial_shared_version']}};throw new Error('Unknown\x20owner\x20type:\x20'+JSON['stringify'](a));}function parseOwnerAddress(a){if(a==='Immutable')return null;if('ConsensusAddressOwner'in a)return a['ConsensusAddressOwner']['owner'];if('AddressOwner'in a)return a['AddressOwner'];if('ObjectOwner'in a)return a['ObjectOwner'];if('Shared'in a)return null;throw new Error('Unknown\x20owner\x20type:\x20'+JSON['stringify'](a));}function parseTransaction(a){const b=bcs['SenderSignedData']['parse'](fromBase64(a['rawTransaction']))[0x0],c={};a['objectChanges']?.['forEach'](f=>{f['type']!=='published'&&(c[f['objectId']]=f['objectType']);});const d=bcs['TransactionData']['serialize'](b['intentMessage']['value'])['toBytes'](),e=TransactionDataBuilder['restore']({'version':0x2,'sender':b['intentMessage']['value']['V1']['sender'],'expiration':b['intentMessage']['value']['V1']['expiration'],'gasData':b['intentMessage']['value']['V1']['gasData'],'inputs':b['intentMessage']['value']['V1']['kind']['ProgrammableTransaction']['inputs'],'commands':b['intentMessage']['value']['V1']['kind']['ProgrammableTransaction']['commands']});return{'digest':a['digest'],'epoch':a['effects']?.['executedEpoch']??null,'effects':parseTransactionEffectsBcs(new Uint8Array(a['rawEffects'])),'objectTypes':Promise['resolve'](c),'transaction':{...e,'bcs':d},'signatures':b['txSignatures'],'balanceChanges':a['balanceChanges']?.['map'](f=>({'coinType':f['coinType'],'address':parseOwnerAddress(f['owner']),'amount':f['amount']}))??[]};}function parseTransactionEffectsJson({bytes:a,effects:b,objectChanges:c}){const d=[],e=[],f={};return c?.['forEach'](g=>{switch(g['type']){case'published':d['push']({'id':g['packageId'],'inputState':'DoesNotExist','inputVersion':null,'inputDigest':null,'inputOwner':null,'outputState':'PackageWrite','outputVersion':g['version'],'outputDigest':g['digest'],'outputOwner':null,'idOperation':'Created'});break;case'transferred':d['push']({'id':g['objectId'],'inputState':'Exists','inputVersion':g['version'],'inputDigest':g['digest'],'inputOwner':{'$kind':'AddressOwner','AddressOwner':g['sender']},'outputState':'ObjectWrite','outputVersion':g['version'],'outputDigest':g['digest'],'outputOwner':parseOwner(g['recipient']),'idOperation':'None'}),f[g['objectId']]=g['objectType'];break;case'mutated':d['push']({'id':g['objectId'],'inputState':'Exists','inputVersion':g['previousVersion'],'inputDigest':null,'inputOwner':parseOwner(g['owner']),'outputState':'ObjectWrite','outputVersion':g['version'],'outputDigest':g['digest'],'outputOwner':parseOwner(g['owner']),'idOperation':'None'}),f[g['objectId']]=g['objectType'];break;case'deleted':d['push']({'id':g['objectId'],'inputState':'Exists','inputVersion':g['version'],'inputDigest':b['deleted']?.['find'](h=>h['objectId']===g['objectId'])?.['digest']??null,'inputOwner':null,'outputState':'DoesNotExist','outputVersion':null,'outputDigest':null,'outputOwner':null,'idOperation':'Deleted'}),f[g['objectId']]=g['objectType'];break;case'wrapped':d['push']({'id':g['objectId'],'inputState':'Exists','inputVersion':g['version'],'inputDigest':null,'inputOwner':{'$kind':'AddressOwner','AddressOwner':g['sender']},'outputState':'ObjectWrite','outputVersion':g['version'],'outputDigest':b['wrapped']?.['find'](h=>h['objectId']===g['objectId'])?.['digest']??null,'outputOwner':{'$kind':'ObjectOwner','ObjectOwner':g['sender']},'idOperation':'None'}),f[g['objectId']]=g['objectType'];break;case'created':d['push']({'id':g['objectId'],'inputState':'DoesNotExist','inputVersion':null,'inputDigest':null,'inputOwner':null,'outputState':'ObjectWrite','outputVersion':g['version'],'outputDigest':g['digest'],'outputOwner':parseOwner(g['owner']),'idOperation':'Created'}),f[g['objectId']]=g['objectType'];break;}}),{'objectTypes':f,'effects':{'bcs':a??null,'digest':b['transactionDigest'],'version':0x2,'status':b['status']['status']==='success'?{'success':!![],'error':null}:{'success':![],'error':b['status']['error']},'gasUsed':b['gasUsed'],'transactionDigest':b['transactionDigest'],'gasObject':{'id':b['gasObject']?.['reference']['objectId'],'inputState':'Exists','inputVersion':null,'inputDigest':null,'inputOwner':null,'outputState':'ObjectWrite','outputVersion':b['gasObject']['reference']['version'],'outputDigest':b['gasObject']['reference']['digest'],'outputOwner':parseOwner(b['gasObject']['owner']),'idOperation':'None'},'eventsDigest':b['eventsDigest']??null,'dependencies':b['dependencies']??[],'lamportVersion':b['gasObject']['reference']['version'],'changedObjects':d,'unchangedConsensusObjects':e,'auxiliaryDataDigest':null}};}const Balance=bcs['struct']('Balance',{'value':bcs['u64']()}),Coin=bcs['struct']('Coin',{'id':bcs['Address'],'balance':Balance});function parseNormalizedSuiMoveType(a){if(typeof a!=='string'){if('Reference'in a)return{'reference':'immutable','body':parseNormalizedSuiMoveTypeBody(a['Reference'])};if('MutableReference'in a)return{'reference':'mutable','body':parseNormalizedSuiMoveTypeBody(a['MutableReference'])};}return{'reference':null,'body':parseNormalizedSuiMoveTypeBody(a)};}function parseNormalizedSuiMoveTypeBody(a){switch(a){case'Address':return{'$kind':'address'};case'Bool':return{'$kind':'bool'};case'U8':return{'$kind':'u8'};case'U16':return{'$kind':'u16'};case'U32':return{'$kind':'u32'};case'U64':return{'$kind':'u64'};case'U128':return{'$kind':'u128'};case'U256':return{'$kind':'u256'};}if(typeof a==='string')throw new Error('Unknown\x20type:\x20'+a);if('Vector'in a)return{'$kind':'vector','vector':parseNormalizedSuiMoveTypeBody(a['Vector'])};if('Struct'in a)return{'$kind':'datatype','datatype':{'typeName':normalizeWowAddress(a['Struct']['address'])+'::'+a['Struct']['module']+'::'+a['Struct']['name'],'typeParameters':a['Struct']['typeArguments']['map'](b=>parseNormalizedSuiMoveTypeBody(b))}};if('TypeParameter'in a)return{'$kind':'typeParameter','index':a['TypeParameter']};throw new Error('Unknown\x20type:\x20'+JSON['stringify'](a));}function parseAbilities(a){return a['abilities']['map'](b=>{switch(b){case'Copy':return'copy';case'Drop':return'drop';case'Store':return'store';case'Key':return'key';default:return'unknown';}});}function parseVisibility(a){switch(a){case'Public':return'public';case'Private':return'private';case'Friend':return'friend';default:return'unknown';}}

package/dist/esm/jsonRpc/errors.js

@@ -1,41 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-const CODE_TO_ERROR_TYPE = {
-    "-32700": "ParseError",
-    "-32701": "OversizedRequest",
-    "-32702": "OversizedResponse",
-    "-32600": "InvalidRequest",
-    "-32601": "MethodNotFound",
-    "-32602": "InvalidParams",
-    "-32603": "InternalError",
-    "-32604": "ServerBusy",
-    "-32000": "CallExecutionFailed",
-    "-32001": "UnknownError",
-    "-32003": "SubscriptionClosed",
-    "-32004": "SubscriptionClosedWithError",
-    "-32005": "BatchesNotSupported",
-    "-32006": "TooManySubscriptions",
-    "-32050": "TransientError",
-    "-32002": "TransactionExecutionClientError",
-};
-export class SuiHTTPTransportError extends Error {
-}
-export class JsonRpcError extends SuiHTTPTransportError {
-    code;
-    type;
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-        this.type = CODE_TO_ERROR_TYPE[code] ?? "ServerError";
-    }
-}
-export class SuiHTTPStatusError extends SuiHTTPTransportError {
-    status;
-    statusText;
-    constructor(message, status, statusText) {
-        super(message);
-        this.status = status;
-        this.statusText = statusText;
-    }
-}
-//# sourceMappingURL=errors.js.map
+const CODE_TO_ERROR_TYPE={'-32700':'ParseError','-32701':'OversizedRequest','-32702':'OversizedResponse','-32600':'InvalidRequest','-32601':'MethodNotFound','-32602':'InvalidParams','-32603':'InternalError','-32604':'ServerBusy','-32000':'CallExecutionFailed','-32001':'UnknownError','-32003':'SubscriptionClosed','-32004':'SubscriptionClosedWithError','-32005':'BatchesNotSupported','-32006':'TooManySubscriptions','-32050':'TransientError','-32002':'TransactionExecutionClientError'};export class SuiHTTPTransportError extends Error{}export class JsonRpcError extends SuiHTTPTransportError{['code'];['type'];constructor(a,b){super(a),this['code']=b,this['type']=CODE_TO_ERROR_TYPE[b]??'ServerError';}}export class SuiHTTPStatusError extends SuiHTTPTransportError{['status'];['statusText'];constructor(a,b,c){super(a),this['status']=b,this['statusText']=c;}}

package/dist/esm/jsonRpc/http-transport.d.ts

@@ -1,7 +1,4 @@
 import type { WebsocketClientOptions } from "./rpc-websocket-client.js";
-/**
- * An object defining headers to be passed to the RPC server
- */
 export type HttpHeaders = {
     [header: string]: string;
 };