@wowok/wowok 2.2.11

package/dist/cjs/jsonRpc/client.d.ts

@@ -0,0 +1,121 @@
+import type { Signer } from "../cryptography/index.js";
+import { Experimental_BaseClient } from "../experimental/client.js";
+import type { Experimental_WowClientTypes } from "../experimental/types.js";
+import type { Transaction } from "../transactions/Transaction.js";
+import type { JsonRpcTransport } from "./http-transport.js";
+import type { AddressMetrics, AllEpochsAddressMetrics, Checkpoint, CheckpointPage, CoinBalance, CoinMetadata, CoinSupply, CommitteeInfo, DelegatedStake, DevInspectResults, DevInspectTransactionBlockParams, DryRunTransactionBlockParams, DryRunTransactionBlockResponse, DynamicFieldPage, EpochInfo, EpochMetricsPage, EpochPage, ExecuteTransactionBlockParams, GetAllBalancesParams, GetAllCoinsParams, GetBalanceParams, GetCheckpointParams, GetCheckpointsParams, GetCoinMetadataParams, GetCoinsParams, GetCommitteeInfoParams, GetDynamicFieldObjectParams, GetDynamicFieldsParams, GetLatestCheckpointSequenceNumberParams, GetLatestWowSystemStateParams, ObjectRead, GetMoveFunctionArgTypesParams, GetNormalizedMoveFunctionParams, GetNormalizedMoveModuleParams, GetNormalizedMoveModulesByPackageParams, GetNormalizedMoveStructParams, GetObjectParams, GetOwnedObjectsParams, GetProtocolConfigParams, GetReferenceGasPriceParams, GetStakesByIdsParams, GetStakesParams, GetTotalSupplyParams, GetTransactionBlockParams, MoveCallMetrics, MultiGetObjectsParams, MultiGetTransactionBlocksParams, NetworkMetrics, Order, PaginatedCoins, PaginatedEvents, PaginatedObjectsResponse, PaginatedTransactionResponse, ProtocolConfig, QueryEventsParams, QueryTransactionBlocksParams, SubscribeEventParams, SubscribeTransactionParams, WowEvent, WowMoveFunctionArgType, WowMoveNormalizedFunction, WowMoveNormalizedModule, WowMoveNormalizedModules, WowMoveNormalizedStruct, WowObjectResponse, WowSystemStateSummary, WowTransactionBlockResponse, TransactionEffects, TryGetPastObjectParams, Unsubscribe, ValidatorsApy } from "./types/index.js";
+import { JSONRpcCoreClient } from "./core.js";
+export interface PaginationArguments<Cursor> {
+    cursor?: Cursor;
+    limit?: number | null;
+}
+export interface OrderArguments {
+    order?: Order | null;
+}
+export type WowJsonRpcClientOptions = NetworkOrTransport & {
+    network?: Experimental_WowClientTypes.Network;
+};
+type NetworkOrTransport = {
+    url: string;
+    transport?: never;
+} | {
+    transport: JsonRpcTransport;
+    url?: never;
+};
+declare const WOW_CLIENT_BRAND: never;
+export declare function isWowJsonRpcClient(client: unknown): client is WowJsonRpcClient;
+export declare class WowJsonRpcClient extends Experimental_BaseClient {
+    [WOW_CLIENT_BRAND]: boolean;
+    core: JSONRpcCoreClient;
+    jsonRpc: this;
+    protected transport: JsonRpcTransport;
+    constructor(options: WowJsonRpcClientOptions);
+    getRpcApiVersion({ signal }?: {
+        signal?: AbortSignal;
+    }): Promise<string | undefined>;
+    getCoins({ coinType, owner, cursor, limit, signal, }: GetCoinsParams): Promise<PaginatedCoins>;
+    getAllCoins(input: GetAllCoinsParams): Promise<PaginatedCoins>;
+    getBalance({ owner, coinType, signal, }: GetBalanceParams): Promise<CoinBalance>;
+    getAllBalances(input: GetAllBalancesParams): Promise<CoinBalance[]>;
+    getCoinMetadata({ coinType, signal, }: GetCoinMetadataParams): Promise<CoinMetadata | null>;
+    getTotalSupply({ coinType, signal, }: GetTotalSupplyParams): Promise<CoinSupply>;
+    call<T = unknown>(method: string, params: unknown[], { signal }?: {
+        signal?: AbortSignal;
+    }): Promise<T>;
+    getMoveFunctionArgTypes({ package: pkg, module, function: fn, signal, }: GetMoveFunctionArgTypesParams): Promise<WowMoveFunctionArgType[]>;
+    getNormalizedMoveModulesByPackage({ package: pkg, signal, }: GetNormalizedMoveModulesByPackageParams): Promise<WowMoveNormalizedModules>;
+    getNormalizedMoveModule({ package: pkg, module, signal, }: GetNormalizedMoveModuleParams): Promise<WowMoveNormalizedModule>;
+    getNormalizedMoveFunction({ package: pkg, module, function: fn, signal, }: GetNormalizedMoveFunctionParams): Promise<WowMoveNormalizedFunction>;
+    getNormalizedMoveStruct({ package: pkg, module, struct, signal, }: GetNormalizedMoveStructParams): Promise<WowMoveNormalizedStruct>;
+    getOwnedObjects(input: GetOwnedObjectsParams): Promise<PaginatedObjectsResponse>;
+    getObject(input: GetObjectParams): Promise<WowObjectResponse>;
+    tryGetPastObject(input: TryGetPastObjectParams): Promise<ObjectRead>;
+    multiGetObjects(input: MultiGetObjectsParams): Promise<WowObjectResponse[]>;
+    queryTransactionBlocks({ filter, options, cursor, limit, order, signal, }: QueryTransactionBlocksParams): Promise<PaginatedTransactionResponse>;
+    getTransactionBlock(input: GetTransactionBlockParams): Promise<WowTransactionBlockResponse>;
+    multiGetTransactionBlocks(input: MultiGetTransactionBlocksParams): Promise<WowTransactionBlockResponse[]>;
+    executeTransactionBlock({ transactionBlock, signature, options, requestType, signal, }: ExecuteTransactionBlockParams): Promise<WowTransactionBlockResponse>;
+    signAndExecuteTransaction({ transaction, signer, ...input }: {
+        transaction: Uint8Array | Transaction;
+        signer: Signer;
+    } & Omit<ExecuteTransactionBlockParams, "transactionBlock" | "signature">): Promise<WowTransactionBlockResponse>;
+    getTotalTransactionBlocks({ signal, }?: {
+        signal?: AbortSignal;
+    }): Promise<bigint>;
+    getReferenceGasPrice({ signal, }?: GetReferenceGasPriceParams): Promise<bigint>;
+    getStakes(input: GetStakesParams): Promise<DelegatedStake[]>;
+    getStakesByIds(input: GetStakesByIdsParams): Promise<DelegatedStake[]>;
+    getLatestWowSystemState({ signal, }?: GetLatestWowSystemStateParams): Promise<WowSystemStateSummary>;
+    queryEvents({ query, cursor, limit, order, signal, }: QueryEventsParams): Promise<PaginatedEvents>;
+    subscribeEvent(input: SubscribeEventParams & {
+        onMessage: (event: WowEvent) => void;
+    }): Promise<Unsubscribe>;
+    subscribeTransaction(input: SubscribeTransactionParams & {
+        onMessage: (event: TransactionEffects) => void;
+    }): Promise<Unsubscribe>;
+    devInspectTransactionBlock(input: DevInspectTransactionBlockParams): Promise<DevInspectResults>;
+    dryRunTransactionBlock(input: DryRunTransactionBlockParams): Promise<DryRunTransactionBlockResponse>;
+    getDynamicFields(input: GetDynamicFieldsParams): Promise<DynamicFieldPage>;
+    getDynamicFieldObject(input: GetDynamicFieldObjectParams): Promise<WowObjectResponse>;
+    getLatestCheckpointSequenceNumber({ signal, }?: GetLatestCheckpointSequenceNumberParams): Promise<string>;
+    getCheckpoint(input: GetCheckpointParams): Promise<Checkpoint>;
+    getCheckpoints(input: PaginationArguments<CheckpointPage["nextCursor"]> & GetCheckpointsParams): Promise<CheckpointPage>;
+    getCommitteeInfo(input?: GetCommitteeInfoParams): Promise<CommitteeInfo>;
+    getNetworkMetrics({ signal, }?: {
+        signal?: AbortSignal;
+    }): Promise<NetworkMetrics>;
+    getAddressMetrics({ signal, }?: {
+        signal?: AbortSignal;
+    }): Promise<AddressMetrics>;
+    getEpochMetrics(input?: {
+        descendingOrder?: boolean;
+        signal?: AbortSignal;
+    } & PaginationArguments<EpochMetricsPage["nextCursor"]>): Promise<EpochMetricsPage>;
+    getAllEpochAddressMetrics(input?: {
+        descendingOrder?: boolean;
+        signal?: AbortSignal;
+    }): Promise<AllEpochsAddressMetrics>;
+    getEpochs(input?: {
+        descendingOrder?: boolean;
+        signal?: AbortSignal;
+    } & PaginationArguments<EpochPage["nextCursor"]>): Promise<EpochPage>;
+    getMoveCallMetrics({ signal, }?: {
+        signal?: AbortSignal;
+    }): Promise<MoveCallMetrics>;
+    getCurrentEpoch({ signal, }?: {
+        signal?: AbortSignal;
+    }): Promise<EpochInfo>;
+    getValidatorsApy({ signal, }?: {
+        signal?: AbortSignal;
+    }): Promise<ValidatorsApy>;
+    getChainIdentifier({ signal, }?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    getProtocolConfig(input?: GetProtocolConfigParams): Promise<ProtocolConfig>;
+    waitForTransaction({ signal, timeout, pollInterval, ...input }: {
+        signal?: AbortSignal;
+        timeout?: number;
+        pollInterval?: number;
+    } & Parameters<WowJsonRpcClient["getTransactionBlock"]>[0]): Promise<WowTransactionBlockResponse>;
+}
+export {};

package/dist/cjs/jsonRpc/client.js

@@ -0,0 +1 @@
+import{fromBase58,toBase64,toHex}from'../_deps/bcs/index.js';import{Experimental_BaseClient}from'../experimental/client.js';import{isTransaction}from'../transactions/Transaction.js';import{isValidWowAddress,isValidWowObjectId,isValidTransactionDigest,normalizeWowAddress,normalizeWowObjectId}from'../utils/wow-types.js';import{JsonRpcHTTPTransport}from'./http-transport.js';import{JSONRpcCoreClient}from'./core.js';const WOW_CLIENT_BRAND=Symbol['for']('https://wowok.net@WowClient');export function isWowJsonRpcClient(a){return typeof a==='object'&&a!==null&&a[WOW_CLIENT_BRAND]===!![];}export class WowJsonRpcClient extends Experimental_BaseClient{['core'];['jsonRpc']=this;['transport'];get[WOW_CLIENT_BRAND](){return!![];}constructor(a){super({'network':a['network']??'unknown'}),this['transport']=a['transport']??new JsonRpcHTTPTransport({'url':a['url']}),this['core']=new JSONRpcCoreClient({'jsonRpcClient':this});}async['getRpcApiVersion']({signal:a}={}){const b=await this['transport']['request']({'method':'rpc.discover','params':[],'signal':a});return b['info']['version'];}async['getCoins']({coinType:a,owner:b,cursor:c,limit:d,signal:e}){if(!b||!isValidWowAddress(normalizeWowAddress(b)))throw new Error('Invalid\x20Wow\x20address');return await this['transport']['request']({'method':'wx_getCoins','params':[b,a,c,d],'signal':e});}async['getAllCoins'](a){if(!a['owner']||!isValidWowAddress(normalizeWowAddress(a['owner'])))throw new Error('Invalid\x20Wow\x20address');return await this['transport']['request']({'method':'wx_getAllCoins','params':[a['owner'],a['cursor'],a['limit']],'signal':a['signal']});}async['getBalance']({owner:a,coinType:b,signal:c}){if(!a||!isValidWowAddress(normalizeWowAddress(a)))throw new Error('Invalid\x20Wow\x20address');return await this['transport']['request']({'method':'wx_getBalance','params':[a,b],'signal':c});}async['getAllBalances'](a){if(!a['owner']||!isValidWowAddress(normalizeWowAddress(a['owner'])))throw new Error('Invalid\x20Wow\x20address');return await this['transport']['request']({'method':'wx_getAllBalances','params':[a['owner']],'signal':a['signal']});}async['getCoinMetadata']({coinType:a,signal:b}){return await this['transport']['request']({'method':'wx_getCoinMetadata','params':[a],'signal':b});}async['getTotalSupply']({coinType:a,signal:b}){return await this['transport']['request']({'method':'wx_getTotalSupply','params':[a],'signal':b});}async['call'](a,b,{signal:c}={}){return await this['transport']['request']({'method':a,'params':b,'signal':c});}async['getMoveFunctionArgTypes']({package:a,module:b,function:c,signal:d}){return await this['transport']['request']({'method':'w_getMoveFunctionArgTypes','params':[a,b,c],'signal':d});}async['getNormalizedMoveModulesByPackage']({package:a,signal:b}){return await this['transport']['request']({'method':'w_getNormalizedMoveModulesByPackage','params':[a],'signal':b});}async['getNormalizedMoveModule']({package:a,module:b,signal:c}){return await this['transport']['request']({'method':'w_getNormalizedMoveModule','params':[a,b],'signal':c});}async['getNormalizedMoveFunction']({package:a,module:b,function:c,signal:d}){return await this['transport']['request']({'method':'w_getNormalizedMoveFunction','params':[a,b,c],'signal':d});}async['getNormalizedMoveStruct']({package:a,module:b,struct:c,signal:d}){return await this['transport']['request']({'method':'w_getNormalizedMoveStruct','params':[a,b,c],'signal':d});}async['getOwnedObjects'](a){if(!a['owner']||!isValidWowAddress(normalizeWowAddress(a['owner'])))throw new Error('Invalid\x20Wow\x20address');return await this['transport']['request']({'method':'wx_getOwnedObjects','params':[a['owner'],{'filter':a['filter'],'options':a['options']},a['cursor'],a['limit']],'signal':a['signal']});}async['getObject'](a){if(!a['id']||!isValidWowObjectId(normalizeWowObjectId(a['id'])))throw new Error('Invalid\x20object\x20ID');return await this['transport']['request']({'method':'w_getObject','params':[a['id'],a['options']],'signal':a['signal']});}async['tryGetPastObject'](a){return await this['transport']['request']({'method':'w_tryGetPastObject','params':[a['id'],a['version'],a['options']],'signal':a['signal']});}async['multiGetObjects'](a){a['ids']['forEach'](c=>{if(!c||!isValidWowObjectId(normalizeWowObjectId(c)))throw new Error('Invalid\x20object\x20ID\x20'+c);});const b=a['ids']['length']!==new Set(a['ids'])['size'];if(b)throw new Error('Duplicate\x20object\x20ids\x20in\x20batch\x20call\x20'+a['ids']);return await this['transport']['request']({'method':'w_multiGetObjects','params':[a['ids'],a['options']],'signal':a['signal']});}async['queryTransactionBlocks']({filter:a,options:b,cursor:c,limit:d,order:e,signal:f}){return await this['transport']['request']({'method':'wx_queryTransactionBlocks','params':[{'filter':a,'options':b},c,d,(e||'descending')==='descending'],'signal':f});}async['getTransactionBlock'](a){if(!isValidTransactionDigest(a['digest']))throw new Error('Invalid\x20Transaction\x20digest');return await this['transport']['request']({'method':'w_getTransactionBlock','params':[a['digest'],a['options']],'signal':a['signal']});}async['multiGetTransactionBlocks'](a){a['digests']['forEach'](c=>{if(!isValidTransactionDigest(c))throw new Error('Invalid\x20Transaction\x20digest\x20'+c);});const b=a['digests']['length']!==new Set(a['digests'])['size'];if(b)throw new Error('Duplicate\x20digests\x20in\x20batch\x20call\x20'+a['digests']);return await this['transport']['request']({'method':'w_multiGetTransactionBlocks','params':[a['digests'],a['options']],'signal':a['signal']});}async['executeTransactionBlock']({transactionBlock:a,signature:b,options:c,requestType:d,signal:f}){const g=await this['transport']['request']({'method':'w_executeTransactionBlock','params':[typeof a==='string'?a:toBase64(a),Array['isArray'](b)?b:[b],c],'signal':f});if(d==='WaitForLocalExecution')try{await this['waitForTransaction']({'digest':g['digest'],'signal':f});}catch(h){}return g;}async['signAndExecuteTransaction']({transaction:a,signer:b,...c}){let d;a instanceof Uint8Array?d=a:(a['setSenderIfNotSet'](b['toWAddress']()),d=await a['build']({'client':this}));const {signature:e,bytes:f}=await b['signTransaction'](d);return this['executeTransactionBlock']({'transactionBlock':f,'signature':e,...c});}async['getTotalTransactionBlocks']({signal:a}={}){const b=await this['transport']['request']({'method':'w_getTotalTransactionBlocks','params':[],'signal':a});return BigInt(b);}async['getReferenceGasPrice']({signal:a}={}){const b=await this['transport']['request']({'method':'wx_getReferenceGasPrice','params':[],'signal':a});return BigInt(b);}async['getStakes'](a){if(!a['owner']||!isValidWowAddress(normalizeWowAddress(a['owner'])))throw new Error('Invalid\x20Wow\x20address');return await this['transport']['request']({'method':'wx_getStakes','params':[a['owner']],'signal':a['signal']});}async['getStakesByIds'](a){return a['stakedWowIds']['forEach'](b=>{if(!b||!isValidWowObjectId(normalizeWowObjectId(b)))throw new Error('Invalid\x20Wow\x20Stake\x20id\x20'+b);}),await this['transport']['request']({'method':'wx_getStakesByIds','params':[a['stakedWowIds']],'signal':a['signal']});}async['getLatestWowSystemState']({signal:a}={}){return await this['transport']['request']({'method':'wx_getLatestWowSystemState','params':[],'signal':a});}async['queryEvents']({query:a,cursor:b,limit:c,order:d,signal:e}){return await this['transport']['request']({'method':'wx_queryEvents','params':[a,b,c,(d||'descending')==='descending'],'signal':e});}async['subscribeEvent'](a){return this['transport']['subscribe']({'method':'wx_subscribeEvent','unsubscribe':'wx_unsubscribeEvent','params':[a['filter']],'onMessage':a['onMessage'],'signal':a['signal']});}async['subscribeTransaction'](a){return this['transport']['subscribe']({'method':'wx_subscribeTransaction','unsubscribe':'wx_unsubscribeTransaction','params':[a['filter']],'onMessage':a['onMessage'],'signal':a['signal']});}async['devInspectTransactionBlock'](a){let b;if(isTransaction(a['transactionBlock']))a['transactionBlock']['setSenderIfNotSet'](a['sender']),b=toBase64(await a['transactionBlock']['build']({'client':this,'onlyTransactionKind':!![]}));else{if(typeof a['transactionBlock']==='string')b=a['transactionBlock'];else{if(a['transactionBlock']instanceof Uint8Array)b=toBase64(a['transactionBlock']);else throw new Error('Unknown\x20transaction\x20block\x20format.');}}return a['signal']?.['throwIfAborted'](),await this['transport']['request']({'method':'w_devInspectTransactionBlock','params':[a['sender'],b,a['gasPrice']?.['toString'](),a['epoch']],'signal':a['signal']});}async['dryRunTransactionBlock'](a){return await this['transport']['request']({'method':'w_dryRunTransactionBlock','params':[typeof a['transactionBlock']==='string'?a['transactionBlock']:toBase64(a['transactionBlock'])]});}async['getDynamicFields'](a){if(!a['parentId']||!isValidWowObjectId(normalizeWowObjectId(a['parentId'])))throw new Error('Invalid\x20WOW\x20Object\x20id');return await this['transport']['request']({'method':'wx_getDynamicFields','params':[a['parentId'],a['cursor'],a['limit']],'signal':a['signal']});}async['getDynamicFieldObject'](a){return await this['transport']['request']({'method':'wx_getDynamicFieldObject','params':[a['parentId'],a['name']],'signal':a['signal']});}async['getLatestCheckpointSequenceNumber']({signal:a}={}){const b=await this['transport']['request']({'method':'w_getLatestCheckpointSequenceNumber','params':[],'signal':a});return String(b);}async['getCheckpoint'](a){return await this['transport']['request']({'method':'w_getCheckpoint','params':[a['id']],'signal':a['signal']});}async['getCheckpoints'](a){return await this['transport']['request']({'method':'w_getCheckpoints','params':[a['cursor'],a?.['limit'],a['descendingOrder']],'signal':a['signal']});}async['getCommitteeInfo'](a){return await this['transport']['request']({'method':'wx_getCommitteeInfo','params':[a?.['epoch']],'signal':a?.['signal']});}async['getNetworkMetrics']({signal:a}={}){return await this['transport']['request']({'method':'wx_getNetworkMetrics','params':[],'signal':a});}async['getAddressMetrics']({signal:a}={}){return await this['transport']['request']({'method':'wx_getLatestAddressMetrics','params':[],'signal':a});}async['getEpochMetrics'](a){return await this['transport']['request']({'method':'wx_getEpochMetrics','params':[a?.['cursor'],a?.['limit'],a?.['descendingOrder']],'signal':a?.['signal']});}async['getAllEpochAddressMetrics'](a){return await this['transport']['request']({'method':'wx_getAllEpochAddressMetrics','params':[a?.['descendingOrder']],'signal':a?.['signal']});}async['getEpochs'](a){return await this['transport']['request']({'method':'wx_getEpochs','params':[a?.['cursor'],a?.['limit'],a?.['descendingOrder']],'signal':a?.['signal']});}async['getMoveCallMetrics']({signal:a}={}){return await this['transport']['request']({'method':'wx_getMoveCallMetrics','params':[],'signal':a});}async['getCurrentEpoch']({signal:a}={}){return await this['transport']['request']({'method':'wx_getCurrentEpoch','params':[],'signal':a});}async['getValidatorsApy']({signal:a}={}){return await this['transport']['request']({'method':'wx_getValidatorsApy','params':[],'signal':a});}async['getChainIdentifier']({signal:a}={}){const b=await this['getCheckpoint']({'id':'0','signal':a}),c=fromBase58(b['digest']);return toHex(c['slice'](0x0,0x4));}async['getProtocolConfig'](a){return await this['transport']['request']({'method':'w_getProtocolConfig','params':[a?.['version']],'signal':a?.['signal']});}async['waitForTransaction']({signal:a,timeout:timeout=0x3c*0x3e8,pollInterval:pollInterval=0x2*0x3e8,...b}){const c=AbortSignal['timeout'](timeout),d=new Promise((e,f)=>{c['addEventListener']('abort',()=>f(c['reason']));});d['catch'](()=>{});while(!c['aborted']){a?.['throwIfAborted']();try{return await this['getTransactionBlock'](b);}catch{await Promise['race']([new Promise(e=>setTimeout(e,pollInterval)),d]);}}c['throwIfAborted']();throw new Error('Unexpected\x20error\x20while\x20waiting\x20for\x20transaction\x20block.');}}

package/dist/cjs/jsonRpc/core.d.ts

@@ -0,0 +1,87 @@
+import { TransactionDataBuilder } from "../transactions/TransactionData.js";
+import { Experimental_CoreClient } from "../experimental/core.js";
+import type { Experimental_WowClientTypes } from "../experimental/types.js";
+import type { WowJsonRpcClient } from "./client.js";
+export declare class JSONRpcCoreClient extends Experimental_CoreClient {
+    #private;
+    constructor({ jsonRpcClient }: {
+        jsonRpcClient: WowJsonRpcClient;
+    });
+    getObjects(options: Experimental_WowClientTypes.GetObjectsOptions): Promise<{
+        objects: (Error | Experimental_WowClientTypes.ObjectResponse)[];
+    }>;
+    getOwnedObjects(options: Experimental_WowClientTypes.GetOwnedObjectsOptions): Promise<{
+        objects: Experimental_WowClientTypes.ObjectResponse[];
+        hasNextPage: boolean;
+        cursor: string;
+    }>;
+    getCoins(options: Experimental_WowClientTypes.GetCoinsOptions): Promise<{
+        objects: {
+            id: string;
+            version: string;
+            digest: string;
+            balance: string;
+            type: string;
+            content: Promise<any>;
+            owner: {
+                $kind: "ObjectOwner";
+                ObjectOwner: string;
+            };
+            previousTransaction: string;
+        }[];
+        hasNextPage: boolean;
+        cursor: string;
+    }>;
+    getBalance(options: Experimental_WowClientTypes.GetBalanceOptions): Promise<{
+        balance: {
+            coinType: string;
+            balance: string;
+        };
+    }>;
+    getAllBalances(options: Experimental_WowClientTypes.GetAllBalancesOptions): Promise<{
+        balances: {
+            coinType: string;
+            balance: string;
+        }[];
+        hasNextPage: boolean;
+        cursor: any;
+    }>;
+    getTransaction(options: Experimental_WowClientTypes.GetTransactionOptions): Promise<{
+        transaction: Experimental_WowClientTypes.TransactionResponse;
+    }>;
+    executeTransaction(options: Experimental_WowClientTypes.ExecuteTransactionOptions): Promise<{
+        transaction: Experimental_WowClientTypes.TransactionResponse;
+    }>;
+    dryRunTransaction(options: Experimental_WowClientTypes.DryRunTransactionOptions): Promise<{
+        transaction: {
+            digest: string;
+            epoch: any;
+            effects: Experimental_WowClientTypes.TransactionEffects;
+            objectTypes: Promise<Record<string, string>>;
+            signatures: any[];
+            transaction: Experimental_WowClientTypes.TransactionData;
+            balanceChanges: {
+                coinType: string;
+                address: string;
+                amount: string;
+            }[];
+        };
+    }>;
+    getReferenceGasPrice(options?: Experimental_WowClientTypes.GetReferenceGasPriceOptions): Promise<{
+        referenceGasPrice: string;
+    }>;
+    getDynamicFields(options: Experimental_WowClientTypes.GetDynamicFieldsOptions): Promise<{
+        dynamicFields: {
+            id: string;
+            type: string;
+            name: {
+                type: string;
+                bcs: Uint8Array<ArrayBuffer>;
+            };
+        }[];
+        hasNextPage: boolean;
+        cursor: string;
+    }>;
+    resolveTransactionPlugin(): (transactionData: TransactionDataBuilder, options: import("../index.js").BuildTransactionOptions, next: () => Promise<void>) => Promise<void>;
+    getMoveFunction(options: Experimental_WowClientTypes.GetMoveFunctionOptions): Promise<Experimental_WowClientTypes.GetMoveFunctionResponse>;
+}

package/dist/cjs/jsonRpc/core.js

@@ -0,0 +1 @@
+import{fromBase64}from'../_deps/bcs/index.js';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'../_deps/utils/index.js';import{normalizeWowAddress}from'../utils/wow-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=>parseNormalizedWowMoveType(c)),'returns':b['return']['map'](c=>parseNormalizedWowMoveType(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 parseNormalizedWowMoveType(a){if(typeof a!=='string'){if('Reference'in a)return{'reference':'immutable','body':parseNormalizedWowMoveTypeBody(a['Reference'])};if('MutableReference'in a)return{'reference':'mutable','body':parseNormalizedWowMoveTypeBody(a['MutableReference'])};}return{'reference':null,'body':parseNormalizedWowMoveTypeBody(a)};}function parseNormalizedWowMoveTypeBody(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':parseNormalizedWowMoveTypeBody(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=>parseNormalizedWowMoveTypeBody(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/cjs/jsonRpc/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class WowHTTPTransportError extends Error {
+}
+export declare class JsonRpcError extends WowHTTPTransportError {
+    code: number;
+    type: string;
+    constructor(message: string, code: number);
+}
+export declare class WowHTTPStatusError extends WowHTTPTransportError {
+    status: number;
+    statusText: string;
+    constructor(message: string, status: number, statusText: string);
+}

package/dist/cjs/jsonRpc/errors.js

@@ -0,0 +1 @@
+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 WowHTTPTransportError extends Error{}export class JsonRpcError extends WowHTTPTransportError{['code'];['type'];constructor(a,b){super(a),this['code']=b,this['type']=CODE_TO_ERROR_TYPE[b]??'ServerError';}}export class WowHTTPStatusError extends WowHTTPTransportError{['status'];['statusText'];constructor(a,b,c){super(a),this['status']=b,this['statusText']=c;}}

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

@@ -0,0 +1,39 @@
+import type { WebsocketClientOptions } from "./rpc-websocket-client.js";
+export type HttpHeaders = {
+    [header: string]: string;
+};
+export interface JsonRpcHTTPTransportOptions {
+    fetch?: typeof fetch;
+    WebSocketConstructor?: typeof WebSocket;
+    url: string;
+    rpc?: {
+        headers?: HttpHeaders;
+        url?: string;
+    };
+    websocket?: WebsocketClientOptions & {
+        url?: string;
+    };
+}
+export interface JsonRpcTransportRequestOptions {
+    method: string;
+    params: unknown[];
+    signal?: AbortSignal;
+}
+export interface JsonRpcTransportSubscribeOptions<T> {
+    method: string;
+    unsubscribe: string;
+    params: unknown[];
+    onMessage: (event: T) => void;
+    signal?: AbortSignal;
+}
+export interface JsonRpcTransport {
+    request<T = unknown>(input: JsonRpcTransportRequestOptions): Promise<T>;
+    subscribe<T = unknown>(input: JsonRpcTransportSubscribeOptions<T>): Promise<() => Promise<boolean>>;
+}
+export declare class JsonRpcHTTPTransport implements JsonRpcTransport {
+    #private;
+    constructor(options: JsonRpcHTTPTransportOptions);
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+    request<T>(input: JsonRpcTransportRequestOptions): Promise<T>;
+    subscribe<T>(input: JsonRpcTransportSubscribeOptions<T>): Promise<() => Promise<boolean>>;
+}

package/dist/cjs/jsonRpc/http-transport.js

@@ -0,0 +1 @@
+import{PACKAGE_VERSION,TARGETED_RPC_VERSION}from'../version.js';import{JsonRpcError,WowHTTPStatusError}from'./errors.js';import{WebsocketClient}from'./rpc-websocket-client.js';export class JsonRpcHTTPTransport{#requestId=0x0;#options;#websocketClient;constructor(a){this.#options=a;}['fetch'](a,b){const c=this.#options['fetch']??fetch;if(!c)throw new Error('The\x20current\x20environment\x20does\x20not\x20support\x20fetch,\x20you\x20can\x20provide\x20a\x20fetch\x20implementation\x20in\x20the\x20options\x20for\x20WowHTTPTransport.');return c(a,b);}#getWebsocketClient(){if(!this.#websocketClient){const a=this.#options['WebSocketConstructor']??WebSocket;if(!a)throw new Error('The\x20current\x20environment\x20does\x20not\x20support\x20WebSocket,\x20you\x20can\x20provide\x20a\x20WebSocketConstructor\x20in\x20the\x20options\x20for\x20WowHTTPTransport.');this.#websocketClient=new WebsocketClient(this.#options['websocket']?.['url']??this.#options['url'],{'WebSocketConstructor':a,...this.#options['websocket']});}return this.#websocketClient;}async['request'](a){this.#requestId+=0x1;const b=await this['fetch'](this.#options['rpc']?.['url']??this.#options['url'],{'method':'POST','signal':a['signal'],'headers':{'Content-Type':'application/json','Client-Sdk-Type':'typescript','Client-Sdk-Version':PACKAGE_VERSION,'Client-Target-Api-Version':TARGETED_RPC_VERSION,'Client-Request-Method':a['method'],...this.#options['rpc']?.['headers']},'body':JSON['stringify']({'jsonrpc':'2.0','id':this.#requestId,'method':a['method'],'params':a['params']})});if(!b['ok'])throw new WowHTTPStatusError('Unexpected\x20status\x20code:\x20'+b['status'],b['status'],b['statusText']);const c=await b['json']();if('error'in c&&c['error']!=null)throw new JsonRpcError(c['error']['message'],c['error']['code']);return c['result'];}async['subscribe'](a){const b=await this.#getWebsocketClient()['subscribe'](a);return a['signal']&&(a['signal']['throwIfAborted'](),a['signal']['addEventListener']('abort',()=>{b();})),async()=>!!await b();}}

package/dist/cjs/jsonRpc/index.d.ts

@@ -0,0 +1,4 @@
+export { type JsonRpcTransport, type JsonRpcTransportRequestOptions, type JsonRpcTransportSubscribeOptions, type HttpHeaders, type JsonRpcHTTPTransportOptions, JsonRpcHTTPTransport, } from "./http-transport.js";
+export type * from "./types/index.js";
+export { type WowJsonRpcClientOptions, type PaginationArguments, type OrderArguments, isWowJsonRpcClient, WowJsonRpcClient, } from "./client.js";
+export { WowHTTPStatusError, WowHTTPTransportError, JsonRpcError, } from "./errors.js";

package/dist/cjs/jsonRpc/index.js

@@ -0,0 +1 @@
+export{JsonRpcHTTPTransport}from'./http-transport.js';export{isWowJsonRpcClient,WowJsonRpcClient}from'./client.js';export{WowHTTPStatusError,WowHTTPTransportError,JsonRpcError}from'./errors.js';

package/dist/cjs/jsonRpc/json-rpc-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { TransactionDataBuilder } from "../transactions/TransactionData.js";
+import type { BuildTransactionOptions } from "../transactions/index.js";
+import type { WowJsonRpcClient } from "./client.js";
+export declare function jsonRpcClientResolveTransactionPlugin(client: WowJsonRpcClient): (transactionData: TransactionDataBuilder, options: BuildTransactionOptions, next: () => Promise<void>) => Promise<void>;

package/dist/cjs/jsonRpc/json-rpc-resolver.js

@@ -0,0 +1 @@
+import{parse}from'valibot';import{normalizeWowAddress,normalizeWowObjectId,WOW_TYPE_ARG}from'../utils/index.js';import{ObjectRefSchema}from'../transactions/data/internal.js';import{Inputs}from'../transactions/Inputs.js';import{getPureBcsSchema,isTxContext,normalizedTypeToMoveTypeSignature}from'../transactions/serializer.js';import{chunk}from'../_deps/utils/index.js';const MAX_OBJECTS_PER_FETCH=0x32,GAS_SAFE_OVERHEAD=0x3e8n,MAX_GAS=0xba43b7400;export function jsonRpcClientResolveTransactionPlugin(a){return async function b(c,d,e){return await normalizeInputs(c,a),await resolveObjectReferences(c,a),!d['onlyTransactionKind']&&(await setGasPrice(c,a),await setGasBudget(c,a),await setGasPayment(c,a)),await e();};}async function setGasPrice(a,b){!a['gasConfig']['price']&&(a['gasConfig']['price']=String(await b['getReferenceGasPrice']()));}async function setGasBudget(a,b){if(a['gasConfig']['budget'])return;const c=await b['dryRunTransactionBlock']({'transactionBlock':a['build']({'overrides':{'gasData':{'budget':String(MAX_GAS),'payment':[]}}})});if(c['effects']['status']['status']!=='success'){const g=new Error('Dry\x20run\x20failed,\x20could\x20not\x20automatically\x20determine\x20a\x20budget:\x20'+c['effects']['status']['error']);g['cause']=c;throw g;}const d=GAS_SAFE_OVERHEAD*BigInt(a['gasConfig']['price']||0x1n),e=BigInt(c['effects']['gasUsed']['computationCost'])+d,f=e+BigInt(c['effects']['gasUsed']['storageCost'])-BigInt(c['effects']['gasUsed']['storageRebate']);a['gasConfig']['budget']=String(f>e?f:e);}async function setGasPayment(a,b){if(!a['gasConfig']['payment']){const c=await b['getCoins']({'owner':a['gasConfig']['owner']||a['sender'],'coinType':WOW_TYPE_ARG}),d=c['data']['filter'](e=>{const f=a['inputs']['find'](g=>{if(g['Object']?.['ImmOrOwnedObject'])return e['coinObjectId']===g['Object']['ImmOrOwnedObject']['objectId'];return![];});return!f;})['map'](e=>({'objectId':e['coinObjectId'],'digest':e['digest'],'version':e['version']}));if(!d['length'])throw new Error('No\x20valid\x20gas\x20coins\x20found\x20for\x20the\x20transaction.');a['gasConfig']['payment']=d['map'](e=>parse(ObjectRefSchema,e));}}async function resolveObjectReferences(a,b){const c=a['inputs']['filter'](k=>{return k['UnresolvedObject']&&!(k['UnresolvedObject']['version']||k['UnresolvedObject']?.['initialSharedVersion']);}),d=[...new Set(c['map'](k=>normalizeWowObjectId(k['UnresolvedObject']['objectId'])))],e=d['length']?chunk(d,MAX_OBJECTS_PER_FETCH):[],f=(await Promise['all'](e['map'](k=>b['multiGetObjects']({'ids':k,'options':{'showOwner':!![]}}))))['flat'](),g=new Map(d['map']((k,l)=>{return[k,f[l]];})),h=Array['from'](g)['filter'](([k,l])=>l['error'])['map'](([k,l])=>JSON['stringify'](l['error']));if(h['length'])throw new Error('The\x20following\x20input\x20objects\x20are\x20invalid:\x20'+h['join'](',\x20'));const i=f['map'](k=>{if(k['error']||!k['data'])throw new Error('Failed\x20to\x20fetch\x20object:\x20'+k['error']);const l=k['data']['owner'],m=l&&typeof l==='object'?'Shared'in l?l['Shared']['initial_shared_version']:'ConsensusAddressOwner'in l?l['ConsensusAddressOwner']['start_version']:null:null;return{'objectId':k['data']['objectId'],'digest':k['data']['digest'],'version':k['data']['version'],'initialSharedVersion':m};}),j=new Map(d['map']((k,l)=>{return[k,i[l]];}));for(const [k,l]of a['inputs']['entries']()){if(!l['UnresolvedObject'])continue;let m;const n=normalizeWowAddress(l['UnresolvedObject']['objectId']),o=j['get'](n);if(l['UnresolvedObject']['initialSharedVersion']??o?.['initialSharedVersion'])m=Inputs['SharedObjectRef']({'objectId':n,'initialSharedVersion':l['UnresolvedObject']['initialSharedVersion']||o?.['initialSharedVersion'],'mutable':l['UnresolvedObject']['mutable']||isUsedAsMutable(a,k)});else isUsedAsReceiving(a,k)&&(m=Inputs['ReceivingRef']({'objectId':n,'digest':l['UnresolvedObject']['digest']??o?.['digest'],'version':l['UnresolvedObject']['version']??o?.['version']}));a['inputs'][a['inputs']['indexOf'](l)]=m??Inputs['ObjectRef']({'objectId':n,'digest':l['UnresolvedObject']['digest']??o?.['digest'],'version':l['UnresolvedObject']['version']??o?.['version']});}}async function normalizeInputs(a,b){const {inputs:c,commands:d}=a,e=[],f=new Set();d['forEach'](h=>{if(h['MoveCall']){if(h['MoveCall']['_argumentTypes'])return;const i=h['MoveCall']['arguments']['map'](k=>{if(k['$kind']==='Input')return a['inputs'][k['Input']];return null;}),j=i['some'](k=>k?.['UnresolvedPure']||k?.['UnresolvedObject']&&typeof k?.['UnresolvedObject']['mutable']!=='boolean');if(j){const k=h['MoveCall']['package']+'::'+h['MoveCall']['module']+'::'+h['MoveCall']['function'];f['add'](k),e['push'](h['MoveCall']);}}});const g=new Map();f['size']>0x0&&await Promise['all']([...f]['map'](async h=>{const [i,j,k]=h['split']('::'),l=await b['getNormalizedMoveFunction']({'package':i,'module':j,'function':k});g['set'](h,l['parameters']['map'](m=>normalizedTypeToMoveTypeSignature(m)));})),e['length']&&await Promise['all'](e['map'](async h=>{const i=g['get'](h['package']+'::'+h['module']+'::'+h['function']);if(!i)return;const j=i['length']>0x0&&isTxContext(i[i['length']-0x1]),k=j?i['slice'](0x0,i['length']-0x1):i;h['_argumentTypes']=k;})),d['forEach'](h=>{if(!h['MoveCall'])return;const i=h['MoveCall'],j=i['package']+'::'+i['module']+'::'+i['function'],k=i['_argumentTypes'];if(!k)return;if(k['length']!==h['MoveCall']['arguments']['length'])throw new Error('Incorrect\x20number\x20of\x20arguments\x20for\x20'+j);k['forEach']((l,m)=>{const n=i['arguments'][m];if(n['$kind']!=='Input')return;const o=c[n['Input']];if(!o['UnresolvedPure']&&!o['UnresolvedObject'])return;const p=o['UnresolvedPure']?.['value']??o['UnresolvedObject']?.['objectId'],q=getPureBcsSchema(l['body']);if(q){n['type']='pure',c[c['indexOf'](o)]=Inputs['Pure'](q['serialize'](p));return;}if(typeof p!=='string')throw new Error('Expect\x20the\x20argument\x20to\x20be\x20an\x20object\x20id\x20string,\x20got\x20'+JSON['stringify'](p,null,0x2));n['type']='object';const r=o['UnresolvedPure']?{'$kind':'UnresolvedObject','UnresolvedObject':{'objectId':p}}:o;c[n['Input']]=r;});});}function isUsedAsMutable(a,b){let c=![];return a['getInputUses'](b,(d,e)=>{if(e['MoveCall']&&e['MoveCall']['_argumentTypes']){const f=e['MoveCall']['arguments']['indexOf'](d);c=e['MoveCall']['_argumentTypes'][f]['ref']!=='&'||c;}(e['$kind']==='MakeMoveVec'||e['$kind']==='MergeCoins'||e['$kind']==='SplitCoins'||e['$kind']==='TransferObjects')&&(c=!![]);}),c;}function isUsedAsReceiving(a,b){let c=![];return a['getInputUses'](b,(d,e)=>{if(e['MoveCall']&&e['MoveCall']['_argumentTypes']){const f=e['MoveCall']['arguments']['indexOf'](d);c=isReceivingType(e['MoveCall']['_argumentTypes'][f])||c;}}),c;}function isReceivingType(a){if(typeof a['body']!=='object'||!('datatype'in a['body']))return![];return a['body']['datatype']['package']==='0x2'&&a['body']['datatype']['module']==='transfer'&&a['body']['datatype']['type']==='Receiving';}

package/dist/cjs/jsonRpc/rpc-websocket-client.d.ts

@@ -0,0 +1,28 @@
+type SubscriptionRequest<T = any> = {
+    method: string;
+    unsubscribe: string;
+    params: any[];
+    onMessage: (event: T) => void;
+    signal?: AbortSignal;
+};
+export type WebsocketClientOptions = {
+    WebSocketConstructor?: typeof WebSocket;
+    callTimeout?: number;
+    reconnectTimeout?: number;
+    maxReconnects?: number;
+};
+export declare const DEFAULT_CLIENT_OPTIONS: {
+    WebSocketConstructor: typeof WebSocket;
+    callTimeout: number;
+    reconnectTimeout: number;
+    maxReconnects: number;
+};
+export declare class WebsocketClient {
+    #private;
+    endpoint: string;
+    options: Required<WebsocketClientOptions>;
+    constructor(endpoint: string, options?: WebsocketClientOptions);
+    makeRequest<T>(method: string, params: any[], signal?: AbortSignal): Promise<T>;
+    subscribe<T>(input: SubscriptionRequest<T>): Promise<() => Promise<unknown>>;
+}
+export {};

package/dist/cjs/jsonRpc/rpc-websocket-client.js

@@ -0,0 +1 @@
+import{JsonRpcError}from'./errors.js';function getWebsocketUrl(a){const b=new URL(a);return b['protocol']=b['protocol']['replace']('http','ws'),b['toString']();}export const DEFAULT_CLIENT_OPTIONS={'WebSocketConstructor':typeof WebSocket!=='undefined'?WebSocket:undefined,'callTimeout':0x7530,'reconnectTimeout':0xbb8,'maxReconnects':0x5};export class WebsocketClient{['endpoint'];['options'];#requestId=0x0;#disconnects=0x0;#webSocket=null;#connectionPromise=null;#subscriptions=new Set();#pendingRequests=new Map();constructor(a,b={}){this['endpoint']=a,this['options']={...DEFAULT_CLIENT_OPTIONS,...b};if(!this['options']['WebSocketConstructor'])throw new Error('Missing\x20WebSocket\x20constructor');this['endpoint']['startsWith']('http')&&(this['endpoint']=getWebsocketUrl(this['endpoint']));}async['makeRequest'](a,b,c){const d=await this.#setupWebSocket();return new Promise((e,f)=>{this.#requestId+=0x1,this.#pendingRequests['set'](this.#requestId,{'resolve':e,'reject':f,'timeout':setTimeout(()=>{this.#pendingRequests['delete'](this.#requestId),f(new Error('Request\x20timeout:\x20'+a));},this['options']['callTimeout'])}),c?.['addEventListener']('abort',()=>{this.#pendingRequests['delete'](this.#requestId),f(c['reason']);}),d['send'](JSON['stringify']({'jsonrpc':'2.0','id':this.#requestId,'method':a,'params':b}));})['then'](({error:e,result:f})=>{if(e)throw new JsonRpcError(e['message'],e['code']);return f;});}#setupWebSocket(){if(this.#connectionPromise)return this.#connectionPromise;return this.#connectionPromise=new Promise(a=>{this.#webSocket?.['close'](),this.#webSocket=new this['options']['WebSocketConstructor'](this['endpoint']),this.#webSocket['addEventListener']('open',()=>{this.#disconnects=0x0,a(this.#webSocket);}),this.#webSocket['addEventListener']('close',()=>{this.#disconnects++,this.#disconnects<=this['options']['maxReconnects']&&setTimeout(()=>{this.#reconnect();},this['options']['reconnectTimeout']);}),this.#webSocket['addEventListener']('message',({data:b})=>{let c;try{c=JSON['parse'](b);}catch(d){const e=new Error('Failed\x20to\x20parse\x20RPC\x20message:\x20'+b);e['cause']=d,console['error'](e);return;}if('id'in c&&c['id']!=null&&this.#pendingRequests['has'](c['id'])){const {resolve:f,timeout:g}=this.#pendingRequests['get'](c['id']);clearTimeout(g),f(c);}else{if('params'in c){const {params:h}=c;this.#subscriptions['forEach'](i=>{if(i['subscriptionId']===h['subscription'])h['subscription']===i['subscriptionId']&&i['onMessage'](h['result']);});}}});}),this.#connectionPromise;}async #reconnect(){return this.#webSocket?.['close'](),this.#connectionPromise=null,Promise['allSettled']([...this.#subscriptions]['map'](a=>a['subscribe'](this)));}async['subscribe'](a){const b=new RpcSubscription(a);return this.#subscriptions['add'](b),await b['subscribe'](this),()=>b['unsubscribe'](this);}}class RpcSubscription{['subscriptionId']=null;['input'];['subscribed']=![];constructor(a){this['input']=a;}['onMessage'](a){this['subscribed']&&this['input']['onMessage'](a);}async['unsubscribe'](a){const {subscriptionId:b}=this;this['subscribed']=![];if(b==null)return![];return this['subscriptionId']=null,a['makeRequest'](this['input']['unsubscribe'],[b]);}async['subscribe'](a){this['subscriptionId']=null,this['subscribed']=!![];const b=await a['makeRequest'](this['input']['method'],this['input']['params'],this['input']['signal']);this['subscribed']&&(this['subscriptionId']=b);}}

package/dist/cjs/jsonRpc/types/chain.d.ts

@@ -0,0 +1,94 @@
+import type { Checkpoint, DynamicFieldInfo, SuiCallArg, WowMoveNormalizedModule, WowParsedData, SuiTransaction, SuiValidatorSummary } from "./generated.js";
+export type EpochInfo = {
+    epoch: string;
+    validators: SuiValidatorSummary[];
+    epochTotalTransactions: string;
+    firstCheckpointId: string;
+    epochStartTimestamp: string;
+    endOfEpochInfo: EndOfEpochInfo | null;
+    referenceGasPrice: number | null;
+};
+export type EpochMetrics = {
+    epoch: string;
+    epochTotalTransactions: string;
+    firstCheckpointId: string;
+    epochStartTimestamp: string;
+    endOfEpochInfo: EndOfEpochInfo | null;
+};
+export type EpochPage = {
+    data: EpochInfo[];
+    nextCursor: string | null;
+    hasNextPage: boolean;
+};
+export type EpochMetricsPage = {
+    data: EpochMetrics[];
+    nextCursor: string | null;
+    hasNextPage: boolean;
+};
+export type EndOfEpochInfo = {
+    lastCheckpointId: string;
+    epochEndTimestamp: string;
+    protocolVersion: string;
+    referenceGasPrice: string;
+    totalStake: string;
+    storageFundReinvestment: string;
+    storageCharge: string;
+    storageRebate: string;
+    storageFundBalance: string;
+    stakeSubsidyAmount: string;
+    totalGasFees: string;
+    totalStakeRewardsDistributed: string;
+    leftoverStorageFundInflow: string;
+};
+export type CheckpointPage = {
+    data: Checkpoint[];
+    nextCursor: string | null;
+    hasNextPage: boolean;
+};
+export type NetworkMetrics = {
+    currentTps: number;
+    tps30Days: number;
+    currentCheckpoint: string;
+    currentEpoch: string;
+    totalAddresses: string;
+    totalObjects: string;
+    totalPackages: string;
+};
+export type AddressMetrics = {
+    checkpoint: number;
+    epoch: number;
+    timestampMs: number;
+    cumulativeAddresses: number;
+    cumulativeActiveAddresses: number;
+    dailyActiveAddresses: number;
+};
+export type AllEpochsAddressMetrics = AddressMetrics[];
+export type MoveCallMetrics = {
+    rank3Days: MoveCallMetric[];
+    rank7Days: MoveCallMetric[];
+    rank30Days: MoveCallMetric[];
+};
+export type MoveCallMetric = [
+    {
+        module: string;
+        package: string;
+        function: string;
+    },
+    string
+];
+export type DynamicFieldPage = {
+    data: DynamicFieldInfo[];
+    nextCursor: string | null;
+    hasNextPage: boolean;
+};
+export type WowMoveNormalizedModules = Record<string, WowMoveNormalizedModule>;
+export type SuiMoveObject = Extract<WowParsedData, {
+    dataType: "moveObject";
+}>;
+export type SuiMovePackage = Extract<WowParsedData, {
+    dataType: "package";
+}>;
+export type ProgrammableTransaction = {
+    transactions: SuiTransaction[];
+    inputs: SuiCallArg[];
+};

package/dist/cjs/jsonRpc/types/chain.js

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

package/dist/cjs/jsonRpc/types/changes.d.ts

@@ -0,0 +1,19 @@
+import type { WowObjectChange } from "./generated.js";
+export type WowObjectChangePublished = Extract<WowObjectChange, {
+    type: "published";
+}>;
+export type WowObjectChangeTransferred = Extract<WowObjectChange, {
+    type: "transferred";
+}>;
+export type WowObjectChangeMutated = Extract<WowObjectChange, {
+    type: "mutated";
+}>;
+export type WowObjectChangeDeleted = Extract<WowObjectChange, {
+    type: "deleted";
+}>;
+export type WowObjectChangeWrapped = Extract<WowObjectChange, {
+    type: "wrapped";
+}>;
+export type WowObjectChangeCreated = Extract<WowObjectChange, {
+    type: "created";
+}>;

package/dist/cjs/jsonRpc/types/changes.js

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

package/dist/cjs/jsonRpc/types/coins.d.ts

@@ -0,0 +1,6 @@
+export type CoinBalance = {
+    coinType: string;
+    coinObjectCount: number;
+    totalBalance: string;
+    lockedBalance: Record<string, string>;
+};

package/dist/cjs/jsonRpc/types/coins.js

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

package/dist/cjs/jsonRpc/types/common.d.ts

@@ -0,0 +1,2 @@
+export type Order = "ascending" | "descending";
+export type Unsubscribe = () => Promise<boolean>;

package/dist/cjs/jsonRpc/types/common.js

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