wowok 2.1.38 → 2.1.40

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

@@ -1,5 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 export const SIGNATURE_SCHEME_TO_FLAG = {
     ED25519: 0x00,
     Secp256k1: 0x01,
@@ -22,4 +20,3 @@ export const SIGNATURE_FLAG_TO_SCHEME = {
     0x05: "ZkLogin",
     0x06: "Passkey",
 };
-//# sourceMappingURL=signature-scheme.js.map

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

@@ -1,22 +1,11 @@
 import type { PublicKey } from "./publickey.js";
 import type { SignatureScheme } from "./signature-scheme.js";
-/**
- * Pair of signature and corresponding public key
- */
 export type SerializeSignatureInput = {
     signatureScheme: SignatureScheme;
-    /** Base64-encoded signature */
     signature: Uint8Array;
-    /** Base64-encoded public key */
     publicKey?: PublicKey;
 };
-/**
- * Takes in a signature, its associated signing scheme and a public key, then serializes this data
- */
 export declare function toSerializedSignature({ signature, signatureScheme, publicKey, }: SerializeSignatureInput): string;
-/**
- * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
- */
 export declare function parseSerializedSignature(serializedSignature: string): {
     serializedSignature: string;
     signatureScheme: "ED25519" | "Secp256k1" | "Secp256r1";

package/dist/cjs/cryptography/signature.js

@@ -1,13 +1,8 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 import { fromBase64, toBase64 } from "@mysten/bcs";
 import { bcs } from "../bcs/index.js";
 import { parseSerializedPasskeySignature } from "../keypairs/passkey/publickey.js";
 import { parseSerializedKeypairSignature } from "./publickey.js";
 import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG, } from "./signature-scheme.js";
-/**
- * Takes in a signature, its associated signing scheme and a public key, then serializes this data
- */
 export function toSerializedSignature({ signature, signatureScheme, publicKey, }) {
     if (!publicKey) {
         throw new Error("`publicKey` is required");
@@ -19,9 +14,6 @@ export function toSerializedSignature({ signature, signatureScheme, publicKey, }
     serializedSignature.set(pubKeyBytes, 1 + signature.length);
     return toBase64(serializedSignature);
 }
-/**
- * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
- */
 export function parseSerializedSignature(serializedSignature) {
     const bytes = fromBase64(serializedSignature);
     const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
@@ -47,4 +39,3 @@ export function parseSerializedSignature(serializedSignature) {
             throw new Error("Unsupported signature scheme");
     }
 }
-//# sourceMappingURL=signature.js.map

package/dist/cjs/experimental/cache.js

@@ -1,5 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 export class ClientCache {
     #prefix;
     #cache;
@@ -58,4 +56,3 @@ export class ClientCache {
         });
     }
 }
-//# sourceMappingURL=cache.js.map

package/dist/cjs/experimental/client.js

@@ -1,6 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-/* eslint-disable @typescript-eslint/ban-types */
 import { ClientCache } from "./cache.js";
 export class Experimental_BaseClient {
     network;
@@ -20,4 +17,3 @@ export class Experimental_BaseClient {
         })));
     }
 }
-//# sourceMappingURL=client.js.map

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

@@ -25,9 +25,7 @@ export declare abstract class Experimental_CoreClient extends Experimental_BaseC
     abstract getMoveFunction(options: Experimental_SuiClientTypes.GetMoveFunctionOptions): Promise<Experimental_SuiClientTypes.GetMoveFunctionResponse>;
     getDynamicField(options: Experimental_SuiClientTypes.GetDynamicFieldOptions): Promise<Experimental_SuiClientTypes.GetDynamicFieldResponse>;
     waitForTransaction({ signal, timeout, ...input }: {
-        /** An optional abort signal that can be used to cancel the wait. */
         signal?: AbortSignal;
-        /** The amount of time to wait for transaction. Defaults to one minute. */
         timeout?: number;
     } & Experimental_SuiClientTypes.GetTransactionOptions): Promise<Experimental_SuiClientTypes.GetTransactionResponse>;
 }

package/dist/cjs/experimental/core.js

@@ -1,5 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 import { TypeTagSerializer } from "../bcs/type-tag-serializer.js";
 import { deriveDynamicFieldID } from "../utils/dynamic-fields.js";
 import { normalizeStructTag, parseStructTag, WOW_ADDRESS_LENGTH, } from "../utils/sui-types.js";
@@ -62,9 +60,7 @@ export class Experimental_CoreClient extends Experimental_BaseClient {
             abortSignal.addEventListener("abort", () => reject(abortSignal.reason));
         });
         abortPromise.catch(() => {
-            // Swallow unhandled rejections that might be thrown after early return
         });
-        // eslint-disable-next-line no-constant-condition
         while (true) {
             abortSignal.throwIfAborted();
             try {
@@ -82,4 +78,3 @@ export class Experimental_CoreClient extends Experimental_BaseClient {
         }
     }
 }
-//# sourceMappingURL=core.js.map

package/dist/cjs/experimental/errors.js

@@ -1,5 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 export class SuiClientError extends Error {
 }
 export class ObjectError extends SuiClientError {
@@ -24,4 +22,3 @@ export class ObjectError extends SuiClientError {
         }
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/cjs/experimental/index.js

@@ -1,8 +1,5 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 import { Experimental_BaseClient } from "./client.js";
 import { Experimental_CoreClient } from "./core.js";
 export { parseTransactionBcs, parseTransactionEffectsBcs, } from "./transports/utils.js";
 export { Experimental_BaseClient, Experimental_CoreClient, };
 export { ClientCache } from "./cache.js";
-//# sourceMappingURL=index.js.map

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

@@ -1,54 +1,14 @@
-/**
- * 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;
@@ -56,79 +16,21 @@ export declare class Lock {
     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/cjs/experimental/persistent-storage.js

@@ -1,28 +1,15 @@
 import { randomBytes } from "crypto";
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, openSync, closeSync, constants, } from "fs";
-/**
- * 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 class PersistentStorage {
     filePath;
     lock;
-    /**
-     * Creates a new PersistentStorage instance.
-     * @param filePath Path to the storage file
-     */
     constructor(filePath) {
         this.filePath = filePath;
         this.lock = new Lock(`${filePath}.lock`);
-        // Create the file if it doesn't exist
         if (!existsSync(filePath)) {
             writeFileSync(filePath, JSON.stringify({}));
         }
     }
-    /**
-     * Reads the entire storage content.
-     * @returns The parsed storage content
-     */
     async readAll() {
         await this.lock.acquireShared();
         try {
@@ -33,30 +20,17 @@ export class PersistentStorage {
             await this.lock.releaseShared();
         }
     }
-    /**
-     * Writes data to the storage.
-     * This operation is atomic and safe for multi-process access.
-     * @param data The data to write
-     */
     async writeAll(data) {
         await this.lock.acquireExclusive();
         try {
-            // Write to a temporary file first
             const tempFilePath = `${this.filePath}.tmp.${randomBytes(8).toString("hex")}`;
             writeFileSync(tempFilePath, JSON.stringify(data));
-            // Rename is atomic on most file systems
             renameSync(tempFilePath, this.filePath);
         }
         finally {
             await this.lock.releaseExclusive();
         }
     }
-    /**
-     * 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
-     */
     async set(key, value) {
         await this.lock.acquireExclusive();
         try {
@@ -71,11 +45,6 @@ export class PersistentStorage {
             await this.lock.releaseExclusive();
         }
     }
-    /**
-     * Gets a specific key from the storage.
-     * @param key The key to get
-     * @returns The value associated with the key
-     */
     async get(key) {
         await this.lock.acquireShared();
         try {
@@ -87,11 +56,6 @@ export class PersistentStorage {
             await this.lock.releaseShared();
         }
     }
-    /**
-     * 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
-     */
     async transaction(transactionFn) {
         await this.lock.acquireExclusive();
         try {
@@ -106,9 +70,6 @@ export class PersistentStorage {
             await this.lock.releaseExclusive();
         }
     }
-    /**
-     * Clears all data from the storage.
-     */
     async clear() {
         await this.lock.acquireExclusive();
         try {
@@ -121,10 +82,6 @@ export class PersistentStorage {
         }
     }
 }
-/**
- * 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 class Lock {
     lockPath;
     sharedLockPath;
@@ -135,203 +92,129 @@ export class Lock {
         this.lockPath = lockPath;
         this.sharedLockPath = `${lockPath}.shared`;
     }
-    /**
-     * Acquires a shared lock. Multiple processes can hold a shared lock simultaneously.
-     */
     async acquireShared() {
-        // If we already hold the exclusive lock, we can upgrade to shared
         if (this.exclusiveLockCount > 0) {
             this.sharedLockCount++;
             this.exclusiveLockCount--;
             return;
         }
-        // If we already hold a shared lock, just increment the count
         if (this.sharedLockCount > 0) {
             this.sharedLockCount++;
             return;
         }
-        // Try to acquire a new shared lock
         let attempts = 0;
         const maxAttempts = 100;
-        const delay = 50; // milliseconds
+        const delay = 50;
         while (attempts < maxAttempts) {
             try {
-                // Check if exclusive lock exists
                 if (existsSync(this.lockPath)) {
                     await new Promise((resolve) => setTimeout(resolve, delay));
                     attempts++;
                     continue;
                 }
-                // Create shared lock file (atomic operation)
                 writeFileSync(this.sharedLockPath, "");
                 this.sharedLockCount = 1;
                 return;
             }
             catch (error) {
-                // If we can't acquire the lock, wait before trying again
                 await new Promise((resolve) => setTimeout(resolve, delay));
                 attempts++;
             }
         }
         throw new Error("Failed to acquire shared lock after multiple attempts");
     }
-    /**
-     * Acquires an exclusive lock. Only one process can hold an exclusive lock at a time.
-     */
     async acquireExclusive() {
-        // If we already hold the exclusive lock, just increment the count
         if (this.exclusiveLockCount > 0) {
             this.exclusiveLockCount++;
             return;
         }
-        // Try to acquire a new exclusive lock
         let attempts = 0;
         const maxAttempts = 100;
-        const delay = 50; // milliseconds
+        const delay = 50;
         while (attempts < maxAttempts) {
             try {
-                // Check if shared lock exists
                 if (existsSync(this.sharedLockPath)) {
                     await new Promise((resolve) => setTimeout(resolve, delay));
                     attempts++;
                     continue;
                 }
-                // Create exclusive lock file (atomic operation)
                 const fd = openSync(this.lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o644);
                 closeSync(fd);
                 this.exclusiveLockCount = 1;
                 return;
             }
             catch (error) {
-                // If we can't acquire the lock, wait before trying again
                 await new Promise((resolve) => setTimeout(resolve, delay));
                 attempts++;
             }
         }
         throw new Error("Failed to acquire exclusive lock after multiple attempts");
     }
-    /**
-     * Releases a shared lock.
-     */
     async releaseShared() {
         if (this.sharedLockCount === 0) {
             throw new Error("No shared lock to release");
         }
         this.sharedLockCount--;
-        // If this was the last shared lock, release the file lock
         if (this.sharedLockCount === 0) {
             try {
                 unlinkSync(this.sharedLockPath);
             }
             catch (error) {
-                // Ignore errors if the file doesn't exist
             }
         }
     }
-    /**
-     * Releases an exclusive lock.
-     */
     async releaseExclusive() {
         if (this.exclusiveLockCount === 0) {
             throw new Error("No exclusive lock to release");
         }
         this.exclusiveLockCount--;
-        // If this was the last exclusive lock, release the file lock
         if (this.exclusiveLockCount === 0) {
             try {
                 unlinkSync(this.lockPath);
             }
             catch (error) {
-                // Ignore errors if the file doesn't exist
             }
         }
     }
 }
-/**
- * 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 class MultiProcessKVStore {
     storage;
-    /**
-     * Creates a new MultiProcessKVStore instance.
-     * @param filePath Path to the storage file
-     */
     constructor(filePath) {
         this.storage = new PersistentStorage(filePath);
     }
-    /**
-     * Gets a value by key.
-     * @param key The key to get
-     * @returns The value associated with the key, or undefined if not found
-     */
     async get(key) {
         return this.storage.get(key);
     }
-    /**
-     * Sets a value by key.
-     * @param key The key to set
-     * @param value The value to set
-     */
     async set(key, value) {
         return this.storage.set(key, value);
     }
-    /**
-     * Deletes a key-value pair.
-     * @param key The key to delete
-     */
     async delete(key) {
         return this.storage.transaction((data) => {
             delete data[key];
             return data;
         });
     }
-    /**
-     * Checks if a key exists.
-     * @param key The key to check
-     * @returns True if the key exists, false otherwise
-     */
     async has(key) {
         const value = await this.storage.get(key);
         return value !== undefined;
     }
-    /**
-     * Gets all keys.
-     * @returns An array of all keys
-     */
     async keys() {
         const data = await this.storage.readAll();
         return Object.keys(data);
     }
-    /**
-     * Gets all values.
-     * @returns An array of all values
-     */
     async values() {
         const data = await this.storage.readAll();
         return Object.values(data);
     }
-    /**
-     * Gets all key-value pairs.
-     * @returns An array of all key-value pairs
-     */
     async entries() {
         const data = await this.storage.readAll();
         return Object.entries(data);
     }
-    /**
-     * Clears all key-value pairs.
-     */
     async clear() {
         return this.storage.clear();
     }
-    /**
-     * Gets the number of key-value pairs.
-     * @returns The number of key-value pairs
-     */
     async size() {
         const data = await this.storage.readAll();
         return Object.keys(data).length;
     }
 }
-//# sourceMappingURL=persistent-storage.js.map

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

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