@opendatalabs/vana-sdk 2.2.3 → 3.0.0

package/dist/tests/fakes/fake-pgp-port.d.ts

@@ -1,13 +0,0 @@
-/**
- * Fake PGP implementation for testing
- *
- * This provides predictable, fast PGP operations for tests
- * without needing to mock complex OpenPGP internals.
- */
-import type { PgpPort, PgpEncryptInput, PgpDecryptInput, PgpResult, PgpKeyPair, PgpKeyPairOptions } from "../../platform/ports/pgp-port";
-export declare class FakePgpPort implements PgpPort {
-    encrypt(input: PgpEncryptInput): Promise<PgpResult>;
-    decrypt(input: PgpDecryptInput): Promise<PgpResult>;
-    generateKeyPair(options?: PgpKeyPairOptions): Promise<PgpKeyPair>;
-}
-export declare const fakePgpPort: FakePgpPort;

package/dist/tests/grantValidation-edge-cases.test.d.ts

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

package/dist/tests/grantValidation-unreachable-branch.test.d.ts

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

package/dist/tests/helper-methods.test.d.ts

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

package/dist/tests/helpers/typedMocks.d.ts

@@ -1,64 +0,0 @@
-/**
- * Type-safe mock utilities following TypeScript best practices.
- * These helpers eliminate the need for type assertions in tests.
- */
-import { vi } from "vitest";
-/**
- * Creates a typed mock function matching the signature of the provided type.
- *
- * @returns A vitest mock function typed to match the specified function signature
- * @example
- * ```typescript
- * const fetchMock = typedFn<typeof fetch>();
- * vi.stubGlobal('fetch', fetchMock);
- * ```
- */
-export declare const typedFn: <T extends (...args: unknown[]) => unknown>() => ReturnType<typeof vi.fn> & T;
-/**
- * Creates a mock object that satisfies a specific interface.
- *
- * @param partial - Partial implementation to use as the mock, with only required methods
- * @returns A mock object cast to the full interface type
- * @example
- * ```typescript
- * const mockClient = createMock<WalletClient>({
- *   getChainId: typedFn<WalletClient['getChainId']>(),
- * });
- * ```
- */
-export declare function createMock<T>(partial: Partial<T>): T;
-/**
- * Stubs a global property with type safety.
- *
- * @param key - The name of the global property to stub
- * @param value - The mock value to use as the stub implementation
- * @example
- * ```typescript
- * stubGlobal('fetch', typedFn<typeof fetch>());
- * ```
- */
-export declare function stubGlobal<K extends keyof typeof globalThis>(key: K, value: (typeof globalThis)[K]): void;
-/**
- * Removes a global property for testing scenarios.
- *
- * @param key - The name of the global property to remove from globalThis
- * @example
- * ```typescript
- * removeGlobal('Buffer');
- * ```
- */
-export declare function removeGlobal(key: keyof typeof globalThis): void;
-/**
- * Restores a global property to its original value.
- *
- * @param key - The name of the global property to restore
- * @param value - The original value to restore for the property
- * @example
- * ```typescript
- * const original = globalThis.Buffer;
- * removeGlobal('Buffer');
- * // ... test ...
- * restoreGlobal('Buffer', original);
- * ```
- */
-export declare function restoreGlobal<K extends keyof typeof globalThis>(key: K, value: (typeof globalThis)[K]): void;

package/dist/tests/index-browser.test.d.ts

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

package/dist/tests/index-node.test.d.ts

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

package/dist/tests/index.test.d.ts

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

package/dist/tests/mocks/platformAdapter.d.ts

@@ -1,12 +0,0 @@
-import type { VanaPlatformAdapter } from "../../platform/interface";
-/**
- * Shared mock platform adapter for test files
- * This provides a consistent mock implementation across all tests
- *
- * @returns A mock VanaPlatformAdapter instance with mocked methods
- */
-export declare const createMockPlatformAdapter: () => VanaPlatformAdapter;
-/**
- * Default mock platform adapter instance for convenience
- */
-export declare const mockPlatformAdapter: VanaPlatformAdapter;

package/dist/tests/new-permissions-methods.test.d.ts

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

package/dist/tests/no-buffer-browser.test.d.ts

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

package/dist/tests/permissions-grantee.test.d.ts

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

package/dist/tests/permissions-revoke-relayer.test.d.ts

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

package/dist/tests/permissions-schema-validation.test.d.ts

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

package/dist/tests/permissions-server-files.test.d.ts

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

package/dist/tests/permissions-transaction-options.test.d.ts

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

package/dist/tests/permissions-trust-servers.test.d.ts

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

package/dist/tests/permissions.test.d.ts

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

package/dist/tests/personal.test.d.ts

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

package/dist/tests/platform-browser.test.d.ts

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

package/dist/tests/platform-crypto-expanded.test.d.ts

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

package/dist/tests/platform-crypto.test.d.ts

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

package/dist/tests/platform-index.test.d.ts

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

package/dist/tests/platform-node.test.d.ts

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

package/dist/tests/platform-shared-utils.test.d.ts

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

package/dist/tests/platform-updated.test.d.ts

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

package/dist/tests/protocol-additional-methods.test.d.ts

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

package/dist/tests/protocol.test.d.ts

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

package/dist/tests/read-only-mode.test.d.ts

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

package/dist/tests/relayer-integration.test.d.ts

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

package/dist/tests/relayer-unified.test.d.ts

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

package/dist/tests/schemas.test.d.ts

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

package/dist/tests/server-relayer-handler.test.d.ts

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

package/dist/tests/signatureFormatter.test.d.ts

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

package/dist/tests/trusted-server-queries.test.d.ts

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

package/dist/tests/typedDataConverter.test.d.ts

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

package/dist/tests/types-contracts.test.d.ts

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

package/dist/tests/types-data.test.d.ts

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

package/dist/tests/types-external-apis.test.d.ts

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

package/dist/tests/types-generics.test.d.ts

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

package/dist/tests/types-permissions.test.d.ts

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

package/dist/tests/types-upload-params.test.d.ts

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

package/dist/tests/types.test.d.ts

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

package/dist/tests/utils-formatters.test.d.ts

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

package/dist/tests/utils-grantFiles-edge-cases.test.d.ts

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

package/dist/tests/utils-grantFiles-validation.test.d.ts

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

package/dist/tests/utils-grantFiles.test.d.ts

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

package/dist/tests/utils-grantValidation-consolidated.test.d.ts

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

package/dist/tests/utils-grants.test.d.ts

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

package/dist/tests/utils-ipfs-additional.test.d.ts

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

package/dist/tests/utils-ipfs.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Test suite for IPFS utilities
- */
-export {};

package/dist/tests/utils-schemaValidation.test.d.ts

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

package/dist/tests/vana.test.d.ts

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

package/dist/tests/wallet-crypto-compatibility.test.d.ts

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

package/dist/types/atomicStore.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/types/atomicStore.ts"],"sourcesContent":["/**\n * Atomic storage primitives for distributed state management.\n *\n * @module\n */\n\n/**\n * Interface for atomic storage operations required by the SDK's distributed components.\n *\n * @remarks\n * Implementations of this interface MUST guarantee atomicity for all operations.\n * These primitives are used by the SDK's internal components to coordinate\n * distributed state in multi-instance deployments (e.g., serverless functions).\n *\n * The SDK provides a reference Redis implementation, but you can implement\n * this interface using any storage backend that supports atomic operations:\n * - PostgreSQL with advisory locks\n * - DynamoDB with conditional writes\n * - MongoDB with findAndModify\n * - Zookeeper or etcd for coordination\n *\n * @example\n * ```typescript\n * // Using the Redis reference implementation\n * import { RedisAtomicStore } from './lib/redisAtomicStore';\n *\n * const atomicStore = new RedisAtomicStore({\n *   redis: process.env.REDIS_URL\n * });\n *\n * const vana = Vana({\n *   privateKey: process.env.RELAYER_PRIVATE_KEY,\n *   atomicStore\n * });\n * ```\n *\n * @category Storage\n */\nexport interface IAtomicStore {\n  /**\n   * Atomically increments a counter and returns the new value.\n   *\n   * @remarks\n   * This operation MUST be atomic. If the key doesn't exist, it should be\n   * initialized to 0 before incrementing. The operation must return the\n   * value after incrementing.\n   *\n   * This is used primarily for nonce assignment where atomicity is critical\n   * to prevent conflicts under concurrent load.\n   *\n   * @param key - The key to increment\n   * @returns The new value after incrementing\n   *\n   * @example\n   * ```typescript\n   * // First call returns 1\n   * const nonce1 = await store.incr('nonce:0x123:1480');\n   * // Second call returns 2\n   * const nonce2 = await store.incr('nonce:0x123:1480');\n   * ```\n   */\n  incr(key: string): Promise<number>;\n\n  /**\n   * Attempts to acquire a distributed lock with automatic expiration.\n   *\n   * @remarks\n   * This operation MUST be atomic and follow the \"SET NX EX\" semantics:\n   * - Only succeeds if the lock doesn't exist (NX - \"Not eXists\")\n   * - Automatically expires after the specified TTL (EX - \"EXpire\")\n   * - Returns a unique lock ID on success for safe release\n   *\n   * The lock ID should be a unique value (e.g., UUID or timestamp+random)\n   * that prevents accidental release by other processes.\n   *\n   * @param key - The lock key\n   * @param ttlSeconds - Time-to-live in seconds (automatic expiration)\n   * @returns A unique lock ID if acquired, null if lock is already held\n   *\n   * @example\n   * ```typescript\n   * const lockId = await store.acquireLock('nonce:lock:0x123', 5);\n   * if (lockId) {\n   *   try {\n   *     // Critical section - only one process can be here\n   *     await performCriticalOperation();\n   *   } finally {\n   *     await store.releaseLock('nonce:lock:0x123', lockId);\n   *   }\n   * }\n   * ```\n   */\n  acquireLock(key: string, ttlSeconds: number): Promise<string | null>;\n\n  /**\n   * Releases a previously acquired lock.\n   *\n   * @remarks\n   * This operation MUST be atomic and safe. It should only succeed if the\n   * provided lockId matches the current lock value. This prevents accidental\n   * release of locks acquired by other processes.\n   *\n   * Implementations should use compare-and-delete semantics or a Lua script\n   * (in Redis) to ensure atomicity.\n   *\n   * @param key - The lock key\n   * @param lockId - The unique ID returned by acquireLock\n   *\n   * @example\n   * ```typescript\n   * const lockId = await store.acquireLock('lock:key', 5);\n   * if (lockId) {\n   *   // ... do work ...\n   *   await store.releaseLock('lock:key', lockId);\n   * }\n   * ```\n   */\n  releaseLock(key: string, lockId: string): Promise<void>;\n\n  /**\n   * Gets the value associated with a key.\n   *\n   * @remarks\n   * This is a simple read operation. It should return null if the key\n   * doesn't exist.\n   *\n   * @param key - The key to retrieve\n   * @returns The stored value, or null if not found\n   *\n   * @example\n   * ```typescript\n   * const lastUsedNonce = await store.get('lastNonce:0x123:1480');\n   * ```\n   */\n  get(key: string): Promise<string | null>;\n\n  /**\n   * Sets a key-value pair.\n   *\n   * @remarks\n   * This is a simple write operation. It should overwrite any existing value.\n   *\n   * @param key - The key to set\n   * @param value - The value to store\n   *\n   * @example\n   * ```typescript\n   * await store.set('lastNonce:0x123:1480', '42');\n   * ```\n   */\n  set(key: string, value: string): Promise<void>;\n\n  /**\n   * Sets a key-value pair with expiration.\n   *\n   * @remarks\n   * This operation sets a value with automatic expiration after the specified TTL.\n   * Useful for temporary state that should be automatically cleaned up.\n   *\n   * @param key - The key to set\n   * @param value - The value to store\n   * @param ttlSeconds - Time-to-live in seconds\n   *\n   * @example\n   * ```typescript\n   * // Store operation state for 24 hours\n   * await store.setWithTTL('operation:123', JSON.stringify(state), 86400);\n   * ```\n   */\n  setWithTTL?(key: string, value: string, ttlSeconds: number): Promise<void>;\n\n  /**\n   * Deletes a key.\n   *\n   * @remarks\n   * This operation removes a key from storage. Should be idempotent\n   * (no error if key doesn't exist).\n   *\n   * @param key - The key to delete\n   *\n   * @example\n   * ```typescript\n   * await store.delete('temp:data:123');\n   * ```\n   */\n  delete?(key: string): Promise<void>;\n\n  /**\n   * Executes an atomic script (e.g., Lua in Redis, stored procedure in SQL).\n   *\n   * @remarks\n   * This is an optional method that allows execution of atomic scripts\n   * for complex operations that require multiple steps to be atomic.\n   * Not all stores support this - simple stores may omit it.\n   *\n   * For Redis: executes a Lua script\n   * For PostgreSQL: executes a stored procedure or CTE\n   * For DynamoDB: might use TransactWrite\n   *\n   * @param script - The script to execute\n   * @param keys - Array of keys the script will operate on\n   * @param args - Array of arguments to pass to the script\n   * @returns The script's return value\n   *\n   * @example\n   * ```typescript\n   * const result = await store.eval(\n   *   'return redis.call(\"INCR\", KEYS[1])',\n   *   ['counter:users'],\n   *   []\n   * );\n   * ```\n   */\n  eval?(script: string, keys: string[], args: string[]): Promise<any>;\n}\n\n/**\n * Extended atomic store interface with nonce support.\n *\n * @remarks\n * Some atomic stores (like Redis) provide optimized atomic nonce assignment\n * through native scripting capabilities. This interface extends the base\n * IAtomicStore with this optional optimization.\n *\n * @internal\n */\nexport interface IAtomicStoreWithNonceSupport extends IAtomicStore {\n  /**\n   * Atomically assigns a nonce with gap prevention.\n   *\n   * @param key - The storage key for the last used nonce\n   * @param pendingCount - The current pending transaction count from blockchain\n   * @returns The assigned nonce\n   */\n  atomicAssignNonce(key: string, pendingCount: number): Promise<number>;\n}\n\n/**\n * Type guard to check if an atomic store supports optimized nonce assignment.\n *\n * @param store - The atomic store to check\n * @returns True if the store supports atomicAssignNonce\n *\n * @internal\n */\nexport function hasNonceSupport(\n  store: IAtomicStore,\n): store is IAtomicStoreWithNonceSupport {\n  return (\n    \"atomicAssignNonce\" in store &&\n    typeof (store as IAtomicStoreWithNonceSupport).atomicAssignNonce ===\n      \"function\"\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqPO,SAAS,gBACd,OACuC;AACvC,SACE,uBAAuB,SACvB,OAAQ,MAAuC,sBAC7C;AAEN;","names":[]}

package/dist/types/atomicStore.d.ts

@@ -1,236 +0,0 @@
-/**
- * Atomic storage primitives for distributed state management.
- *
- * @module
- */
-/**
- * Interface for atomic storage operations required by the SDK's distributed components.
- *
- * @remarks
- * Implementations of this interface MUST guarantee atomicity for all operations.
- * These primitives are used by the SDK's internal components to coordinate
- * distributed state in multi-instance deployments (e.g., serverless functions).
- *
- * The SDK provides a reference Redis implementation, but you can implement
- * this interface using any storage backend that supports atomic operations:
- * - PostgreSQL with advisory locks
- * - DynamoDB with conditional writes
- * - MongoDB with findAndModify
- * - Zookeeper or etcd for coordination
- *
- * @example
- * ```typescript
- * // Using the Redis reference implementation
- * import { RedisAtomicStore } from './lib/redisAtomicStore';
- *
- * const atomicStore = new RedisAtomicStore({
- *   redis: process.env.REDIS_URL
- * });
- *
- * const vana = Vana({
- *   privateKey: process.env.RELAYER_PRIVATE_KEY,
- *   atomicStore
- * });
- * ```
- *
- * @category Storage
- */
-export interface IAtomicStore {
-    /**
-     * Atomically increments a counter and returns the new value.
-     *
-     * @remarks
-     * This operation MUST be atomic. If the key doesn't exist, it should be
-     * initialized to 0 before incrementing. The operation must return the
-     * value after incrementing.
-     *
-     * This is used primarily for nonce assignment where atomicity is critical
-     * to prevent conflicts under concurrent load.
-     *
-     * @param key - The key to increment
-     * @returns The new value after incrementing
-     *
-     * @example
-     * ```typescript
-     * // First call returns 1
-     * const nonce1 = await store.incr('nonce:0x123:1480');
-     * // Second call returns 2
-     * const nonce2 = await store.incr('nonce:0x123:1480');
-     * ```
-     */
-    incr(key: string): Promise<number>;
-    /**
-     * Attempts to acquire a distributed lock with automatic expiration.
-     *
-     * @remarks
-     * This operation MUST be atomic and follow the "SET NX EX" semantics:
-     * - Only succeeds if the lock doesn't exist (NX - "Not eXists")
-     * - Automatically expires after the specified TTL (EX - "EXpire")
-     * - Returns a unique lock ID on success for safe release
-     *
-     * The lock ID should be a unique value (e.g., UUID or timestamp+random)
-     * that prevents accidental release by other processes.
-     *
-     * @param key - The lock key
-     * @param ttlSeconds - Time-to-live in seconds (automatic expiration)
-     * @returns A unique lock ID if acquired, null if lock is already held
-     *
-     * @example
-     * ```typescript
-     * const lockId = await store.acquireLock('nonce:lock:0x123', 5);
-     * if (lockId) {
-     *   try {
-     *     // Critical section - only one process can be here
-     *     await performCriticalOperation();
-     *   } finally {
-     *     await store.releaseLock('nonce:lock:0x123', lockId);
-     *   }
-     * }
-     * ```
-     */
-    acquireLock(key: string, ttlSeconds: number): Promise<string | null>;
-    /**
-     * Releases a previously acquired lock.
-     *
-     * @remarks
-     * This operation MUST be atomic and safe. It should only succeed if the
-     * provided lockId matches the current lock value. This prevents accidental
-     * release of locks acquired by other processes.
-     *
-     * Implementations should use compare-and-delete semantics or a Lua script
-     * (in Redis) to ensure atomicity.
-     *
-     * @param key - The lock key
-     * @param lockId - The unique ID returned by acquireLock
-     *
-     * @example
-     * ```typescript
-     * const lockId = await store.acquireLock('lock:key', 5);
-     * if (lockId) {
-     *   // ... do work ...
-     *   await store.releaseLock('lock:key', lockId);
-     * }
-     * ```
-     */
-    releaseLock(key: string, lockId: string): Promise<void>;
-    /**
-     * Gets the value associated with a key.
-     *
-     * @remarks
-     * This is a simple read operation. It should return null if the key
-     * doesn't exist.
-     *
-     * @param key - The key to retrieve
-     * @returns The stored value, or null if not found
-     *
-     * @example
-     * ```typescript
-     * const lastUsedNonce = await store.get('lastNonce:0x123:1480');
-     * ```
-     */
-    get(key: string): Promise<string | null>;
-    /**
-     * Sets a key-value pair.
-     *
-     * @remarks
-     * This is a simple write operation. It should overwrite any existing value.
-     *
-     * @param key - The key to set
-     * @param value - The value to store
-     *
-     * @example
-     * ```typescript
-     * await store.set('lastNonce:0x123:1480', '42');
-     * ```
-     */
-    set(key: string, value: string): Promise<void>;
-    /**
-     * Sets a key-value pair with expiration.
-     *
-     * @remarks
-     * This operation sets a value with automatic expiration after the specified TTL.
-     * Useful for temporary state that should be automatically cleaned up.
-     *
-     * @param key - The key to set
-     * @param value - The value to store
-     * @param ttlSeconds - Time-to-live in seconds
-     *
-     * @example
-     * ```typescript
-     * // Store operation state for 24 hours
-     * await store.setWithTTL('operation:123', JSON.stringify(state), 86400);
-     * ```
-     */
-    setWithTTL?(key: string, value: string, ttlSeconds: number): Promise<void>;
-    /**
-     * Deletes a key.
-     *
-     * @remarks
-     * This operation removes a key from storage. Should be idempotent
-     * (no error if key doesn't exist).
-     *
-     * @param key - The key to delete
-     *
-     * @example
-     * ```typescript
-     * await store.delete('temp:data:123');
-     * ```
-     */
-    delete?(key: string): Promise<void>;
-    /**
-     * Executes an atomic script (e.g., Lua in Redis, stored procedure in SQL).
-     *
-     * @remarks
-     * This is an optional method that allows execution of atomic scripts
-     * for complex operations that require multiple steps to be atomic.
-     * Not all stores support this - simple stores may omit it.
-     *
-     * For Redis: executes a Lua script
-     * For PostgreSQL: executes a stored procedure or CTE
-     * For DynamoDB: might use TransactWrite
-     *
-     * @param script - The script to execute
-     * @param keys - Array of keys the script will operate on
-     * @param args - Array of arguments to pass to the script
-     * @returns The script's return value
-     *
-     * @example
-     * ```typescript
-     * const result = await store.eval(
-     *   'return redis.call("INCR", KEYS[1])',
-     *   ['counter:users'],
-     *   []
-     * );
-     * ```
-     */
-    eval?(script: string, keys: string[], args: string[]): Promise<any>;
-}
-/**
- * Extended atomic store interface with nonce support.
- *
- * @remarks
- * Some atomic stores (like Redis) provide optimized atomic nonce assignment
- * through native scripting capabilities. This interface extends the base
- * IAtomicStore with this optional optimization.
- *
- * @internal
- */
-export interface IAtomicStoreWithNonceSupport extends IAtomicStore {
-    /**
-     * Atomically assigns a nonce with gap prevention.
-     *
-     * @param key - The storage key for the last used nonce
-     * @param pendingCount - The current pending transaction count from blockchain
-     * @returns The assigned nonce
-     */
-    atomicAssignNonce(key: string, pendingCount: number): Promise<number>;
-}
-/**
- * Type guard to check if an atomic store supports optimized nonce assignment.
- *
- * @param store - The atomic store to check
- * @returns True if the store supports atomicAssignNonce
- *
- * @internal
- */
-export declare function hasNonceSupport(store: IAtomicStore): store is IAtomicStoreWithNonceSupport;

package/dist/types/atomicStore.js

@@ -1,7 +0,0 @@
-function hasNonceSupport(store) {
-  return "atomicAssignNonce" in store && typeof store.atomicAssignNonce === "function";
-}
-export {
-  hasNonceSupport
-};
-//# sourceMappingURL=atomicStore.js.map

package/dist/types/atomicStore.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/types/atomicStore.ts"],"sourcesContent":["/**\n * Atomic storage primitives for distributed state management.\n *\n * @module\n */\n\n/**\n * Interface for atomic storage operations required by the SDK's distributed components.\n *\n * @remarks\n * Implementations of this interface MUST guarantee atomicity for all operations.\n * These primitives are used by the SDK's internal components to coordinate\n * distributed state in multi-instance deployments (e.g., serverless functions).\n *\n * The SDK provides a reference Redis implementation, but you can implement\n * this interface using any storage backend that supports atomic operations:\n * - PostgreSQL with advisory locks\n * - DynamoDB with conditional writes\n * - MongoDB with findAndModify\n * - Zookeeper or etcd for coordination\n *\n * @example\n * ```typescript\n * // Using the Redis reference implementation\n * import { RedisAtomicStore } from './lib/redisAtomicStore';\n *\n * const atomicStore = new RedisAtomicStore({\n *   redis: process.env.REDIS_URL\n * });\n *\n * const vana = Vana({\n *   privateKey: process.env.RELAYER_PRIVATE_KEY,\n *   atomicStore\n * });\n * ```\n *\n * @category Storage\n */\nexport interface IAtomicStore {\n  /**\n   * Atomically increments a counter and returns the new value.\n   *\n   * @remarks\n   * This operation MUST be atomic. If the key doesn't exist, it should be\n   * initialized to 0 before incrementing. The operation must return the\n   * value after incrementing.\n   *\n   * This is used primarily for nonce assignment where atomicity is critical\n   * to prevent conflicts under concurrent load.\n   *\n   * @param key - The key to increment\n   * @returns The new value after incrementing\n   *\n   * @example\n   * ```typescript\n   * // First call returns 1\n   * const nonce1 = await store.incr('nonce:0x123:1480');\n   * // Second call returns 2\n   * const nonce2 = await store.incr('nonce:0x123:1480');\n   * ```\n   */\n  incr(key: string): Promise<number>;\n\n  /**\n   * Attempts to acquire a distributed lock with automatic expiration.\n   *\n   * @remarks\n   * This operation MUST be atomic and follow the \"SET NX EX\" semantics:\n   * - Only succeeds if the lock doesn't exist (NX - \"Not eXists\")\n   * - Automatically expires after the specified TTL (EX - \"EXpire\")\n   * - Returns a unique lock ID on success for safe release\n   *\n   * The lock ID should be a unique value (e.g., UUID or timestamp+random)\n   * that prevents accidental release by other processes.\n   *\n   * @param key - The lock key\n   * @param ttlSeconds - Time-to-live in seconds (automatic expiration)\n   * @returns A unique lock ID if acquired, null if lock is already held\n   *\n   * @example\n   * ```typescript\n   * const lockId = await store.acquireLock('nonce:lock:0x123', 5);\n   * if (lockId) {\n   *   try {\n   *     // Critical section - only one process can be here\n   *     await performCriticalOperation();\n   *   } finally {\n   *     await store.releaseLock('nonce:lock:0x123', lockId);\n   *   }\n   * }\n   * ```\n   */\n  acquireLock(key: string, ttlSeconds: number): Promise<string | null>;\n\n  /**\n   * Releases a previously acquired lock.\n   *\n   * @remarks\n   * This operation MUST be atomic and safe. It should only succeed if the\n   * provided lockId matches the current lock value. This prevents accidental\n   * release of locks acquired by other processes.\n   *\n   * Implementations should use compare-and-delete semantics or a Lua script\n   * (in Redis) to ensure atomicity.\n   *\n   * @param key - The lock key\n   * @param lockId - The unique ID returned by acquireLock\n   *\n   * @example\n   * ```typescript\n   * const lockId = await store.acquireLock('lock:key', 5);\n   * if (lockId) {\n   *   // ... do work ...\n   *   await store.releaseLock('lock:key', lockId);\n   * }\n   * ```\n   */\n  releaseLock(key: string, lockId: string): Promise<void>;\n\n  /**\n   * Gets the value associated with a key.\n   *\n   * @remarks\n   * This is a simple read operation. It should return null if the key\n   * doesn't exist.\n   *\n   * @param key - The key to retrieve\n   * @returns The stored value, or null if not found\n   *\n   * @example\n   * ```typescript\n   * const lastUsedNonce = await store.get('lastNonce:0x123:1480');\n   * ```\n   */\n  get(key: string): Promise<string | null>;\n\n  /**\n   * Sets a key-value pair.\n   *\n   * @remarks\n   * This is a simple write operation. It should overwrite any existing value.\n   *\n   * @param key - The key to set\n   * @param value - The value to store\n   *\n   * @example\n   * ```typescript\n   * await store.set('lastNonce:0x123:1480', '42');\n   * ```\n   */\n  set(key: string, value: string): Promise<void>;\n\n  /**\n   * Sets a key-value pair with expiration.\n   *\n   * @remarks\n   * This operation sets a value with automatic expiration after the specified TTL.\n   * Useful for temporary state that should be automatically cleaned up.\n   *\n   * @param key - The key to set\n   * @param value - The value to store\n   * @param ttlSeconds - Time-to-live in seconds\n   *\n   * @example\n   * ```typescript\n   * // Store operation state for 24 hours\n   * await store.setWithTTL('operation:123', JSON.stringify(state), 86400);\n   * ```\n   */\n  setWithTTL?(key: string, value: string, ttlSeconds: number): Promise<void>;\n\n  /**\n   * Deletes a key.\n   *\n   * @remarks\n   * This operation removes a key from storage. Should be idempotent\n   * (no error if key doesn't exist).\n   *\n   * @param key - The key to delete\n   *\n   * @example\n   * ```typescript\n   * await store.delete('temp:data:123');\n   * ```\n   */\n  delete?(key: string): Promise<void>;\n\n  /**\n   * Executes an atomic script (e.g., Lua in Redis, stored procedure in SQL).\n   *\n   * @remarks\n   * This is an optional method that allows execution of atomic scripts\n   * for complex operations that require multiple steps to be atomic.\n   * Not all stores support this - simple stores may omit it.\n   *\n   * For Redis: executes a Lua script\n   * For PostgreSQL: executes a stored procedure or CTE\n   * For DynamoDB: might use TransactWrite\n   *\n   * @param script - The script to execute\n   * @param keys - Array of keys the script will operate on\n   * @param args - Array of arguments to pass to the script\n   * @returns The script's return value\n   *\n   * @example\n   * ```typescript\n   * const result = await store.eval(\n   *   'return redis.call(\"INCR\", KEYS[1])',\n   *   ['counter:users'],\n   *   []\n   * );\n   * ```\n   */\n  eval?(script: string, keys: string[], args: string[]): Promise<any>;\n}\n\n/**\n * Extended atomic store interface with nonce support.\n *\n * @remarks\n * Some atomic stores (like Redis) provide optimized atomic nonce assignment\n * through native scripting capabilities. This interface extends the base\n * IAtomicStore with this optional optimization.\n *\n * @internal\n */\nexport interface IAtomicStoreWithNonceSupport extends IAtomicStore {\n  /**\n   * Atomically assigns a nonce with gap prevention.\n   *\n   * @param key - The storage key for the last used nonce\n   * @param pendingCount - The current pending transaction count from blockchain\n   * @returns The assigned nonce\n   */\n  atomicAssignNonce(key: string, pendingCount: number): Promise<number>;\n}\n\n/**\n * Type guard to check if an atomic store supports optimized nonce assignment.\n *\n * @param store - The atomic store to check\n * @returns True if the store supports atomicAssignNonce\n *\n * @internal\n */\nexport function hasNonceSupport(\n  store: IAtomicStore,\n): store is IAtomicStoreWithNonceSupport {\n  return (\n    \"atomicAssignNonce\" in store &&\n    typeof (store as IAtomicStoreWithNonceSupport).atomicAssignNonce ===\n      \"function\"\n  );\n}\n"],"mappings":"AAqPO,SAAS,gBACd,OACuC;AACvC,SACE,uBAAuB,SACvB,OAAQ,MAAuC,sBAC7C;AAEN;","names":[]}

package/dist/types/blockchain.cjs

@@ -1,17 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var blockchain_exports = {};
-module.exports = __toCommonJS(blockchain_exports);
-//# sourceMappingURL=blockchain.cjs.map

package/dist/types/blockchain.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/types/blockchain.ts"],"sourcesContent":["/**\n * Defines core blockchain interaction types.\n *\n * @remarks\n * This module provides fundamental types for blockchain transactions,\n * including transaction requests, confirmation options, and results.\n * These types form the basis for all blockchain interactions in the SDK.\n *\n * @category Types\n * @module types/blockchain\n */\n\nimport type { Hash, Address } from \"viem\";\n\n/**\n * Represents a submitted blockchain transaction awaiting confirmation.\n *\n * @remarks\n * Returned immediately after transaction submission, before confirmation.\n * Use `waitForTransactionEvents` to wait for confirmation and retrieve events.\n *\n * @category Blockchain\n */\nexport interface TransactionRequest {\n  /** Transaction hash */\n  hash: Hash;\n  /** Account that initiated the transaction */\n  from: Address;\n  /** Contract that was called */\n  contractName: string;\n  /** Function that was called */\n  functionName: string;\n  /** Function arguments (for debugging/logging) */\n  args?: readonly unknown[];\n}\n\n/**\n * Configures transaction confirmation waiting behavior.\n *\n * @remarks\n * Controls how long and how often to check for transaction confirmation.\n * Adjust based on network congestion and application requirements.\n *\n * @category Blockchain\n */\nexport interface TransactionWaitOptions {\n  /** Number of confirmations to wait for (default: 1) */\n  confirmations?: number;\n  /** Timeout in milliseconds (default: 30000) */\n  timeout?: number;\n  /** Polling interval in milliseconds (default: 4000) */\n  pollingInterval?: number;\n}\n\n/**\n * Represents a confirmed blockchain transaction with metadata.\n *\n * @remarks\n * Contains essential transaction information after confirmation including\n * gas usage, block number, and function details. Extended by specific\n * result types with parsed events.\n *\n * @category Blockchain\n */\nexport interface TransactionResult {\n  /** Transaction hash */\n  transactionHash: Hash;\n  /** Block number where transaction was included */\n  blockNumber: bigint;\n  /** Gas used by the transaction */\n  gasUsed: bigint;\n  /** Account that initiated the transaction */\n  from: Address;\n  /** Contract that was called */\n  contractName: string;\n  /** Function that was called */\n  functionName: string;\n}\n\n/**\n * @remarks\n * Event typing strategy:\n * - Event arguments are dynamically typed based on contract mappings\n * - `parseTransaction` returns `expectedEvents` with typed args for mapped functions\n * - `allEvents` contains all parsed events from the transaction\n * - This approach lets the mapping file drive types rather than requiring\n *   specific result interfaces per event type\n *\n * @internal\n */\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}