wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,134 @@
+/**
+ * A persistent storage module that supports multi-process access with file locking mechanism.
+ * This module ensures safe concurrent read/write operations across multiple processes.
+ */
+export declare class PersistentStorage<T> {
+    private readonly filePath;
+    private readonly lock;
+    /**
+     * Creates a new PersistentStorage instance.
+     * @param filePath Path to the storage file
+     */
+    constructor(filePath: string);
+    /**
+     * Reads the entire storage content.
+     * @returns The parsed storage content
+     */
+    readAll(): Promise<T>;
+    /**
+     * Writes data to the storage.
+     * This operation is atomic and safe for multi-process access.
+     * @param data The data to write
+     */
+    writeAll(data: T): Promise<void>;
+    /**
+     * Updates a specific key in the storage.
+     * This operation is atomic and safe for multi-process access.
+     * @param key The key to update
+     * @param value The new value
+     */
+    set<K extends keyof T>(key: K, value: T[K]): Promise<void>;
+    /**
+     * Gets a specific key from the storage.
+     * @param key The key to get
+     * @returns The value associated with the key
+     */
+    get<K extends keyof T>(key: K): Promise<T[K] | undefined>;
+    /**
+     * Updates the storage using a transaction function.
+     * This operation is atomic and safe for multi-process access.
+     * @param transactionFn A function that takes the current data and returns updated data
+     */
+    transaction(transactionFn: (data: T) => T): Promise<void>;
+    /**
+     * Clears all data from the storage.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * A file-based lock implementation that supports both shared and exclusive locks.
+ * This ensures safe concurrent access across multiple processes using atomic file operations.
+ */
+export declare class Lock {
+    private readonly lockPath;
+    private readonly sharedLockPath;
+    private lockFd;
+    private sharedLockCount;
+    private exclusiveLockCount;
+    constructor(lockPath: string);
+    /**
+     * Acquires a shared lock. Multiple processes can hold a shared lock simultaneously.
+     */
+    acquireShared(): Promise<void>;
+    /**
+     * Acquires an exclusive lock. Only one process can hold an exclusive lock at a time.
+     */
+    acquireExclusive(): Promise<void>;
+    /**
+     * Releases a shared lock.
+     */
+    releaseShared(): Promise<void>;
+    /**
+     * Releases an exclusive lock.
+     */
+    releaseExclusive(): Promise<void>;
+}
+/**
+ * A simple key-value store that supports multi-process access and persistence.
+ * This is a higher-level API built on top of PersistentStorage for easier use.
+ */
+export declare class MultiProcessKVStore<T = any> {
+    private readonly storage;
+    /**
+     * Creates a new MultiProcessKVStore instance.
+     * @param filePath Path to the storage file
+     */
+    constructor(filePath: string);
+    /**
+     * Gets a value by key.
+     * @param key The key to get
+     * @returns The value associated with the key, or undefined if not found
+     */
+    get(key: string): Promise<T | undefined>;
+    /**
+     * Sets a value by key.
+     * @param key The key to set
+     * @param value The value to set
+     */
+    set(key: string, value: T): Promise<void>;
+    /**
+     * Deletes a key-value pair.
+     * @param key The key to delete
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Checks if a key exists.
+     * @param key The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Gets all keys.
+     * @returns An array of all keys
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Gets all values.
+     * @returns An array of all values
+     */
+    values(): Promise<T[]>;
+    /**
+     * Gets all key-value pairs.
+     * @returns An array of all key-value pairs
+     */
+    entries(): Promise<[string, T][]>;
+    /**
+     * Clears all key-value pairs.
+     */
+    clear(): Promise<void>;
+    /**
+     * Gets the number of key-value pairs.
+     * @returns The number of key-value pairs
+     */
+    size(): Promise<number>;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Test file for the persistent-storage module
+ * This demonstrates how to use the PersistentStorage and MultiProcessKVStore classes
+ */
+export {};

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

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

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

@@ -0,0 +1,367 @@
+import type { SerializedTransactionDataV2, TransactionPlugin } from "../transactions/index.js";
+import type { ClientCache } from "./cache.js";
+import type { Experimental_BaseClient } from "./client.js";
+export type SuiClientRegistration<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_SuiClientTypes {
+    type Network = "mainnet" | "testnet" | "devnet" | "localnet" | (string & {});
+    interface SuiClientOptions {
+        network: Network;
+        base?: Experimental_BaseClient;
+        cache?: ClientCache;
+    }
+    interface CoreClientMethodOptions {
+        signal?: AbortSignal;
+    }
+    /** Object methods */
+    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;
+    }
+    /** Balance methods */
+    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;
+    }
+    /** Transaction methods */
+    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;
+    }
+    /** Move package methods */
+    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;
+    };
+    /** ObjectOwner types */
+    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;
+    /** Effects */
+    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/faucet/faucet.d.ts

@@ -0,0 +1,66 @@
+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;
+    };
+};
+/**
+ * @deprecated "Use requestSuiFromFaucetV2 instead"
+ */
+export declare function requestSuiFromFaucetV0(input: {
+    host: string;
+    recipient: string;
+    headers?: HeadersInit;
+}): Promise<FaucetResponse>;
+/**
+ * @deprecated "Use requestSuiFromFaucetV2 instead"
+ */
+export declare function requestSuiFromFaucetV1(input: {
+    host: string;
+    recipient: string;
+    headers?: HeadersInit;
+}): Promise<BatchFaucetResponse>;
+export declare function requestSuiFromFaucetV2(input: {
+    host: string;
+    recipient: string;
+    headers?: HeadersInit;
+}): Promise<FaucetResponseV2>;
+/**
+ * @deprecated "Use requestSuiFromFaucetV2 which returns directly a success or failure status"
+ */
+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,118 @@
+class FaucetRateLimitError extends Error {
+}
+async function faucetRequest({
+  host,
+  path,
+  body,
+  headers,
+  method
+}) {
+  const endpoint = new URL(path, host).toString();
+  const requestHeaders = {
+    "Content-Type": "application/json"
+  };
+  if (headers) {
+    Object.assign(requestHeaders, headers);
+  }
+  const res = await fetch(endpoint, {
+    method,
+    body: body ? JSON.stringify(body) : void 0,
+    headers: requestHeaders
+  });
+  if (res.status === 429) {
+    throw new FaucetRateLimitError(
+      `Too many requests from this client have been sent to the faucet. Please retry later`
+    );
+  }
+  try {
+    const parsed = await res.json();
+    return parsed;
+  } catch (e) {
+    throw new Error(
+      `Encountered error when parsing response from faucet, error: ${e}, status ${res.status}, response ${res}`
+    );
+  }
+}
+async function requestSuiFromFaucetV0(input) {
+  const response = await faucetRequest({
+    host: input.host,
+    path: "/gas",
+    body: {
+      FixedAmountRequest: {
+        recipient: input.recipient
+      }
+    },
+    headers: input.headers,
+    method: "POST"
+  });
+  if (response.error) {
+    throw new Error(`Faucet request failed: ${response.error}`);
+  }
+  return response;
+}
+async function requestSuiFromFaucetV1(input) {
+  const response = await faucetRequest({
+    host: input.host,
+    path: "/v1/gas",
+    body: {
+      FixedAmountRequest: {
+        recipient: input.recipient
+      }
+    },
+    headers: input.headers,
+    method: "POST"
+  });
+  if (response.error) {
+    throw new Error(`Faucet request failed: ${response.error}`);
+  }
+  return response;
+}
+async function requestSuiFromFaucetV2(input) {
+  const response = await faucetRequest({
+    host: input.host,
+    path: "/v2/gas",
+    body: {
+      FixedAmountRequest: {
+        recipient: input.recipient
+      }
+    },
+    headers: input.headers,
+    method: "POST"
+  });
+  if (response.status !== "Success") {
+    throw new Error(
+      `Faucet request failed: ${response.status.Failure.internal}`
+    );
+  }
+  return response;
+}
+async function getFaucetRequestStatus(input) {
+  const response = await faucetRequest({
+    host: input.host,
+    path: `/v1/status/${input.taskId}`,
+    headers: input.headers,
+    method: "GET"
+  });
+  if (response.error) {
+    throw new Error(`Faucet request failed: ${response.error}`);
+  }
+  return response;
+}
+function getFaucetHost(network) {
+  switch (network) {
+    case "testnet":
+      return "https://faucet.testnet.wowok.net";
+    case "localnet":
+      return "http://127.0.0.1:9123";
+    default:
+      throw new Error(`Unknown network: ${network}`);
+  }
+}
+export {
+  FaucetRateLimitError,
+  getFaucetHost,
+  getFaucetRequestStatus,
+  requestSuiFromFaucetV0,
+  requestSuiFromFaucetV1,
+  requestSuiFromFaucetV2
+};

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

@@ -0,0 +1 @@
+export { requestSuiFromFaucetV0, requestSuiFromFaucetV1, requestSuiFromFaucetV2, getFaucetRequestStatus, getFaucetHost, FaucetRateLimitError, } from "./faucet.js";