@wowok/wowok 2.2.11

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

@@ -0,0 +1,361 @@
+import type { SerializedTransactionDataV2, TransactionPlugin } from "../transactions/index.js";
+import type { ClientCache } from "./cache.js";
+import type { Experimental_BaseClient } from "./client.js";
+export type WowClientRegistration<T extends Experimental_BaseClient = Experimental_BaseClient, Name extends string = string, Extension = unknown> = {
+    readonly name: Name;
+    readonly register: (client: T) => Extension;
+};
+export type ClientWithExtensions<T, Base extends Experimental_BaseClient = Experimental_BaseClient> = Base & T;
+export declare namespace Experimental_WowClientTypes {
+    type Network = "mainnet" | "testnet" | "devnet" | "localnet" | (string & {});
+    interface WowClientOptions {
+        network: Network;
+        base?: Experimental_BaseClient;
+        cache?: ClientCache;
+    }
+    interface CoreClientMethodOptions {
+        signal?: AbortSignal;
+    }
+    interface TransportMethods {
+        getObjects: (options: GetObjectsOptions) => Promise<GetObjectsResponse>;
+        getOwnedObjects: (options: GetOwnedObjectsOptions) => Promise<GetOwnedObjectsResponse>;
+        getCoins: (options: GetCoinsOptions) => Promise<GetCoinsResponse>;
+        getDynamicFields: (options: GetDynamicFieldsOptions) => Promise<GetDynamicFieldsResponse>;
+        getDynamicField: (options: GetDynamicFieldOptions) => Promise<GetDynamicFieldResponse>;
+    }
+    interface GetObjectsOptions extends CoreClientMethodOptions {
+        objectIds: string[];
+    }
+    interface GetObjectOptions extends CoreClientMethodOptions {
+        objectId: string;
+    }
+    interface GetOwnedObjectsOptions extends CoreClientMethodOptions {
+        address: string;
+        limit?: number;
+        cursor?: string | null;
+        type?: string;
+    }
+    interface GetCoinsOptions extends CoreClientMethodOptions {
+        address: string;
+        coinType: string;
+        limit?: number;
+        cursor?: string | null;
+    }
+    interface GetDynamicFieldsOptions extends CoreClientMethodOptions {
+        parentId: string;
+        limit?: number;
+        cursor?: string | null;
+    }
+    interface GetDynamicFieldOptions extends CoreClientMethodOptions {
+        parentId: string;
+        name: DynamicFieldName;
+    }
+    interface GetObjectsResponse {
+        objects: (ObjectResponse | Error)[];
+    }
+    interface GetObjectResponse {
+        object: ObjectResponse;
+    }
+    interface GetOwnedObjectsResponse {
+        objects: ObjectResponse[];
+        hasNextPage: boolean;
+        cursor: string | null;
+    }
+    interface GetCoinsResponse {
+        objects: CoinResponse[];
+        hasNextPage: boolean;
+        cursor: string | null;
+    }
+    interface ObjectResponse {
+        id: string;
+        version: string;
+        digest: string;
+        owner: ObjectOwner;
+        type: string;
+        content: PromiseLike<Uint8Array>;
+        previousTransaction: string | null;
+    }
+    interface CoinResponse extends ObjectResponse {
+        balance: string;
+    }
+    interface GetDynamicFieldsResponse {
+        hasNextPage: boolean;
+        cursor: string | null;
+        dynamicFields: {
+            id: string;
+            type: string;
+            name: DynamicFieldName;
+        }[];
+    }
+    interface GetDynamicFieldResponse {
+        dynamicField: {
+            name: DynamicFieldName;
+            value: DynamicFieldValue;
+            id: string;
+            version: string;
+            digest: string;
+            type: string;
+            previousTransaction: string | null;
+        };
+    }
+    interface DynamicFieldName {
+        type: string;
+        bcs: Uint8Array;
+    }
+    interface DynamicFieldValue {
+        type: string;
+        bcs: Uint8Array;
+    }
+    interface TransportMethods {
+        getBalance: (options: GetBalanceOptions) => Promise<GetBalanceResponse>;
+        getAllBalances: (options: GetAllBalancesOptions) => Promise<GetAllBalancesResponse>;
+    }
+    interface GetBalanceOptions extends CoreClientMethodOptions {
+        address: string;
+        coinType: string;
+    }
+    interface CoinBalance {
+        coinType: string;
+        balance: string;
+    }
+    interface GetBalanceResponse {
+        balance: CoinBalance;
+    }
+    interface GetAllBalancesOptions extends CoreClientMethodOptions {
+        address: string;
+        limit?: number;
+        cursor?: string | null;
+    }
+    interface GetAllBalancesResponse {
+        balances: CoinBalance[];
+        hasNextPage: boolean;
+        cursor: string | null;
+    }
+    interface TransportMethods {
+        getTransaction: (options: GetTransactionOptions) => Promise<GetTransactionResponse>;
+        executeTransaction: (options: ExecuteTransactionOptions) => Promise<ExecuteTransactionResponse>;
+        dryRunTransaction: (options: DryRunTransactionOptions) => Promise<DryRunTransactionResponse>;
+        resolveTransactionPlugin: () => TransactionPlugin;
+    }
+    interface TransactionResponse {
+        digest: string;
+        signatures: string[];
+        epoch: string | null;
+        effects: TransactionEffects;
+        objectTypes: PromiseLike<Record<string, string>>;
+        transaction: TransactionData;
+        balanceChanges: BalanceChange[];
+    }
+    interface BalanceChange {
+        coinType: string;
+        address: string;
+        amount: string;
+    }
+    interface TransactionData extends SerializedTransactionDataV2 {
+        bcs: Uint8Array;
+    }
+    interface GetTransactionOptions extends CoreClientMethodOptions {
+        digest: string;
+    }
+    interface GetTransactionResponse {
+        transaction: TransactionResponse;
+    }
+    interface ExecuteTransactionOptions extends CoreClientMethodOptions {
+        transaction: Uint8Array;
+        signatures: string[];
+    }
+    interface DryRunTransactionOptions extends CoreClientMethodOptions {
+        transaction: Uint8Array;
+    }
+    interface DryRunTransactionResponse {
+        transaction: TransactionResponse;
+    }
+    interface ExecuteTransactionResponse {
+        transaction: TransactionResponse;
+    }
+    interface GetReferenceGasPriceOptions extends CoreClientMethodOptions {
+    }
+    interface TransportMethods {
+        getReferenceGasPrice?: (options?: GetReferenceGasPriceOptions) => Promise<GetReferenceGasPriceResponse>;
+    }
+    interface GetReferenceGasPriceResponse {
+        referenceGasPrice: string;
+    }
+    interface TransportMethods {
+        getMoveFunction: (options: GetMoveFunctionOptions) => Promise<GetMoveFunctionResponse>;
+    }
+    interface GetMovePackageOptions extends CoreClientMethodOptions {
+        packageId: string;
+    }
+    interface GetMovePackageResponse {
+        package: PackageResponse;
+    }
+    interface PackageResponse {
+        storageId: string;
+        originalId: string;
+        version: string;
+        modules: ModuleResponse[];
+    }
+    interface ModuleResponse {
+        name: string;
+        datatypes: DatatypeResponse[];
+        functions: FunctionResponse[];
+    }
+    type DatatypeResponse = {
+        $kind: "struct";
+        typeName: string;
+        definingId: string;
+        moduleName: string;
+        name: string;
+        abilities: Ability[];
+        typeParameters: TypeParameter[];
+        fields: FieldDescriptor[];
+    } | {
+        $kind: "enum";
+        typeName: string;
+        definingId: string;
+        moduleName: string;
+        name: string;
+        abilities: Ability[];
+        typeParameters: TypeParameter[];
+        variants: VariantDescriptor[];
+    };
+    type Ability = "copy" | "drop" | "store" | "key" | "unknown";
+    type DatatypeKind = "struct" | "enum" | "unknown";
+    interface TypeParameter {
+        constraints: Ability[];
+        isPhantom: boolean;
+    }
+    interface FieldDescriptor {
+        name: string;
+        position: number;
+        type: OpenSignatureBody;
+    }
+    interface VariantDescriptor {
+        name: string;
+        position: number;
+        fields: FieldDescriptor[];
+    }
+    interface GetMoveFunctionOptions extends CoreClientMethodOptions {
+        packageId: string;
+        moduleName: string;
+        name: string;
+    }
+    interface GetMoveFunctionResponse {
+        function: FunctionResponse;
+    }
+    interface GetMoveDatatypeOptions extends CoreClientMethodOptions {
+        packageId: string;
+        moduleName: string;
+        name: string;
+    }
+    interface GetMoveDatatypeResponse {
+        datatype: DatatypeResponse;
+    }
+    type Visibility = "public" | "friend" | "private" | "unknown";
+    interface FunctionResponse {
+        packageId: string;
+        moduleName: string;
+        name: string;
+        visibility: Visibility;
+        isEntry: boolean;
+        typeParameters: TypeParameter[];
+        parameters: OpenSignature[];
+        returns: OpenSignature[];
+    }
+    type ReferenceType = "mutable" | "immutable" | "unknown";
+    type OpenSignature = {
+        reference: ReferenceType | null;
+        body: OpenSignatureBody;
+    };
+    type OpenSignatureBody = {
+        $kind: "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "bool" | "address" | "unknown";
+    } | {
+        $kind: "vector";
+        vector: OpenSignatureBody;
+    } | {
+        $kind: "datatype";
+        datatype: {
+            typeName: string;
+            typeParameters: OpenSignatureBody[];
+        };
+    } | {
+        $kind: "typeParameter";
+        index: number;
+    };
+    interface AddressOwner {
+        $kind: "AddressOwner";
+        AddressOwner: string;
+    }
+    interface ParentOwner {
+        $kind: "ObjectOwner";
+        ObjectOwner: string;
+    }
+    interface SharedOwner {
+        $kind: "Shared";
+        Shared: {
+            initialSharedVersion: string;
+        };
+    }
+    interface ImmutableOwner {
+        $kind: "Immutable";
+        Immutable: true;
+    }
+    interface ConsensusAddressOwner {
+        $kind: "ConsensusAddressOwner";
+        ConsensusAddressOwner: {
+            owner: string;
+            startVersion: string;
+        };
+    }
+    interface UnknownOwner {
+        $kind: "Unknown";
+    }
+    type ObjectOwner = AddressOwner | ParentOwner | SharedOwner | ImmutableOwner | ConsensusAddressOwner | UnknownOwner;
+    interface TransactionEffects {
+        bcs: Uint8Array | null;
+        digest: string;
+        version: number;
+        status: ExecutionStatus;
+        gasUsed: GasCostSummary;
+        transactionDigest: string;
+        gasObject: ChangedObject | null;
+        eventsDigest: string | null;
+        dependencies: string[];
+        lamportVersion: string | null;
+        changedObjects: ChangedObject[];
+        unchangedConsensusObjects: UnchangedConsensusObject[];
+        auxiliaryDataDigest: string | null;
+    }
+    interface ChangedObject {
+        id: string;
+        inputState: "Unknown" | "DoesNotExist" | "Exists";
+        inputVersion: string | null;
+        inputDigest: string | null;
+        inputOwner: ObjectOwner | null;
+        outputState: "Unknown" | "DoesNotExist" | "ObjectWrite" | "PackageWrite";
+        outputVersion: string | null;
+        outputDigest: string | null;
+        outputOwner: ObjectOwner | null;
+        idOperation: "Unknown" | "None" | "Created" | "Deleted";
+    }
+    interface GasCostSummary {
+        computationCost: string;
+        storageCost: string;
+        storageRebate: string;
+        nonRefundableStorageFee: string;
+    }
+    type ExecutionStatus = {
+        success: true;
+        error: null;
+    } | {
+        success: false;
+        error: string;
+    };
+    interface UnchangedConsensusObject {
+        kind: "Unknown" | "ReadOnlyRoot" | "MutateConsensusStreamEnded" | "ReadConsensusStreamEnded" | "Cancelled" | "PerEpochConfig";
+        objectId: string;
+        version: string | null;
+        digest: string | null;
+    }
+}

package/dist/esm/experimental/types.js

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

package/dist/esm/faucet/faucet.d.ts

@@ -0,0 +1,57 @@
+type HeadersInit = Record<string, string>;
+export declare class FaucetRateLimitError extends Error {
+}
+type FaucetCoinInfo = {
+    amount: number;
+    id: string;
+    transferTxDigest: string;
+};
+type FaucetResponse = {
+    transferredGasObjects: FaucetCoinInfo[];
+    error?: string | null;
+};
+type BatchFaucetResponse = {
+    task?: string | null;
+    error?: string | null;
+};
+type BatchSendStatusType = {
+    status: "INPROGRESS" | "SUCCEEDED" | "DISCARDED";
+    transferred_gas_objects: {
+        sent: FaucetCoinInfo[];
+    };
+};
+type BatchStatusFaucetResponse = {
+    status: BatchSendStatusType;
+    error?: string | null;
+};
+type FaucetResponseV2 = {
+    status: "Success" | FaucetFailure;
+    coins_sent: FaucetCoinInfo[] | null;
+};
+type FaucetFailure = {
+    Failure: {
+        internal: string;
+    };
+};
+export declare function requestWowFromFaucetV0(input: {
+    host: string;
+    recipient: string;
+    headers?: HeadersInit;
+}): Promise<FaucetResponse>;
+export declare function requestWowFromFaucetV1(input: {
+    host: string;
+    recipient: string;
+    headers?: HeadersInit;
+}): Promise<BatchFaucetResponse>;
+export declare function requestWowFromFaucetV2(input: {
+    host: string;
+    recipient: string;
+    headers?: HeadersInit;
+}): Promise<FaucetResponseV2>;
+export declare function getFaucetRequestStatus(input: {
+    host: string;
+    taskId: string;
+    headers?: HeadersInit;
+}): Promise<BatchStatusFaucetResponse>;
+export declare function getFaucetHost(network: "testnet" | "devnet" | "localnet"): "https://faucet.testnet.wowok.net" | "http://127.0.0.1:9123";
+export {};

package/dist/esm/faucet/faucet.js

@@ -0,0 +1 @@
+export class FaucetRateLimitError extends Error{}async function faucetRequest({host:a,path:b,body:c,headers:d,method:f}){const g=new URL(b,a)['toString'](),h={'Content-Type':'application/json'};d&&Object['assign'](h,d);const i=await fetch(g,{'method':f,'body':c?JSON['stringify'](c):undefined,'headers':h});if(i['status']===0x1ad)throw new FaucetRateLimitError('Too\x20many\x20requests\x20from\x20this\x20client\x20have\x20been\x20sent\x20to\x20the\x20faucet.\x20Please\x20retry\x20later');try{const j=await i['json']();return j;}catch(k){throw new Error('Encountered\x20error\x20when\x20parsing\x20response\x20from\x20faucet,\x20error:\x20'+k+',\x20status\x20'+i['status']+',\x20response\x20'+i);}}export async function requestWowFromFaucetV0(a){const b=await faucetRequest({'host':a['host'],'path':'/gas','body':{'FixedAmountRequest':{'recipient':a['recipient']}},'headers':a['headers'],'method':'POST'});if(b['error'])throw new Error('Faucet\x20request\x20failed:\x20'+b['error']);return b;}export async function requestWowFromFaucetV1(a){const b=await faucetRequest({'host':a['host'],'path':'/v1/gas','body':{'FixedAmountRequest':{'recipient':a['recipient']}},'headers':a['headers'],'method':'POST'});if(b['error'])throw new Error('Faucet\x20request\x20failed:\x20'+b['error']);return b;}export async function requestWowFromFaucetV2(a){const b=await faucetRequest({'host':a['host'],'path':'/v2/gas','body':{'FixedAmountRequest':{'recipient':a['recipient']}},'headers':a['headers'],'method':'POST'});if(b['status']!=='Success')throw new Error('Faucet\x20request\x20failed:\x20'+b['status']['Failure']['internal']);return b;}export async function getFaucetRequestStatus(a){const b=await faucetRequest({'host':a['host'],'path':'/v1/status/'+a['taskId'],'headers':a['headers'],'method':'GET'});if(b['error'])throw new Error('Faucet\x20request\x20failed:\x20'+b['error']);return b;}export function getFaucetHost(a){switch(a){case'testnet':return'https://faucet.testnet.wowok.net';case'localnet':return'http://127.0.0.1:9123';default:throw new Error('Unknown\x20network:\x20'+a);}}

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

@@ -0,0 +1 @@
+export { requestWowFromFaucetV0, requestWowFromFaucetV1, requestWowFromFaucetV2, getFaucetRequestStatus, getFaucetHost, FaucetRateLimitError, } from "./faucet.js";

package/dist/esm/faucet/index.js

@@ -0,0 +1 @@
+export{requestWowFromFaucetV0,requestWowFromFaucetV1,requestWowFromFaucetV2,getFaucetRequestStatus,getFaucetHost,FaucetRateLimitError}from'./faucet.js';

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

@@ -0,0 +1,30 @@
+import type { GrpcWebOptions } from "@protobuf-ts/grpcweb-transport";
+import { TransactionExecutionServiceClient } from "./proto/sui/rpc/v2/transaction_execution_service.client.js";
+import { LedgerServiceClient } from "./proto/sui/rpc/v2/ledger_service.client.js";
+import { MovePackageServiceClient } from "./proto/sui/rpc/v2/move_package_service.client.js";
+import { SignatureVerificationServiceClient } from "./proto/sui/rpc/v2/signature_verification_service.client.js";
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import { StateServiceClient } from "./proto/sui/rpc/v2/state_service.client.js";
+import { SubscriptionServiceClient } from "./proto/sui/rpc/v2/subscription_service.client.js";
+import { GrpcCoreClient } from "./core.js";
+import type { Experimental_WowClientTypes } from "../experimental/index.js";
+import { Experimental_BaseClient } from "../experimental/index.js";
+interface WowGrpcTransportOptions extends GrpcWebOptions {
+    transport?: never;
+}
+export type WowGrpcClientOptions = {
+    network: Experimental_WowClientTypes.Network;
+} & ({
+    transport: RpcTransport;
+} | WowGrpcTransportOptions);
+export declare class WowGrpcClient extends Experimental_BaseClient {
+    core: GrpcCoreClient;
+    transactionExecutionService: TransactionExecutionServiceClient;
+    ledgerService: LedgerServiceClient;
+    stateService: StateServiceClient;
+    subscriptionService: SubscriptionServiceClient;
+    movePackageService: MovePackageServiceClient;
+    signatureVerificationService: SignatureVerificationServiceClient;
+    constructor(options: WowGrpcClientOptions);
+}
+export {};

package/dist/esm/grpc/client.js

@@ -0,0 +1 @@
+import{GrpcWebFetchTransport}from'@protobuf-ts/grpcweb-transport';import{TransactionExecutionServiceClient}from'./proto/sui/rpc/v2/transaction_execution_service.client.js';import{LedgerServiceClient}from'./proto/sui/rpc/v2/ledger_service.client.js';import{MovePackageServiceClient}from'./proto/sui/rpc/v2/move_package_service.client.js';import{SignatureVerificationServiceClient}from'./proto/sui/rpc/v2/signature_verification_service.client.js';import{StateServiceClient}from'./proto/sui/rpc/v2/state_service.client.js';import{SubscriptionServiceClient}from'./proto/sui/rpc/v2/subscription_service.client.js';import{GrpcCoreClient}from'./core.js';import{Experimental_BaseClient}from'../experimental/index.js';export class WowGrpcClient extends Experimental_BaseClient{['core'];['transactionExecutionService'];['ledgerService'];['stateService'];['subscriptionService'];['movePackageService'];['signatureVerificationService'];constructor(a){super({'network':a['network']});const b=a['transport']??new GrpcWebFetchTransport({'baseUrl':a['baseUrl'],'fetchInit':a['fetchInit']});this['transactionExecutionService']=new TransactionExecutionServiceClient(b),this['ledgerService']=new LedgerServiceClient(b),this['stateService']=new StateServiceClient(b),this['subscriptionService']=new SubscriptionServiceClient(b),this['movePackageService']=new MovePackageServiceClient(b),this['signatureVerificationService']=new SignatureVerificationServiceClient(b),this['core']=new GrpcCoreClient({'client':this,'base':this,'network':a['network']});}}

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

@@ -0,0 +1,28 @@
+import type { Experimental_CoreClientOptions, Experimental_WowClientTypes } from "../experimental/index.js";
+import { Experimental_CoreClient } from "../experimental/index.js";
+import type { WowGrpcClient } from "./client.js";
+import type { TransactionEffects } from "./proto/sui/rpc/v2/effects.js";
+import type { BuildTransactionOptions } from "../transactions/index.js";
+import { TransactionDataBuilder } from "../transactions/index.js";
+export interface GrpcCoreClientOptions extends Experimental_CoreClientOptions {
+    client: WowGrpcClient;
+}
+export declare class GrpcCoreClient extends Experimental_CoreClient {
+    #private;
+    constructor({ client, ...options }: GrpcCoreClientOptions);
+    getObjects(options: Experimental_WowClientTypes.GetObjectsOptions): Promise<Experimental_WowClientTypes.GetObjectsResponse>;
+    getOwnedObjects(options: Experimental_WowClientTypes.GetOwnedObjectsOptions): Promise<Experimental_WowClientTypes.GetOwnedObjectsResponse>;
+    getCoins(options: Experimental_WowClientTypes.GetCoinsOptions): Promise<Experimental_WowClientTypes.GetCoinsResponse>;
+    getBalance(options: Experimental_WowClientTypes.GetBalanceOptions): Promise<Experimental_WowClientTypes.GetBalanceResponse>;
+    getAllBalances(options: Experimental_WowClientTypes.GetAllBalancesOptions): Promise<Experimental_WowClientTypes.GetAllBalancesResponse>;
+    getTransaction(options: Experimental_WowClientTypes.GetTransactionOptions): Promise<Experimental_WowClientTypes.GetTransactionResponse>;
+    executeTransaction(options: Experimental_WowClientTypes.ExecuteTransactionOptions): Promise<Experimental_WowClientTypes.ExecuteTransactionResponse>;
+    dryRunTransaction(options: Experimental_WowClientTypes.DryRunTransactionOptions): Promise<Experimental_WowClientTypes.DryRunTransactionResponse>;
+    getReferenceGasPrice(): Promise<Experimental_WowClientTypes.GetReferenceGasPriceResponse>;
+    getDynamicFields(options: Experimental_WowClientTypes.GetDynamicFieldsOptions): Promise<Experimental_WowClientTypes.GetDynamicFieldsResponse>;
+    getMoveFunction(options: Experimental_WowClientTypes.GetMoveFunctionOptions): Promise<Experimental_WowClientTypes.GetMoveFunctionResponse>;
+    resolveTransactionPlugin(): (_transactionData: TransactionDataBuilder, _options: BuildTransactionOptions, _next: () => Promise<void>) => Promise<never>;
+}
+export declare function parseTransactionEffects({ effects, }: {
+    effects: TransactionEffects | undefined;
+}): Experimental_WowClientTypes.TransactionEffects | null;

package/dist/esm/grpc/core.js

@@ -0,0 +1 @@
+import{Experimental_CoreClient}from'../experimental/index.js';import{Owner_OwnerKind}from'./proto/sui/rpc/v2/owner.js';import{chunk,fromBase64,toBase64}from'../_deps/utils/index.js';import{UnchangedConsensusObject_UnchangedConsensusObjectKind}from'./proto/sui/rpc/v2/effects.js';import{ChangedObject_IdOperation,ChangedObject_InputObjectState,ChangedObject_OutputObjectState}from'./proto/sui/rpc/v2/effects.js';import{TransactionDataBuilder}from'../transactions/index.js';import{bcs}from'../bcs/index.js';import{Ability,FunctionDescriptor_Visibility,OpenSignature_Reference,OpenSignatureBody_Type}from'./proto/sui/rpc/v2/move_package.js';export class GrpcCoreClient extends Experimental_CoreClient{#client;constructor({client:a,...b}){super(b),this.#client=a;}async['getObjects'](a){const b=chunk(a['objectIds'],0x32),c=[];for(const d of b){const e=await this.#client['ledgerService']['batchGetObjects']({'requests':d['map'](f=>({'objectId':f})),'readMask':{'paths':['owner','object_type','bcs','digest','version','object_id','previous_transaction']}});c['push'](...e['response']['objects']['map'](f=>{if(f['result']['oneofKind']==='error')return new Error(f['result']['error']['message']);if(f['result']['oneofKind']!=='object')return new Error('Unexpected\x20result\x20type');const g=f['result']['object'];return{'id':g['objectId'],'version':g['version']?.['toString'](),'digest':g['digest'],'content':Promise['resolve'](g['bcs']?.['value']),'owner':mapOwner(g['owner']),'type':g['objectType'],'previousTransaction':g['previousTransaction']??null};}));}return{'objects':c};}async['getOwnedObjects'](a){const b=await this.#client['stateService']['listOwnedObjects']({'owner':a['address'],'objectType':a['type'],'pageToken':a['cursor']?fromBase64(a['cursor']):undefined,'readMask':{'paths':['owner','object_type','bcs','digest','version','object_id','previous_transaction']}}),c=b['response']['objects']['map'](d=>({'id':d['objectId'],'version':d['version']?.['toString'](),'digest':d['digest'],get 'content'(){return d['bcs']?.['value']?Promise['resolve'](d['bcs']['value']):Promise['reject'](new Error('GRPC\x20does\x20not\x20return\x20object\x20contents\x20when\x20listing\x20owned\x20objects'));},'owner':mapOwner(d['owner']),'type':d['objectType'],'previousTransaction':d['previousTransaction']??null}));return{'objects':c,'cursor':b['response']['nextPageToken']?toBase64(b['response']['nextPageToken']):null,'hasNextPage':b['response']['nextPageToken']!==undefined};}async['getCoins'](a){const b=await this.#client['stateService']['listOwnedObjects']({'owner':a['address'],'objectType':'0x2::coin::Coin<'+a['coinType']+'>','pageToken':a['cursor']?fromBase64(a['cursor']):undefined,'readMask':{'paths':['owner','object_type','bcs','digest','version','object_id','balance','previous_transaction']}});return{'objects':b['response']['objects']['map'](c=>({'id':c['objectId'],'version':c['version']?.['toString'](),'digest':c['digest'],get 'content'(){return c['bcs']?.['value']?Promise['resolve'](c['bcs']['value']):Promise['reject'](new Error('GRPC\x20does\x20not\x20return\x20object\x20contents\x20when\x20listing\x20owned\x20objects'));},'owner':mapOwner(c['owner']),'type':c['objectType'],'balance':c['balance']?.['toString'](),'previousTransaction':c['previousTransaction']??null})),'cursor':b['response']['nextPageToken']?toBase64(b['response']['nextPageToken']):null,'hasNextPage':b['response']['nextPageToken']!==undefined};}async['getBalance'](a){const b=await this.#client['stateService']['getBalance']({'owner':a['address'],'coinType':a['coinType']});return{'balance':{'balance':b['response']['balance']?.['balance']?.['toString']()??'0','coinType':b['response']['balance']?.['coinType']??a['coinType']}};}async['getAllBalances'](a){const b=await this.#client['stateService']['listBalances']({'owner':a['address'],'pageToken':a['cursor']?fromBase64(a['cursor']):undefined,'pageSize':a['limit']});return{'hasNextPage':!!b['response']['nextPageToken'],'cursor':b['response']['nextPageToken']?toBase64(b['response']['nextPageToken']):null,'balances':b['response']['balances']['map'](c=>({'balance':c['balance']?.['toString']()??'0','coinType':c['coinType']}))};}async['getTransaction'](a){const {response:b}=await this.#client['ledgerService']['getTransaction']({'digest':a['digest'],'readMask':{'paths':['digest','transaction','effects','signatures','balance_changes']}});return{'transaction':parseTransaction(b['transaction'])};}async['executeTransaction'](a){const {response:b}=await this.#client['transactionExecutionService']['executeTransaction']({'transaction':{'bcs':{'value':a['transaction']}},'signatures':a['signatures']['map'](c=>({'bcs':{'value':fromBase64(c)},'signature':{'oneofKind':undefined}})),'readMask':{'paths':['transaction.digest','transaction.transaction','transaction.effects','transaction.signatures','transaction.balance_changes']}});return{'transaction':parseTransaction(b['transaction'])};}async['dryRunTransaction'](a){const {response:b}=await this.#client['transactionExecutionService']['simulateTransaction']({'transaction':{'bcs':{'value':a['transaction']}},'readMask':{'paths':['transaction.digest','transaction.transaction','transaction.effects','transaction.signatures','transaction.balance_changes']}});return{'transaction':parseTransaction(b['transaction'])};}async['getReferenceGasPrice'](){const a=await this.#client['ledgerService']['getEpoch']({});return{'referenceGasPrice':a['response']['epoch']?.['referenceGasPrice']?.['toString']()};}async['getDynamicFields'](a){const b=await this.#client['stateService']['listDynamicFields']({'parent':a['parentId'],'pageToken':a['cursor']?fromBase64(a['cursor']):undefined});return{'dynamicFields':b['response']['dynamicFields']['map'](c=>({'id':c['fieldId'],'name':{'type':c['name']?.['name'],'bcs':c['name']?.['value']},'type':c['fieldObject']?'0x2::dynamic_field::Field<0x2::dynamic_object_field::Wrapper<'+c['name']?.['name']+'>,0x2::object::ID>':'0x2::dynamic_field::Field<'+c['name']?.['value']+','+c['valueType']+'>'})),'cursor':b['response']['nextPageToken']?toBase64(b['response']['nextPageToken']):null,'hasNextPage':b['response']['nextPageToken']!==undefined};}async['getMoveFunction'](a){const {response:b}=await this.#client['movePackageService']['getFunction']({'packageId':a['packageId'],'moduleName':a['moduleName'],'name':a['name']});let c='unknown';switch(b['function']?.['visibility']){case FunctionDescriptor_Visibility['PUBLIC']:c='public';break;case FunctionDescriptor_Visibility['PRIVATE']:c='private';break;case FunctionDescriptor_Visibility['FRIEND']:c='friend';break;}return{'function':{'packageId':a['packageId'],'moduleName':a['moduleName'],'name':b['function']?.['name'],'visibility':c,'isEntry':b['function']?.['isEntry']??![],'typeParameters':b['function']?.['typeParameters']?.['map'](({constraints:d})=>({'isPhantom':![],'constraints':d['map'](e=>{switch(e){case Ability['COPY']:return'copy';case Ability['DROP']:return'drop';case Ability['STORE']:return'store';case Ability['KEY']:return'key';default:return'unknown';}})??[]}))??[],'parameters':b['function']?.['parameters']?.['map'](d=>parseNormalizedWowMoveType(d))??[],'returns':b['function']?.['returns']?.['map'](d=>parseNormalizedWowMoveType(d))??[]}};}['resolveTransactionPlugin'](){return async function a(b,c,d){throw new Error('Transaction\x20resolution\x20is\x20not\x20supported\x20with\x20the\x20GRPC\x20client');};}}function mapOwner(a){if(!a)return null;if(a['kind']===Owner_OwnerKind['IMMUTABLE'])return{'$kind':'Immutable','Immutable':!![]};if(a['kind']===Owner_OwnerKind['ADDRESS'])return{'AddressOwner':a['address'],'$kind':'AddressOwner'};if(a['kind']===Owner_OwnerKind['OBJECT'])return{'$kind':'ObjectOwner','ObjectOwner':a['address']};if(a['kind']===Owner_OwnerKind['SHARED']){if(a['address'])return{'$kind':'ConsensusAddressOwner','ConsensusAddressOwner':{'owner':a['address'],'startVersion':a['version']?.['toString']()}};return{'$kind':'Shared','Shared':{'initialSharedVersion':a['version']?.['toString']()}};}throw new Error('Unknown\x20owner\x20kind');}function mapIdOperation(a){if(a==null)return null;switch(a){case ChangedObject_IdOperation['CREATED']:return'Created';case ChangedObject_IdOperation['DELETED']:return'Deleted';case ChangedObject_IdOperation['NONE']:case ChangedObject_IdOperation['ID_OPERATION_UNKNOWN']:return'None';default:a;return'Unknown';}}function mapInputObjectState(a){if(a==null)return null;switch(a){case ChangedObject_InputObjectState['EXISTS']:return'Exists';case ChangedObject_InputObjectState['DOES_NOT_EXIST']:return'DoesNotExist';case ChangedObject_InputObjectState['UNKNOWN']:return'Unknown';default:a;return'Unknown';}}function mapOutputObjectState(a){if(a==null)return null;switch(a){case ChangedObject_OutputObjectState['OBJECT_WRITE']:return'ObjectWrite';case ChangedObject_OutputObjectState['PACKAGE_WRITE']:return'PackageWrite';case ChangedObject_OutputObjectState['DOES_NOT_EXIST']:return'DoesNotExist';case ChangedObject_OutputObjectState['UNKNOWN']:return'Unknown';default:a;return'Unknown';}}function mapUnchangedConsensusObjectKind(a){if(a==null)return null;switch(a){case UnchangedConsensusObject_UnchangedConsensusObjectKind['UNCHANGED_CONSENSUS_OBJECT_KIND_UNKNOWN']:return'Unknown';case UnchangedConsensusObject_UnchangedConsensusObjectKind['READ_ONLY_ROOT']:return'ReadOnlyRoot';case UnchangedConsensusObject_UnchangedConsensusObjectKind['MUTATE_CONSENSUS_STREAM_ENDED']:return'MutateConsensusStreamEnded';case UnchangedConsensusObject_UnchangedConsensusObjectKind['READ_CONSENSUS_STREAM_ENDED']:return'ReadConsensusStreamEnded';case UnchangedConsensusObject_UnchangedConsensusObjectKind['CANCELED']:return'Cancelled';case UnchangedConsensusObject_UnchangedConsensusObjectKind['PER_EPOCH_CONFIG']:return'PerEpochConfig';default:a;return'Unknown';}}export function parseTransactionEffects({effects:a}){if(!a)return null;const b=a['changedObjects']['map'](c=>{return{'id':c['objectId'],'inputState':mapInputObjectState(c['inputState']),'inputVersion':c['inputVersion']?.['toString']()??null,'inputDigest':c['inputDigest']??null,'inputOwner':mapOwner(c['inputOwner']),'outputState':mapOutputObjectState(c['outputState']),'outputVersion':c['outputVersion']?.['toString']()??null,'outputDigest':c['outputDigest']??null,'outputOwner':mapOwner(c['outputOwner']),'idOperation':mapIdOperation(c['idOperation'])};});return{'bcs':a['bcs']?.['value'],'digest':a['digest'],'version':0x2,'status':a['status']?.['success']?{'success':!![],'error':null}:{'success':![],'error':JSON['stringify'](a['status']?.['error'])},'gasUsed':{'computationCost':a['gasUsed']?.['computationCost']?.['toString'](),'storageCost':a['gasUsed']?.['storageCost']?.['toString'](),'storageRebate':a['gasUsed']?.['storageRebate']?.['toString'](),'nonRefundableStorageFee':a['gasUsed']?.['nonRefundableStorageFee']?.['toString']()},'transactionDigest':a['transactionDigest'],'gasObject':{'id':a['gasObject']?.['objectId'],'inputState':mapInputObjectState(a['gasObject']?.['inputState']),'inputVersion':a['gasObject']?.['inputVersion']?.['toString']()??null,'inputDigest':a['gasObject']?.['inputDigest']??null,'inputOwner':mapOwner(a['gasObject']?.['inputOwner']),'outputState':mapOutputObjectState(a['gasObject']?.['outputState']),'outputVersion':a['gasObject']?.['outputVersion']?.['toString']()??null,'outputDigest':a['gasObject']?.['outputDigest']??null,'outputOwner':mapOwner(a['gasObject']?.['outputOwner']),'idOperation':mapIdOperation(a['gasObject']?.['idOperation'])},'eventsDigest':a['eventsDigest']??null,'dependencies':a['dependencies'],'lamportVersion':a['lamportVersion']?.['toString']()??null,'changedObjects':b,'unchangedConsensusObjects':a['unchangedConsensusObjects']['map'](c=>{return{'kind':mapUnchangedConsensusObjectKind(c['kind']),'objectId':c['objectId'],'version':c['version']?.['toString']()??null,'digest':c['digest']??null};}),'auxiliaryDataDigest':a['auxiliaryDataDigest']??null};}function parseTransaction(a){const b=bcs['SenderSignedData']['parse'](a['transaction']?.['bcs']?.['value'])[0x0],c=bcs['TransactionData']['serialize'](b['intentMessage']['value'])['toBytes'](),d=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']}),e={};a['objects']?.['objects']['forEach'](g=>{g['objectId']&&g['objectType']&&(e[g['objectId']]=g['objectType']);});const f=parseTransactionEffects({'effects':a['effects']});return{'digest':a['digest'],'epoch':a['effects']?.['epoch']?.['toString']()??null,'effects':f,'objectTypes':Promise['resolve'](e),'transaction':{'gasData':d['gasData'],'sender':d['sender'],'expiration':d['expiration'],'commands':d['commands'],'inputs':d['inputs'],'version':d['version'],'bcs':c},'signatures':b['txSignatures'],'balanceChanges':a['balanceChanges']?.['map'](g=>({'coinType':g['coinType'],'address':g['address'],'amount':g['amount']}))??[]};}function parseNormalizedWowMoveType(a){let b=null;if(a['reference']===OpenSignature_Reference['IMMUTABLE'])b='immutable';else a['reference']===OpenSignature_Reference['MUTABLE']&&(b='mutable');return{'reference':b,'body':parseNormalizedWowMoveTypeBody(a['body'])};}function parseNormalizedWowMoveTypeBody(a){switch(a['type']){case OpenSignatureBody_Type['TYPE_UNKNOWN']:return{'$kind':'unknown'};case OpenSignatureBody_Type['ADDRESS']:return{'$kind':'address'};case OpenSignatureBody_Type['BOOL']:return{'$kind':'bool'};case OpenSignatureBody_Type['U8']:return{'$kind':'u8'};case OpenSignatureBody_Type['U16']:return{'$kind':'u16'};case OpenSignatureBody_Type['U32']:return{'$kind':'u32'};case OpenSignatureBody_Type['U64']:return{'$kind':'u64'};case OpenSignatureBody_Type['U128']:return{'$kind':'u128'};case OpenSignatureBody_Type['U256']:return{'$kind':'u256'};case OpenSignatureBody_Type['VECTOR']:return{'$kind':'vector','vector':parseNormalizedWowMoveTypeBody(a['typeParameterInstantiation'][0x0])};case OpenSignatureBody_Type['DATATYPE']:return{'$kind':'datatype','datatype':{'typeName':a['typeName'],'typeParameters':a['typeParameterInstantiation']['map'](b=>parseNormalizedWowMoveTypeBody(b))}};case OpenSignatureBody_Type['TYPE_PARAMETER']:return{'$kind':'typeParameter','index':a['typeParameter']};default:return{'$kind':'unknown'};}}

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

@@ -0,0 +1,4 @@
+export { WowGrpcClient } from "./client.js";
+export { GrpcCoreClient } from "./core.js";
+export type { WowGrpcClientOptions } from "./client.js";
+export type { GrpcCoreClientOptions } from "./core.js";

package/dist/esm/grpc/index.js

@@ -0,0 +1 @@
+export{WowGrpcClient}from'./client.js';export{GrpcCoreClient}from'./core.js';

package/dist/esm/grpc/proto/google/protobuf/any.d.ts

@@ -0,0 +1,29 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import type { JsonValue } from "@protobuf-ts/runtime";
+import type { JsonReadOptions } from "@protobuf-ts/runtime";
+import type { JsonWriteOptions } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IMessageType } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+export interface Any {
+    typeUrl: string;
+    value: Uint8Array;
+}
+declare class Any$Type extends MessageType<Any> {
+    constructor();
+    pack<T extends object>(message: T, type: IMessageType<T>): Any;
+    unpack<T extends object>(any: Any, type: IMessageType<T>, options?: Partial<BinaryReadOptions>): T;
+    contains(any: Any, type: IMessageType<any> | string): boolean;
+    internalJsonWrite(any: Any, options: JsonWriteOptions): JsonValue;
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Any): Any;
+    typeNameToUrl(name: string): string;
+    typeUrlToName(url: string): string;
+    create(value?: PartialMessage<Any>): Any;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Any): Any;
+    internalBinaryWrite(message: Any, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+export declare const Any: Any$Type;
+export {};

package/dist/esm/grpc/proto/google/protobuf/any.js

@@ -0,0 +1 @@
+import{WireType}from'@protobuf-ts/runtime';import{UnknownFieldHandler}from'@protobuf-ts/runtime';import{reflectionMergePartial}from'@protobuf-ts/runtime';import{isJsonObject}from'@protobuf-ts/runtime';import{typeofJsonValue}from'@protobuf-ts/runtime';import{jsonWriteOptions}from'@protobuf-ts/runtime';import{MessageType}from'@protobuf-ts/runtime';class Any$Type extends MessageType{constructor(){super('google.protobuf.Any',[{'no':0x1,'name':'type_url','kind':'scalar','T':0x9},{'no':0x2,'name':'value','kind':'scalar','T':0xc}]);}['pack'](a,b){return{'typeUrl':this['typeNameToUrl'](b['typeName']),'value':b['toBinary'](a)};}['unpack'](a,b,c){if(!this['contains'](a,b))throw new Error('Cannot\x20unpack\x20google.protobuf.Any\x20with\x20typeUrl\x20\x27'+a['typeUrl']+'\x27\x20as\x20'+b['typeName']+'.');return b['fromBinary'](a['value'],c);}['contains'](a,b){if(!a['typeUrl']['length'])return![];let c=typeof b=='string'?b:b['typeName'],d=this['typeUrlToName'](a['typeUrl']);return c===d;}['internalJsonWrite'](a,b){if(a['typeUrl']==='')return{};let c=this['typeUrlToName'](a['typeUrl']),d=jsonWriteOptions(b),e=d['typeRegistry']?.['find'](h=>h['typeName']===c);if(!e)throw new globalThis['Error']('Unable\x20to\x20convert\x20google.protobuf.Any\x20with\x20typeUrl\x20\x27'+a['typeUrl']+'\x27\x20to\x20JSON.\x20The\x20specified\x20type\x20'+c+'\x20is\x20not\x20available\x20in\x20the\x20type\x20registry.');let f=e['fromBinary'](a['value'],{'readUnknownField':![]}),g=e['internalJsonWrite'](f,d);if(c['startsWith']('google.protobuf.')||!isJsonObject(g))g={'value':g};return g['@type']=a['typeUrl'],g;}['internalJsonRead'](a,b,c){if(!isJsonObject(a))throw new globalThis['Error']('Unable\x20to\x20parse\x20google.protobuf.Any\x20from\x20JSON\x20'+typeofJsonValue(a)+'.');if(typeof a['@type']!='string'||a['@type']=='')return this['create']();let d=this['typeUrlToName'](a['@type']),e=b?.['typeRegistry']?.['find'](g=>g['typeName']==d);if(!e)throw new globalThis['Error']('Unable\x20to\x20parse\x20google.protobuf.Any\x20from\x20JSON.\x20The\x20specified\x20type\x20'+d+'\x20is\x20not\x20available\x20in\x20the\x20type\x20registry.');let f;if(d['startsWith']('google.protobuf.')&&a['hasOwnProperty']('value'))f=e['fromJson'](a['value'],b);else{let g=Object['assign']({},a);delete g['@type'],f=e['fromJson'](g,b);}if(c===undefined)c=this['create']();return c['typeUrl']=a['@type'],c['value']=e['toBinary'](f),c;}['typeNameToUrl'](a){if(!a['length'])throw new Error('invalid\x20type\x20name:\x20'+a);return'type.googleapis.com/'+a;}['typeUrlToName'](a){if(!a['length'])throw new Error('invalid\x20type\x20url:\x20'+a);let b=a['lastIndexOf']('/'),c=b>0x0?a['substring'](b+0x1):a;if(!c['length'])throw new Error('invalid\x20type\x20url:\x20'+a);return c;}['create'](a){const b=globalThis['Object']['create'](this['messagePrototype']);b['typeUrl']='',b['value']=new Uint8Array(0x0);if(a!==undefined)reflectionMergePartial(this,b,a);return b;}['internalBinaryRead'](a,b,c,e){let f=e??this['create'](),g=a['pos']+b;while(a['pos']<g){let [h,i]=a['tag']();switch(h){case 0x1:f['typeUrl']=a['string']();break;case 0x2:f['value']=a['bytes']();break;default:let j=c['readUnknownField'];if(j==='throw')throw new globalThis['Error']('Unknown\x20field\x20'+h+'\x20(wire\x20type\x20'+i+')\x20for\x20'+this['typeName']);let k=a['skip'](i);if(j!==![])(j===!![]?UnknownFieldHandler['onRead']:j)(this['typeName'],f,h,i,k);}}return f;}['internalBinaryWrite'](a,b,c){if(a['typeUrl']!=='')b['tag'](0x1,WireType['LengthDelimited'])['string'](a['typeUrl']);if(a['value']['length'])b['tag'](0x2,WireType['LengthDelimited'])['bytes'](a['value']);let d=c['writeUnknownFields'];if(d!==![])(d==!![]?UnknownFieldHandler['onWrite']:d)(this['typeName'],a,b);return b;}}export const Any=new Any$Type();

package/dist/esm/grpc/proto/google/protobuf/duration.d.ts

@@ -0,0 +1,23 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import type { JsonValue } from "@protobuf-ts/runtime";
+import type { JsonReadOptions } from "@protobuf-ts/runtime";
+import type { JsonWriteOptions } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+export interface Duration {
+    seconds: bigint;
+    nanos: number;
+}
+declare class Duration$Type extends MessageType<Duration> {
+    constructor();
+    internalJsonWrite(message: Duration, options: JsonWriteOptions): JsonValue;
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Duration): Duration;
+    create(value?: PartialMessage<Duration>): Duration;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Duration): Duration;
+    internalBinaryWrite(message: Duration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+export declare const Duration: Duration$Type;
+export {};

package/dist/esm/grpc/proto/google/protobuf/duration.js

@@ -0,0 +1 @@
+import{WireType}from'@protobuf-ts/runtime';import{UnknownFieldHandler}from'@protobuf-ts/runtime';import{reflectionMergePartial}from'@protobuf-ts/runtime';import{typeofJsonValue}from'@protobuf-ts/runtime';import{PbLong}from'@protobuf-ts/runtime';import{MessageType}from'@protobuf-ts/runtime';class Duration$Type extends MessageType{constructor(){super('google.protobuf.Duration',[{'no':0x1,'name':'seconds','kind':'scalar','T':0x3,'L':0x0},{'no':0x2,'name':'nanos','kind':'scalar','T':0x5}]);}['internalJsonWrite'](a,b){let c=PbLong['from'](a['seconds'])['toNumber']();if(c>0x4979cb9e00||c<-0x4979cb9e00)throw new Error('Duration\x20value\x20out\x20of\x20range.');let d=a['seconds']['toString']();if(c===0x0&&a['nanos']<0x0)d='-'+d;if(a['nanos']!==0x0){let e=Math['abs'](a['nanos'])['toString']();e='0'['repeat'](0x9-e['length'])+e;if(e['substring'](0x3)==='000000')e=e['substring'](0x0,0x3);else{if(e['substring'](0x6)==='000')e=e['substring'](0x0,0x6);}d+='.'+e;}return d+'s';}['internalJsonRead'](a,b,c){if(typeof a!=='string')throw new Error('Unable\x20to\x20parse\x20Duration\x20from\x20JSON\x20'+typeofJsonValue(a)+'.\x20Expected\x20string.');let d=a['match'](/^(-?)([0-9]+)(?:\.([0-9]+))?s/);if(d===null)throw new Error('Unable\x20to\x20parse\x20Duration\x20from\x20JSON\x20string.\x20Invalid\x20format.');if(!c)c=this['create']();let [,e,f,g]=d,h=PbLong['from'](e+f);if(h['toNumber']()>0x4979cb9e00||h['toNumber']()<-0x4979cb9e00)throw new Error('Unable\x20to\x20parse\x20Duration\x20from\x20JSON\x20string.\x20Value\x20out\x20of\x20range.');c['seconds']=h['toBigInt']();if(typeof g=='string'){let i=e+g+'0'['repeat'](0x9-g['length']);c['nanos']=parseInt(i);}return c;}['create'](a){const b=globalThis['Object']['create'](this['messagePrototype']);b['seconds']=0x0n,b['nanos']=0x0;if(a!==undefined)reflectionMergePartial(this,b,a);return b;}['internalBinaryRead'](a,b,c,e){let f=e??this['create'](),g=a['pos']+b;while(a['pos']<g){let [h,i]=a['tag']();switch(h){case 0x1:f['seconds']=a['int64']()['toBigInt']();break;case 0x2:f['nanos']=a['int32']();break;default:let j=c['readUnknownField'];if(j==='throw')throw new globalThis['Error']('Unknown\x20field\x20'+h+'\x20(wire\x20type\x20'+i+')\x20for\x20'+this['typeName']);let k=a['skip'](i);if(j!==![])(j===!![]?UnknownFieldHandler['onRead']:j)(this['typeName'],f,h,i,k);}}return f;}['internalBinaryWrite'](a,b,c){if(a['seconds']!==0x0n)b['tag'](0x1,WireType['Varint'])['int64'](a['seconds']);if(a['nanos']!==0x0)b['tag'](0x2,WireType['Varint'])['int32'](a['nanos']);let d=c['writeUnknownFields'];if(d!==![])(d==!![]?UnknownFieldHandler['onWrite']:d)(this['typeName'],a,b);return b;}}export const Duration=new Duration$Type();

package/dist/esm/grpc/proto/google/protobuf/empty.d.ts

@@ -0,0 +1,16 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+export interface Empty {
+}
+declare class Empty$Type extends MessageType<Empty> {
+    constructor();
+    create(value?: PartialMessage<Empty>): Empty;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Empty): Empty;
+    internalBinaryWrite(message: Empty, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+export declare const Empty: Empty$Type;
+export {};