@wowok/wowok 2.2.11

package/dist/esm/bcs/pure.d.ts

@@ -0,0 +1,22 @@
+import type { BcsType } from "../_deps/bcs/index.js";
+export type BasePureType = "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "bool" | "id" | "string" | "address";
+interface PureShapeByType {
+    u8: number;
+    u16: number;
+    u32: number;
+    u64: bigint | string | number;
+    u128: bigint | string | number;
+    u256: bigint | string | number;
+    bool: boolean;
+    string: string;
+    id: string | Uint8Array;
+    address: string | Uint8Array;
+}
+export type PureTypeName = BasePureType | `vector<${string}>` | `option<${string}>`;
+export type ValidPureTypeName<T extends string> = T extends BasePureType ? PureTypeName : T extends `vector<${infer U}>` ? ValidPureTypeName<U> : T extends `option<${infer U}>` ? ValidPureTypeName<U> : PureTypeValidationError<T>;
+export type ShapeFromPureTypeName<T extends PureTypeName> = T extends BasePureType ? PureShapeByType[T] : T extends `vector<${infer U extends PureTypeName}>` ? ShapeFromPureTypeName<U>[] : T extends `option<${infer U extends PureTypeName}>` ? ShapeFromPureTypeName<U> | null : never;
+type PureTypeValidationError<T extends string> = {
+    error: `Invalid Pure type name: ${T}`;
+} & {};
+export declare function pureBcsSchemaFromTypeName<T extends PureTypeName>(name: T extends PureTypeName ? ValidPureTypeName<T> : T): BcsType<ShapeFromPureTypeName<T>>;
+export {};

package/dist/esm/bcs/pure.js

@@ -0,0 +1 @@
+import{bcs}from'../_deps/bcs/index.js';import{Address}from'./bcs.js';export function pureBcsSchemaFromTypeName(a){switch(a){case'u8':return bcs['u8']();case'u16':return bcs['u16']();case'u32':return bcs['u32']();case'u64':return bcs['u64']();case'u128':return bcs['u128']();case'u256':return bcs['u256']();case'bool':return bcs['bool']();case'string':return bcs['string']();case'id':case'address':return Address;}const b=a['match'](/^(vector|option)<(.+)>$/);if(b){const [c,d]=b['slice'](0x1);return c==='vector'?bcs['vector'](pureBcsSchemaFromTypeName(d)):bcs['option'](pureBcsSchemaFromTypeName(d));}throw new Error('Invalid\x20Pure\x20type\x20name:\x20'+a);}

package/dist/esm/bcs/type-tag-serializer.d.ts

@@ -0,0 +1,7 @@
+import type { TypeTag } from "./types.js";
+export declare class TypeTagSerializer {
+    static parseFromStr(str: string, normalizeAddress?: boolean): TypeTag;
+    static parseStructTypeArgs(str: string, normalizeAddress?: boolean): TypeTag[];
+    static tagToString(tag: TypeTag): string;
+}
+export declare function normalizeTypeTag(type: string): string;

package/dist/esm/bcs/type-tag-serializer.js

@@ -0,0 +1 @@
+import{splitGenericParameters}from'../_deps/bcs/index.js';import{normalizeWowAddress}from'../utils/wow-types.js';const VECTOR_REGEX=/^vector<(.+)>$/,STRUCT_REGEX=/^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;export class TypeTagSerializer{static['parseFromStr'](a,b=![]){if(a==='address')return{'address':null};else{if(a==='bool')return{'bool':null};else{if(a==='u8')return{'u8':null};else{if(a==='u16')return{'u16':null};else{if(a==='u32')return{'u32':null};else{if(a==='u64')return{'u64':null};else{if(a==='u128')return{'u128':null};else{if(a==='u256')return{'u256':null};else{if(a==='signer')return{'signer':null};}}}}}}}}const c=a['match'](VECTOR_REGEX);if(c)return{'vector':TypeTagSerializer['parseFromStr'](c[0x1],b)};const d=a['match'](STRUCT_REGEX);if(d){const e=b?normalizeWowAddress(d[0x1]):d[0x1];return{'struct':{'address':e,'module':d[0x2],'name':d[0x3],'typeParams':d[0x5]===undefined?[]:TypeTagSerializer['parseStructTypeArgs'](d[0x5],b)}};}throw new Error('Encountered\x20unexpected\x20token\x20when\x20parsing\x20type\x20args\x20for\x20'+a);}static['parseStructTypeArgs'](a,b=![]){return splitGenericParameters(a)['map'](c=>TypeTagSerializer['parseFromStr'](c,b));}static['tagToString'](a){if('bool'in a)return'bool';if('u8'in a)return'u8';if('u16'in a)return'u16';if('u32'in a)return'u32';if('u64'in a)return'u64';if('u128'in a)return'u128';if('u256'in a)return'u256';if('address'in a)return'address';if('signer'in a)return'signer';if('vector'in a)return'vector<'+TypeTagSerializer['tagToString'](a['vector'])+'>';if('struct'in a){const b=a['struct'],c=b['typeParams']['map'](TypeTagSerializer['tagToString'])['join'](',\x20');return b['address']+'::'+b['module']+'::'+b['name']+(c?'<'+c+'>':'');}throw new Error('Invalid\x20TypeTag');}}export function normalizeTypeTag(a){return TypeTagSerializer['tagToString'](TypeTagSerializer['parseFromStr'](a));}

package/dist/esm/bcs/types.d.ts

@@ -0,0 +1,65 @@
+export type SharedObjectRef = {
+    objectId: string;
+    initialSharedVersion: number | string;
+    mutable: boolean;
+};
+export type WowObjectRef = {
+    objectId: string;
+    version: number | string;
+    digest: string;
+};
+export type ObjectArg = {
+    ImmOrOwnedObject: WowObjectRef;
+} | {
+    SharedObject: SharedObjectRef;
+} | {
+    Receiving: WowObjectRef;
+};
+export type ObjectCallArg = {
+    Object: ObjectArg;
+};
+export type PureArg = {
+    Pure: Array<number>;
+};
+export declare function isPureArg(arg: any): arg is PureArg;
+export type CallArg = PureArg | ObjectCallArg;
+export type StructTag = {
+    address: string;
+    module: string;
+    name: string;
+    typeParams: TypeTag[];
+};
+export type TypeTag = {
+    bool: null | true;
+} | {
+    u8: null | true;
+} | {
+    u64: null | true;
+} | {
+    u128: null | true;
+} | {
+    address: null | true;
+} | {
+    signer: null | true;
+} | {
+    vector: TypeTag;
+} | {
+    struct: StructTag;
+} | {
+    u16: null | true;
+} | {
+    u32: null | true;
+} | {
+    u256: null | true;
+};
+export type GasData = {
+    payment: WowObjectRef[];
+    owner: string;
+    price: number;
+    budget: number;
+};
+export type TransactionExpiration = {
+    None: null;
+} | {
+    Epoch: number;
+};

package/dist/esm/bcs/types.js

@@ -0,0 +1 @@
+export function isPureArg(a){return a['Pure']!==undefined;}

package/dist/esm/client/index.d.ts

@@ -0,0 +1,5 @@
+export { type JsonRpcTransport as WowTransport, type JsonRpcTransportRequestOptions as WowTransportRequestOptions, type JsonRpcTransportSubscribeOptions as WowTransportSubscribeOptions, type HttpHeaders, type JsonRpcHTTPTransportOptions as WowHTTPTransportOptions, JsonRpcHTTPTransport as WowHTTPTransport, } from "../jsonRpc/http-transport.js";
+export { getFullnodeUrl, ENTRYPOINT } from "./network.js";
+export { type WowJsonRpcClientOptions as WowClientOptions, type PaginationArguments, type OrderArguments, isWowJsonRpcClient as isWowClient, WowJsonRpcClient as WowClient, } from "../jsonRpc/client.js";
+export { WowHTTPStatusError, WowHTTPTransportError, JsonRpcError, } from "../jsonRpc/errors.js";
+export type { WowTransactionBlockResponseOptions, CoinStruct, WowMoveNormalizedType, CoinBalance, PaginatedCoins, WowTransactionBlockResponse, CoinMetadata, ObjectResponseError, ExecuteTransactionBlockParams, } from "../jsonRpc/types/index.js";

package/dist/esm/client/index.js

@@ -0,0 +1 @@
+export{JsonRpcHTTPTransport as WowHTTPTransport}from'../jsonRpc/http-transport.js';export{getFullnodeUrl,ENTRYPOINT}from'./network.js';export{isWowJsonRpcClient as isWowClient,WowJsonRpcClient as WowClient}from'../jsonRpc/client.js';export{WowHTTPStatusError,WowHTTPTransportError,JsonRpcError}from'../jsonRpc/errors.js';

package/dist/esm/client/network.d.ts

@@ -0,0 +1,5 @@
+export declare enum ENTRYPOINT {
+    Testnet = "testnet",
+    Localnet = "localnet"
+}
+export declare function getFullnodeUrl(network: ENTRYPOINT): "https://fullnode.testnet.wowok.net:443" | "http://127.0.0.1:9000";

package/dist/esm/client/network.js

@@ -0,0 +1 @@
+export var ENTRYPOINT;(function(a){a['Testnet']='testnet',a['Localnet']='localnet';}(ENTRYPOINT||(ENTRYPOINT={})));export function getFullnodeUrl(a){switch(a){case ENTRYPOINT['Testnet']:return'https://fullnode.testnet.wowok.net:443';case ENTRYPOINT['Localnet']:return'http://127.0.0.1:9000';default:throw new Error('Unknown\x20network:\x20'+a);}}

package/dist/esm/cryptography/index.d.ts

@@ -0,0 +1,7 @@
+export { type SerializeSignatureInput, toSerializedSignature, parseSerializedSignature, } from "./signature.js";
+export { SIGNATURE_SCHEME_TO_FLAG, SIGNATURE_SCHEME_TO_SIZE, SIGNATURE_FLAG_TO_SCHEME, type SignatureScheme, type SignatureFlag, } from "./signature-scheme.js";
+export { isValidHardenedPath, isValidBIP32Path, mnemonicToSeed, mnemonicToSeedHex, } from "./mnemonics.js";
+export { messageWithIntent } from "./intent.js";
+export type { IntentScope } from "./intent.js";
+export { PRIVATE_KEY_SIZE, FALCON512_PRIVATE_KEY_SIZE, W_PRIVATE_KEY_PREFIX, type ParsedKeypair, type SignatureWithBytes, Signer, Keypair, decodeWowPrivateKey, encodeWowPrivateKey, } from "./keypair.js";
+export { PublicKey } from "./publickey.js";

package/dist/esm/cryptography/index.js

@@ -0,0 +1 @@
+export{toSerializedSignature,parseSerializedSignature}from'./signature.js';export{SIGNATURE_SCHEME_TO_FLAG,SIGNATURE_SCHEME_TO_SIZE,SIGNATURE_FLAG_TO_SCHEME}from'./signature-scheme.js';export{isValidHardenedPath,isValidBIP32Path,mnemonicToSeed,mnemonicToSeedHex}from'./mnemonics.js';export{messageWithIntent}from'./intent.js';export{PRIVATE_KEY_SIZE,FALCON512_PRIVATE_KEY_SIZE,W_PRIVATE_KEY_PREFIX,Signer,Keypair,decodeWowPrivateKey,encodeWowPrivateKey}from'./keypair.js';export{PublicKey}from'./publickey.js';

package/dist/esm/cryptography/intent.d.ts

@@ -0,0 +1,3 @@
+import { bcs } from "../bcs/index.js";
+export type IntentScope = Exclude<keyof typeof bcs.IntentScope.$inferType, "$kind">;
+export declare function messageWithIntent(scope: IntentScope, message: Uint8Array): any;

package/dist/esm/cryptography/intent.js

@@ -0,0 +1 @@
+import{bcs}from'../bcs/index.js';export function messageWithIntent(a,b){return bcs['IntentMessage'](bcs['bytes'](b['length']))['serialize']({'intent':{'scope':{[a]:!![]},'version':{'V0':!![]},'appId':{'Wow':!![]}},'value':b})['toBytes']();}

package/dist/esm/cryptography/keypair.d.ts

@@ -0,0 +1,39 @@
+import type { IntentScope } from "./intent.js";
+import type { PublicKey } from "./publickey.js";
+import type { SignatureScheme } from "./signature-scheme.js";
+import type { Transaction } from "../transactions/Transaction.js";
+import type { ClientWithCoreApi, Experimental_WowClientTypes } from "../experimental/index.js";
+export declare const FALCON512_PRIVATE_KEY_SIZE = 1281;
+export declare const PRIVATE_KEY_SIZE = 1281;
+export declare const W_PRIVATE_KEY_PREFIX = "wowprivkey";
+export type ParsedKeypair = {
+    scheme: SignatureScheme;
+    secretKey: Uint8Array;
+};
+export interface SignatureWithBytes {
+    bytes: string;
+    signature: string;
+}
+export interface SignAndExecuteOptions {
+    transaction: Transaction;
+    client: ClientWithCoreApi;
+}
+export declare abstract class Signer {
+    abstract sign(bytes: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes>;
+    signTransaction(bytes: Uint8Array): Promise<SignatureWithBytes>;
+    signPersonalMessage(bytes: Uint8Array): Promise<{
+        bytes: string;
+        signature: string;
+    }>;
+    signAndExecuteTransaction({ transaction, client, }: SignAndExecuteOptions): Promise<Omit<Experimental_WowClientTypes.TransactionResponse, "balanceChanges">>;
+    toWowAddress(): string;
+    toWAddress(): string;
+    abstract getKeyScheme(): SignatureScheme;
+    abstract getPublicKey(): PublicKey;
+}
+export declare abstract class Keypair extends Signer {
+    abstract getSecretKey(): string;
+}
+export declare function decodeWowPrivateKey(value: string): ParsedKeypair;
+export declare function encodeWowPrivateKey(bytes: Uint8Array, scheme: SignatureScheme): string;

package/dist/esm/cryptography/keypair.js

@@ -0,0 +1 @@
+import{bcs,toBase64}from'../_deps/bcs/index.js';import{blake2b}from'@noble/hashes/blake2b';import{bech32}from'@scure/base';import{messageWithIntent}from'./intent.js';import{SIGNATURE_FLAG_TO_SCHEME,SIGNATURE_SCHEME_TO_FLAG}from'./signature-scheme.js';import{toSerializedSignature}from'./signature.js';export const FALCON512_PRIVATE_KEY_SIZE=0x501;export const PRIVATE_KEY_SIZE=FALCON512_PRIVATE_KEY_SIZE;export const W_PRIVATE_KEY_PREFIX='wowprivkey';export class Signer{async['signWithIntent'](a,b){const c=messageWithIntent(b,a),d=blake2b(c,{'dkLen':0x20}),e=toSerializedSignature({'signature':await this['sign'](d),'signatureScheme':this['getKeyScheme'](),'publicKey':this['getPublicKey']()});return{'signature':e,'bytes':toBase64(a)};}async['signTransaction'](a){return this['signWithIntent'](a,'TransactionData');}async['signPersonalMessage'](a){const {signature:b}=await this['signWithIntent'](bcs['byteVector']()['serialize'](a)['toBytes'](),'PersonalMessage');return{'bytes':toBase64(a),'signature':b};}async['signAndExecuteTransaction']({transaction:a,client:b}){const c=await a['build']({'client':b}),{signature:d}=await this['signTransaction'](c),e=await b['core']['executeTransaction']({'transaction':c,'signatures':[d]});return e['transaction'];}['toWowAddress'](){return this['getPublicKey']()['toWAddress']();}['toWAddress'](){return this['toWowAddress']();}}export class Keypair extends Signer{}export function decodeWowPrivateKey(a){const {prefix:b,words:c}=bech32['decode'](a,![]);if(b!==W_PRIVATE_KEY_PREFIX)throw new Error('invalid\x20private\x20key\x20prefix');const d=new Uint8Array(bech32['fromWords'](c)),e=d['slice'](0x1),f=SIGNATURE_FLAG_TO_SCHEME[d[0x0]];if(f!=='Falcon512')throw new Error('Unsupported\x20signature\x20scheme:\x20'+f+'.\x20Only\x20Falcon512\x20is\x20supported.');return{'scheme':f,'secretKey':e};}export function encodeWowPrivateKey(a,b){if(b!=='Falcon512')throw new Error('Unsupported\x20signature\x20scheme:\x20'+b+'.\x20Only\x20Falcon512\x20is\x20supported.');if(a['length']!==FALCON512_PRIVATE_KEY_SIZE)throw new Error('Invalid\x20bytes\x20length.\x20Expected\x20'+FALCON512_PRIVATE_KEY_SIZE+'\x20bytes\x20for\x20'+b+',\x20got\x20'+a['length']);const c=SIGNATURE_SCHEME_TO_FLAG[b],d=new Uint8Array(a['length']+0x1);return d['set']([c]),d['set'](a,0x1),bech32['encode'](W_PRIVATE_KEY_PREFIX,bech32['toWords'](d),![]);}

package/dist/esm/cryptography/mnemonics.d.ts

@@ -0,0 +1,4 @@
+export declare function isValidHardenedPath(path: string): boolean;
+export declare function isValidBIP32Path(path: string): boolean;
+export declare function mnemonicToSeed(mnemonics: string): Uint8Array;
+export declare function mnemonicToSeedHex(mnemonics: string): string;

package/dist/esm/cryptography/mnemonics.js

@@ -0,0 +1 @@
+import{toHex}from'../_deps/bcs/index.js';import{mnemonicToSeedSync as a27a}from'@scure/bip39';export function isValidHardenedPath(a){if(!new RegExp('^m\x5c/44\x27\x5c/784\x27\x5c/[0-9]+\x27\x5c/[0-9]+\x27\x5c/[0-9]+\x27+$')['test'](a))return![];return!![];}export function isValidBIP32Path(a){if(!new RegExp('^m\x5c/(54|74)\x27\x5c/784\x27\x5c/[0-9]+\x27\x5c/[0-9]+\x5c/[0-9]+$')['test'](a))return![];return!![];}export function mnemonicToSeed(a){return a27a(a,'');}export function mnemonicToSeedHex(a){return toHex(mnemonicToSeed(a));}

package/dist/esm/cryptography/publickey.d.ts

@@ -0,0 +1,25 @@
+import type { IntentScope } from "./intent.js";
+export type PublicKeyInitData = string | Uint8Array | Iterable<number>;
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
+export declare abstract class PublicKey {
+    equals(publicKey: PublicKey): boolean;
+    toBase64(): string;
+    toString(): never;
+    toWPublicKey(): string;
+    verifyWithIntent(bytes: Uint8Array, signature: Uint8Array | string, intent: IntentScope): Promise<boolean>;
+    verifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+    verifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+    verifyAddress(address: string): boolean;
+    toWBytes(): Uint8Array<ArrayBuffer>;
+    toWAddress(): string;
+    abstract toRawBytes(): Uint8Array<ArrayBuffer>;
+    abstract flag(): number;
+    abstract verify(data: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+}
+export declare function parseSerializedKeypairSignature(serializedSignature: string): {
+    serializedSignature: string;
+    signatureScheme: "Falcon512" | "MultiSig";
+    signature: Uint8Array<ArrayBuffer>;
+    publicKey: Uint8Array<ArrayBuffer>;
+    bytes: Uint8Array<ArrayBuffer>;
+};

package/dist/esm/cryptography/publickey.js

@@ -0,0 +1 @@
+import{fromBase64,toBase64}from'../_deps/bcs/index.js';import{blake2b}from'@noble/hashes/blake2b';import{bytesToHex}from'@noble/hashes/utils';import{bcs}from'../bcs/index.js';import{normalizeWowAddress,WOW_ADDRESS_LENGTH}from'../utils/wow-types.js';import{messageWithIntent}from'./intent.js';import{SIGNATURE_FLAG_TO_SCHEME,SIGNATURE_SCHEME_TO_SIZE}from'./signature-scheme.js';export function bytesEqual(c,d){if(c===d)return!![];if(c['length']!==d['length'])return![];for(let e=0x0;e<c['length'];e++){if(c[e]!==d[e])return![];}return!![];}export class PublicKey{['equals'](a){return bytesEqual(this['toRawBytes'](),a['toRawBytes']());}['toBase64'](){return toBase64(this['toRawBytes']());}['toString'](){throw new Error('`toString`\x20is\x20not\x20implemented\x20on\x20public\x20keys.\x20Use\x20`toBase64()`\x20or\x20`toRawBytes()`\x20instead.');}['toWPublicKey'](){const a=this['toWBytes']();return toBase64(a);}['verifyWithIntent'](a,b,c){const d=messageWithIntent(c,a),e=blake2b(d,{'dkLen':0x20});return this['verify'](e,b);}['verifyPersonalMessage'](a,b){return this['verifyWithIntent'](bcs['byteVector']()['serialize'](a)['toBytes'](),b,'PersonalMessage');}['verifyTransaction'](a,b){return this['verifyWithIntent'](a,b,'TransactionData');}['verifyAddress'](a){return this['toWAddress']()===a;}['toWBytes'](){const a=this['toRawBytes'](),b=new Uint8Array(a['length']+0x1);return b['set']([this['flag']()]),b['set'](a,0x1),b;}['toWAddress'](){return normalizeWowAddress(bytesToHex(blake2b(this['toWBytes'](),{'dkLen':0x20}))['slice'](0x0,WOW_ADDRESS_LENGTH*0x2));}}export function parseSerializedKeypairSignature(a){const b=fromBase64(a),c=SIGNATURE_FLAG_TO_SCHEME[b[0x0]];switch(c){case'MultiSig':case'Falcon512':const d=SIGNATURE_SCHEME_TO_SIZE[c],e=b['slice'](0x1,b['length']-d),f=b['slice'](0x1+e['length']);return{'serializedSignature':a,'signatureScheme':c,'signature':e,'publicKey':f,'bytes':b};default:throw new Error('Unsupported\x20signature\x20scheme');}}

package/dist/esm/cryptography/signature-scheme.d.ts

@@ -0,0 +1,13 @@
+export declare const SIGNATURE_SCHEME_TO_FLAG: {
+    readonly MultiSig: 3;
+    readonly Falcon512: 7;
+};
+export declare const SIGNATURE_SCHEME_TO_SIZE: {
+    Falcon512: number;
+};
+export declare const SIGNATURE_FLAG_TO_SCHEME: {
+    readonly 3: "MultiSig";
+    readonly 7: "Falcon512";
+};
+export type SignatureScheme = "MultiSig" | "Falcon512";
+export type SignatureFlag = keyof typeof SIGNATURE_FLAG_TO_SCHEME;

package/dist/esm/cryptography/signature-scheme.js

@@ -0,0 +1 @@
+export const SIGNATURE_SCHEME_TO_FLAG={'MultiSig':0x3,'Falcon512':0x7};export const SIGNATURE_SCHEME_TO_SIZE={'Falcon512':0x381};export const SIGNATURE_FLAG_TO_SCHEME={0x3:'MultiSig',0x7:'Falcon512'};

package/dist/esm/cryptography/signature.d.ts

@@ -0,0 +1,21 @@
+import type { PublicKey } from "./publickey.js";
+import type { SignatureScheme } from "./signature-scheme.js";
+export type SerializeSignatureInput = {
+    signatureScheme: SignatureScheme;
+    signature: Uint8Array;
+    publicKey?: PublicKey;
+};
+export declare function toSerializedSignature({ signature, signatureScheme, publicKey, }: SerializeSignatureInput): string;
+export declare function parseSerializedSignature(serializedSignature: string): {
+    serializedSignature: string;
+    signatureScheme: "Falcon512" | "MultiSig";
+    signature: Uint8Array<ArrayBuffer>;
+    publicKey: Uint8Array<ArrayBuffer>;
+    bytes: Uint8Array<ArrayBuffer>;
+} | {
+    serializedSignature: string;
+    signatureScheme: "MultiSig";
+    multisig: any;
+    bytes: Uint8Array<ArrayBuffer>;
+    signature: any;
+};

package/dist/esm/cryptography/signature.js

@@ -0,0 +1 @@
+import{fromBase64,toBase64}from'../_deps/bcs/index.js';import{bcs}from'../bcs/index.js';import{parseSerializedKeypairSignature}from'./publickey.js';import{SIGNATURE_FLAG_TO_SCHEME,SIGNATURE_SCHEME_TO_FLAG}from'./signature-scheme.js';export function toSerializedSignature({signature:a,signatureScheme:b,publicKey:c}){if(!c)throw new Error('`publicKey`\x20is\x20required');const d=c['toRawBytes'](),e=new Uint8Array(0x1+a['length']+d['length']);return e['set']([SIGNATURE_SCHEME_TO_FLAG[b]]),e['set'](a,0x1),e['set'](d,0x1+a['length']),toBase64(e);}export function parseSerializedSignature(a){const b=fromBase64(a),c=SIGNATURE_FLAG_TO_SCHEME[b[0x0]];switch(c){case'MultiSig':const d=bcs['MultiSig']['parse'](b['slice'](0x1));return{'serializedSignature':a,'signatureScheme':'MultiSig','multisig':d,'bytes':b,'signature':undefined};case'Falcon512':return parseSerializedKeypairSignature(a);default:throw new Error('Unsupported\x20signature\x20scheme');}}

package/dist/esm/experimental/cache.d.ts

@@ -0,0 +1,12 @@
+export interface ClientCacheOptions {
+    prefix?: string[];
+    cache?: Map<string, unknown>;
+}
+export declare class ClientCache {
+    #private;
+    constructor({ prefix, cache }?: ClientCacheOptions);
+    read<T>(key: [string, ...string[]], load: () => T | Promise<T>): T | Promise<T>;
+    readSync<T>(key: [string, ...string[]], load: () => T): T;
+    clear(prefix?: string[]): void;
+    scope(prefix: string | string[]): ClientCache;
+}

package/dist/esm/experimental/cache.js

@@ -0,0 +1 @@
+export class ClientCache{#prefix;#cache;constructor({prefix:a,cache:b}={}){this.#prefix=a??[],this.#cache=b??new Map();}['read'](a,b){const c=[this.#prefix,...a]['join'](':');if(this.#cache['has'](c))return this.#cache['get'](c);const d=b();this.#cache['set'](c,d);if(typeof d==='object'&&d!==null&&'then'in d)return Promise['resolve'](d)['then'](e=>{return this.#cache['set'](c,e),e;})['catch'](e=>{this.#cache['delete'](c);throw e;});return d;}['readSync'](a,b){const c=[this.#prefix,...a]['join'](':');if(this.#cache['has'](c))return this.#cache['get'](c);const d=b();return this.#cache['set'](c,d),d;}['clear'](a){const b=[...this.#prefix,...a??[]]['join'](':');if(!b){this.#cache['clear']();return;}for(const c of this.#cache['keys']()){c['startsWith'](b)&&this.#cache['delete'](c);}}['scope'](a){return new ClientCache({'prefix':[...this.#prefix,...Array['isArray'](a)?a:[a]],'cache':this.#cache});}}

package/dist/esm/experimental/client.d.ts

@@ -0,0 +1,12 @@
+import type { Simplify, UnionToIntersection } from "../_deps/utils/index.js";
+import { ClientCache } from "./cache.js";
+import type { Experimental_CoreClient } from "./core.js";
+import type { ClientWithExtensions, Experimental_WowClientTypes, WowClientRegistration } from "./types.js";
+export declare abstract class Experimental_BaseClient {
+    network: Experimental_WowClientTypes.Network;
+    cache: ClientCache;
+    base: Experimental_BaseClient;
+    constructor({ network, base, cache, }: Experimental_WowClientTypes.WowClientOptions);
+    abstract core: Experimental_CoreClient;
+    $extend<const Registrations extends WowClientRegistration<this>[]>(...registrations: Registrations): ClientWithExtensions<Simplify<UnionToIntersection<{ [K in keyof Registrations]: Registrations[K] extends WowClientRegistration<this, infer Name extends string, infer Extension> ? { [K2 in Name]: Extension; } : never; }[number]>>, this>;
+}

package/dist/esm/experimental/client.js

@@ -0,0 +1 @@
+import{ClientCache}from'./cache.js';export class Experimental_BaseClient{['network'];['cache'];['base'];constructor({network:a,base:b,cache:cache=b?.['cache']??new ClientCache()}){this['network']=a,this['base']=b??this,this['cache']=cache;}['$extend'](...a){return Object['create'](this,Object['fromEntries'](a['map'](b=>{return[b['name'],{'value':b['register'](this)}];})));}}

package/dist/esm/experimental/core.d.ts

@@ -0,0 +1,31 @@
+import type { TransactionPlugin } from "../transactions/index.js";
+import { Experimental_BaseClient } from "./client.js";
+import type { ClientWithExtensions, Experimental_WowClientTypes } from "./types.js";
+export type ClientWithCoreApi = ClientWithExtensions<{
+    core: Experimental_CoreClient;
+}>;
+export interface Experimental_CoreClientOptions extends Experimental_WowClientTypes.WowClientOptions {
+    base: Experimental_BaseClient;
+}
+export declare abstract class Experimental_CoreClient extends Experimental_BaseClient implements Experimental_WowClientTypes.TransportMethods {
+    core: this;
+    constructor(options: Experimental_CoreClientOptions);
+    abstract getObjects(options: Experimental_WowClientTypes.GetObjectsOptions): Promise<Experimental_WowClientTypes.GetObjectsResponse>;
+    getObject(options: Experimental_WowClientTypes.GetObjectOptions): Promise<Experimental_WowClientTypes.GetObjectResponse>;
+    abstract getCoins(options: Experimental_WowClientTypes.GetCoinsOptions): Promise<Experimental_WowClientTypes.GetCoinsResponse>;
+    abstract getOwnedObjects(options: Experimental_WowClientTypes.GetOwnedObjectsOptions): Promise<Experimental_WowClientTypes.GetOwnedObjectsResponse>;
+    abstract getBalance(options: Experimental_WowClientTypes.GetBalanceOptions): Promise<Experimental_WowClientTypes.GetBalanceResponse>;
+    abstract getAllBalances(options: Experimental_WowClientTypes.GetAllBalancesOptions): Promise<Experimental_WowClientTypes.GetAllBalancesResponse>;
+    abstract getTransaction(options: Experimental_WowClientTypes.GetTransactionOptions): Promise<Experimental_WowClientTypes.GetTransactionResponse>;
+    abstract executeTransaction(options: Experimental_WowClientTypes.ExecuteTransactionOptions): Promise<Experimental_WowClientTypes.ExecuteTransactionResponse>;
+    abstract dryRunTransaction(options: Experimental_WowClientTypes.DryRunTransactionOptions): Promise<Experimental_WowClientTypes.DryRunTransactionResponse>;
+    abstract getReferenceGasPrice(options?: Experimental_WowClientTypes.GetReferenceGasPriceOptions): Promise<Experimental_WowClientTypes.GetReferenceGasPriceResponse>;
+    abstract getDynamicFields(options: Experimental_WowClientTypes.GetDynamicFieldsOptions): Promise<Experimental_WowClientTypes.GetDynamicFieldsResponse>;
+    abstract resolveTransactionPlugin(): TransactionPlugin;
+    abstract getMoveFunction(options: Experimental_WowClientTypes.GetMoveFunctionOptions): Promise<Experimental_WowClientTypes.GetMoveFunctionResponse>;
+    getDynamicField(options: Experimental_WowClientTypes.GetDynamicFieldOptions): Promise<Experimental_WowClientTypes.GetDynamicFieldResponse>;
+    waitForTransaction({ signal, timeout, ...input }: {
+        signal?: AbortSignal;
+        timeout?: number;
+    } & Experimental_WowClientTypes.GetTransactionOptions): Promise<Experimental_WowClientTypes.GetTransactionResponse>;
+}

package/dist/esm/experimental/core.js

@@ -0,0 +1 @@
+import{TypeTagSerializer}from'../bcs/type-tag-serializer.js';import{deriveDynamicFieldID}from'../utils/dynamic-fields.js';import{normalizeStructTag,parseStructTag,WOW_ADDRESS_LENGTH}from'../utils/wow-types.js';import{Experimental_BaseClient}from'./client.js';export class Experimental_CoreClient extends Experimental_BaseClient{['core']=this;constructor(a){super(a);}async['getObject'](a){const {objectId:b}=a,{objects:[c]}=await this['getObjects']({'objectIds':[b],'signal':a['signal']});if(c instanceof Error)throw c;return{'object':c};}async['getDynamicField'](a){const b=TypeTagSerializer['parseFromStr'](a['name']['type']),c=deriveDynamicFieldID(a['parentId'],b,a['name']['bcs']),{objects:[d]}=await this['getObjects']({'objectIds':[c],'signal':a['signal']});if(d instanceof Error)throw d;const e=parseStructTag(d['type']),f=await d['content'];return{'dynamicField':{'id':d['id'],'digest':d['digest'],'version':d['version'],'type':d['type'],'previousTransaction':d['previousTransaction'],'name':{'type':typeof e['typeParams'][0x0]==='string'?e['typeParams'][0x0]:normalizeStructTag(e['typeParams'][0x0]),'bcs':a['name']['bcs']},'value':{'type':typeof e['typeParams'][0x1]==='string'?e['typeParams'][0x1]:normalizeStructTag(e['typeParams'][0x1]),'bcs':f['slice'](WOW_ADDRESS_LENGTH+a['name']['bcs']['length'])}}};}async['waitForTransaction']({signal:a,timeout:timeout=0x3c*0x3e8,...b}){const c=a?AbortSignal['any']([AbortSignal['timeout'](timeout),a]):AbortSignal['timeout'](timeout),d=new Promise((e,f)=>{c['addEventListener']('abort',()=>f(c['reason']));});d['catch'](()=>{});while(!![]){c['throwIfAborted']();try{return await this['getTransaction']({...b,'signal':c});}catch{await Promise['race']([new Promise(e=>setTimeout(e,0x7d0)),d]);}}}}

package/dist/esm/experimental/errors.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectResponseError } from "../client/index.js";
+export declare class WowClientError extends Error {
+}
+export declare class ObjectError extends WowClientError {
+    code: string;
+    constructor(code: string, message: string);
+    static fromResponse(response: ObjectResponseError, objectId?: string): ObjectError;
+}

package/dist/esm/experimental/errors.js

@@ -0,0 +1 @@
+export class WowClientError extends Error{}export class ObjectError extends WowClientError{['code'];constructor(a,b){super(b),this['code']=a;}static['fromResponse'](a,b){switch(a['code']){case'notExists':return new ObjectError(a['code'],'Object\x20'+a['object_id']+'\x20does\x20not\x20exist');case'dynamicFieldNotFound':return new ObjectError(a['code'],'Dynamic\x20field\x20not\x20found\x20for\x20object\x20'+a['parent_object_id']);case'deleted':return new ObjectError(a['code'],'Object\x20'+a['object_id']+'\x20has\x20been\x20deleted');case'displayError':return new ObjectError(a['code'],'Display\x20error:\x20'+a['error']);case'unknown':default:return new ObjectError(a['code'],'Unknown\x20error\x20while\x20loading\x20object'+(b?'\x20'+b:''));}}}

package/dist/esm/experimental/index.d.ts

@@ -0,0 +1,7 @@
+import { Experimental_BaseClient } from "./client.js";
+import type { ClientWithCoreApi, Experimental_CoreClientOptions } from "./core.js";
+import { Experimental_CoreClient } from "./core.js";
+import type { ClientWithExtensions, Experimental_WowClientTypes, WowClientRegistration } from "./types.js";
+export { parseTransactionBcs, parseTransactionEffectsBcs, } from "./transports/utils.js";
+export { Experimental_BaseClient, Experimental_CoreClient, type Experimental_CoreClientOptions, type ClientWithExtensions, type Experimental_WowClientTypes, type WowClientRegistration, type ClientWithCoreApi, };
+export { ClientCache, type ClientCacheOptions } from "./cache.js";

package/dist/esm/experimental/index.js

@@ -0,0 +1 @@
+import{Experimental_BaseClient}from'./client.js';import{Experimental_CoreClient}from'./core.js';export{parseTransactionBcs,parseTransactionEffectsBcs}from'./transports/utils.js';export{Experimental_BaseClient,Experimental_CoreClient};export{ClientCache}from'./cache.js';

package/dist/esm/experimental/persistent-storage.d.ts

@@ -0,0 +1,36 @@
+export declare class PersistentStorage<T> {
+    private readonly filePath;
+    private readonly lock;
+    constructor(filePath: string);
+    readAll(): Promise<T>;
+    writeAll(data: T): Promise<void>;
+    set<K extends keyof T>(key: K, value: T[K]): Promise<void>;
+    get<K extends keyof T>(key: K): Promise<T[K] | undefined>;
+    transaction(transactionFn: (data: T) => T): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class Lock {
+    private readonly lockPath;
+    private readonly sharedLockPath;
+    private lockFd;
+    private sharedLockCount;
+    private exclusiveLockCount;
+    constructor(lockPath: string);
+    acquireShared(): Promise<void>;
+    acquireExclusive(): Promise<void>;
+    releaseShared(): Promise<void>;
+    releaseExclusive(): Promise<void>;
+}
+export declare class MultiProcessKVStore<T = any> {
+    private readonly storage;
+    constructor(filePath: string);
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+    values(): Promise<T[]>;
+    entries(): Promise<[string, T][]>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+}

package/dist/esm/experimental/persistent-storage.js

@@ -0,0 +1 @@
+import{randomBytes}from'crypto';import{readFileSync,writeFileSync,renameSync,unlinkSync,existsSync,openSync,closeSync,constants}from'fs';export class PersistentStorage{['filePath'];['lock'];constructor(a){this['filePath']=a,this['lock']=new Lock(a+'.lock'),!existsSync(a)&&writeFileSync(a,JSON['stringify']({}));}async['readAll'](){await this['lock']['acquireShared']();try{const a=readFileSync(this['filePath'],'utf8');return JSON['parse'](a);}finally{await this['lock']['releaseShared']();}}async['writeAll'](a){await this['lock']['acquireExclusive']();try{const b=this['filePath']+'.tmp.'+randomBytes(0x8)['toString']('hex');writeFileSync(b,JSON['stringify'](a)),renameSync(b,this['filePath']);}finally{await this['lock']['releaseExclusive']();}}async['set'](a,b){await this['lock']['acquireExclusive']();try{const c=readFileSync(this['filePath'],'utf8'),d=JSON['parse'](c);d[a]=b;const e=this['filePath']+'.tmp.'+randomBytes(0x8)['toString']('hex');writeFileSync(e,JSON['stringify'](d)),renameSync(e,this['filePath']);}finally{await this['lock']['releaseExclusive']();}}async['get'](a){await this['lock']['acquireShared']();try{const b=readFileSync(this['filePath'],'utf8'),c=JSON['parse'](b);return c[a];}finally{await this['lock']['releaseShared']();}}async['transaction'](a){await this['lock']['acquireExclusive']();try{const b=readFileSync(this['filePath'],'utf8'),c=JSON['parse'](b),d=a(c),e=this['filePath']+'.tmp.'+randomBytes(0x8)['toString']('hex');writeFileSync(e,JSON['stringify'](d)),renameSync(e,this['filePath']);}finally{await this['lock']['releaseExclusive']();}}async['clear'](){await this['lock']['acquireExclusive']();try{const a=this['filePath']+'.tmp.'+randomBytes(0x8)['toString']('hex');writeFileSync(a,JSON['stringify']({})),renameSync(a,this['filePath']);}finally{await this['lock']['releaseExclusive']();}}}export class Lock{['lockPath'];['sharedLockPath'];['lockFd']=null;['sharedLockCount']=0x0;['exclusiveLockCount']=0x0;constructor(a){this['lockPath']=a,this['sharedLockPath']=a+'.shared';}async['acquireShared'](){if(this['exclusiveLockCount']>0x0){this['sharedLockCount']++,this['exclusiveLockCount']--;return;}if(this['sharedLockCount']>0x0){this['sharedLockCount']++;return;}let a=0x0;const b=0x64,c=0x32;while(a<b){try{if(existsSync(this['lockPath'])){await new Promise(d=>setTimeout(d,c)),a++;continue;}writeFileSync(this['sharedLockPath'],''),this['sharedLockCount']=0x1;return;}catch(d){await new Promise(e=>setTimeout(e,c)),a++;}}throw new Error('Failed\x20to\x20acquire\x20shared\x20lock\x20after\x20multiple\x20attempts');}async['acquireExclusive'](){if(this['exclusiveLockCount']>0x0){this['exclusiveLockCount']++;return;}let a=0x0;const b=0x64,c=0x32;while(a<b){try{if(existsSync(this['sharedLockPath'])){await new Promise(e=>setTimeout(e,c)),a++;continue;}const d=openSync(this['lockPath'],constants['O_CREAT']|constants['O_EXCL']|constants['O_WRONLY'],0x1a4);closeSync(d),this['exclusiveLockCount']=0x1;return;}catch(e){await new Promise(f=>setTimeout(f,c)),a++;}}throw new Error('Failed\x20to\x20acquire\x20exclusive\x20lock\x20after\x20multiple\x20attempts');}async['releaseShared'](){if(this['sharedLockCount']===0x0)throw new Error('No\x20shared\x20lock\x20to\x20release');this['sharedLockCount']--;if(this['sharedLockCount']===0x0)try{unlinkSync(this['sharedLockPath']);}catch(a){}}async['releaseExclusive'](){if(this['exclusiveLockCount']===0x0)throw new Error('No\x20exclusive\x20lock\x20to\x20release');this['exclusiveLockCount']--;if(this['exclusiveLockCount']===0x0)try{unlinkSync(this['lockPath']);}catch(a){}}}export class MultiProcessKVStore{['storage'];constructor(a){this['storage']=new PersistentStorage(a);}async['get'](a){return this['storage']['get'](a);}async['set'](a,b){return this['storage']['set'](a,b);}async['delete'](a){return this['storage']['transaction'](b=>{return delete b[a],b;});}async['has'](a){const b=await this['storage']['get'](a);return b!==undefined;}async['keys'](){const a=await this['storage']['readAll']();return Object['keys'](a);}async['values'](){const a=await this['storage']['readAll']();return Object['values'](a);}async['entries'](){const a=await this['storage']['readAll']();return Object['entries'](a);}async['clear'](){return this['storage']['clear']();}async['size'](){const a=await this['storage']['readAll']();return Object['keys'](a)['length'];}}

package/dist/esm/experimental/persistent-storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/experimental/persistent-storage.test.js

@@ -0,0 +1 @@
+import{PersistentStorage,MultiProcessKVStore}from'./persistent-storage.js';import{existsSync,unlinkSync}from'fs';const STORAGE_FILE='./test-storage.json',KV_STORE_FILE='./test-kv-store.json';function cleanupTestFiles(){existsSync(STORAGE_FILE)&&unlinkSync(STORAGE_FILE),existsSync(STORAGE_FILE+'.lock')&&unlinkSync(STORAGE_FILE+'.lock'),existsSync(STORAGE_FILE+'.lock.shared')&&unlinkSync(STORAGE_FILE+'.lock.shared'),existsSync(KV_STORE_FILE)&&unlinkSync(KV_STORE_FILE),existsSync(KV_STORE_FILE+'.lock')&&unlinkSync(KV_STORE_FILE+'.lock'),existsSync(KV_STORE_FILE+'.lock.shared')&&unlinkSync(KV_STORE_FILE+'.lock.shared');}async function testPersistentStorage(){console['log']('===\x20Testing\x20PersistentStorage\x20===');const a=new PersistentStorage(STORAGE_FILE);console['log']('Writing\x20initial\x20data...'),await a['writeAll']({'port':0xbb8,'host':'localhost','debug':!![]}),console['log']('Initial\x20data\x20written\x20successfully!'),console['log']('Reading\x20all\x20data...');const b=await a['readAll']();console['log']('Read\x20data:',b),console['log']('Getting\x20specific\x20key\x20(port)...');const c=await a['get']('port');console['log']('Port:',c),console['log']('Setting\x20new\x20value\x20for\x20port...'),await a['set']('port',0xfa0),console['log']('New\x20port\x20set\x20to:',await a['get']('port')),console['log']('Adding\x20new\x20key\x20(apiKey)...'),await a['set']('apiKey','test-12345'),console['log']('New\x20apiKey:',await a['get']('apiKey')),console['log']('Running\x20transaction...'),await a['transaction'](d=>{return d['debug']=![],d['host']='0.0.0.0',d;}),console['log']('After\x20transaction:',await a['readAll']()),console['log']('Clearing\x20all\x20data...'),await a['clear'](),console['log']('After\x20clearing:',await a['readAll']()),console['log']('PersistentStorage\x20tests\x20completed!\x0a');}async function testMultiProcessKVStore(){console['log']('===\x20Testing\x20MultiProcessKVStore\x20===');const a=new MultiProcessKVStore(KV_STORE_FILE);console['log']('Setting\x20values...'),await a['set']('username','john_doe'),await a['set']('email','john@example.com'),await a['set']('role','admin'),console['log']('Values\x20set\x20successfully!'),console['log']('Getting\x20values...'),console['log']('Username:',await a['get']('username')),console['log']('Email:',await a['get']('email')),console['log']('Role:',await a['get']('role')),console['log']('Checking\x20if\x20keys\x20exist...'),console['log']('Username\x20exists:',await a['has']('username')),console['log']('Password\x20exists:',await a['has']('password')),console['log']('Getting\x20all\x20keys...');const b=await a['keys']();console['log']('Keys:',b),console['log']('Getting\x20all\x20values...');const c=await a['values']();console['log']('Values:',c),console['log']('Getting\x20all\x20entries...');const d=await a['entries']();console['log']('Entries:',d),console['log']('Getting\x20size...');const e=await a['size']();console['log']('Size:',e),console['log']('Deleting\x20a\x20key\x20(role)...'),await a['delete']('role'),console['log']('Role\x20exists\x20after\x20deletion:',await a['has']('role')),console['log']('Size\x20after\x20deletion:',await a['size']()),console['log']('Clearing\x20all\x20data...'),await a['clear'](),console['log']('Size\x20after\x20clearing:',await a['size']()),console['log']('MultiProcessKVStore\x20tests\x20completed!\x0a');}async function testMultiProcessSimulation(){console['log']('===\x20Testing\x20Multi-Process\x20Simulation\x20===');const a=new PersistentStorage(STORAGE_FILE),b=new PersistentStorage(STORAGE_FILE);await a['writeAll']({'counter':0x0}),console['log']('Initial\x20counter:',await a['get']('counter')),console['log']('Simulating\x20concurrent\x20updates...');const c=async()=>{for(let f=0x0;f<0x5;f++){await a['transaction'](g=>{return g['counter']+=0x1,g;}),console['log']('Process\x201:\x20counter\x20=',await a['get']('counter')),await new Promise(g=>setTimeout(g,0x64));}},d=async()=>{for(let f=0x0;f<0x5;f++){await b['transaction'](g=>{return g['counter']+=0x1,g;}),console['log']('Process\x202:\x20counter\x20=',await b['get']('counter')),await new Promise(g=>setTimeout(g,0x96));}};await Promise['all']([c(),d()]);const e=await a['get']('counter');console['log']('Final\x20counter\x20value:',e),console['log']('Expected\x20final\x20counter\x20value:\x2010'),console['log']('Multi-process\x20simulation\x20completed!\x0a');}async function runAllTests(){try{cleanupTestFiles(),await testPersistentStorage(),await testMultiProcessKVStore(),await testMultiProcessSimulation(),cleanupTestFiles(),console['log']('All\x20tests\x20completed\x20successfully!');}catch(a){console['error']('Error\x20running\x20tests:',a),cleanupTestFiles();}}require['main']===module&&runAllTests()['catch'](console['error']);

package/dist/esm/experimental/transports/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Experimental_WowClientTypes } from "../types.js";
+export declare function parseTransactionBcs(bytes: Uint8Array): Experimental_WowClientTypes.TransactionResponse["transaction"];
+export declare function parseTransactionEffectsBcs(effects: Uint8Array): Experimental_WowClientTypes.TransactionEffects;

package/dist/esm/experimental/transports/utils.js

@@ -0,0 +1 @@
+import{bcs}from'../../bcs/index.js';import{TransactionDataBuilder}from'../../transactions/TransactionData.js';export function parseTransactionBcs(a){return{...TransactionDataBuilder['fromBytes'](a)['snapshot'](),'bcs':a};}export function parseTransactionEffectsBcs(a){const b=bcs['TransactionEffects']['parse'](a);switch(b['$kind']){case'V1':return parseTransactionEffectsV1({'bytes':a,'effects':b['V1']});case'V2':return parseTransactionEffectsV2({'bytes':a,'effects':b['V2']});default:throw new Error('Unknown\x20transaction\x20effects\x20version:\x20'+b['$kind']);}}function parseTransactionEffectsV1(a){throw new Error('V1\x20effects\x20are\x20not\x20supported\x20yet');}function parseTransactionEffectsV2({bytes:a,effects:b}){const c=b['changedObjects']['map'](([d,e])=>{return{'id':d,'inputState':e['inputState']['$kind']==='Exist'?'Exists':'DoesNotExist','inputVersion':e['inputState']['Exist']?.[0x0][0x0]??null,'inputDigest':e['inputState']['Exist']?.[0x0][0x1]??null,'inputOwner':e['inputState']['Exist']?.[0x1]??null,'outputState':e['outputState']['$kind']==='NotExist'?'DoesNotExist':e['outputState']['$kind'],'outputVersion':e['outputState']['$kind']==='PackageWrite'?e['outputState']['PackageWrite']?.[0x0]:e['outputState']['ObjectWrite']?b['lamportVersion']:null,'outputDigest':e['outputState']['$kind']==='PackageWrite'?e['outputState']['PackageWrite']?.[0x1]:e['outputState']['ObjectWrite']?.[0x0]??null,'outputOwner':e['outputState']['ObjectWrite']?e['outputState']['ObjectWrite'][0x1]:null,'idOperation':e['idOperation']['$kind']};});return{'bcs':a,'digest':b['transactionDigest'],'version':0x2,'status':b['status']['$kind']==='Success'?{'success':!![],'error':null}:{'success':![],'error':b['status']['Failed']['error']['$kind']},'gasUsed':b['gasUsed'],'transactionDigest':b['transactionDigest'],'gasObject':b['gasObjectIndex']===null?null:c[b['gasObjectIndex']]??null,'eventsDigest':b['eventsDigest'],'dependencies':b['dependencies'],'lamportVersion':b['lamportVersion'],'changedObjects':c,'unchangedConsensusObjects':b['unchangedSharedObjects']['map'](([d,e])=>{return{'kind':e['$kind']==='MutateDeleted'?'MutateConsensusStreamEnded':e['$kind']==='ReadDeleted'?'ReadConsensusStreamEnded':e['$kind'],'objectId':d,'version':e['$kind']==='ReadOnlyRoot'?e['ReadOnlyRoot'][0x0]:e[e['$kind']],'digest':e['$kind']==='ReadOnlyRoot'?e['ReadOnlyRoot'][0x1]:null};}),'auxiliaryDataDigest':b['auxDataDigest']};}