@opendatalabs/vana-sdk 2.3.0 → 3.0.1-canary.b068ac6

package/dist/controllers/operations.d.ts

@@ -1,229 +0,0 @@
-/**
- * Operations controller for managing and recovering asynchronous relayer operations.
- *
- * @module
- */
-import type { ControllerContext } from "./permissions";
-import type { OperationStatus } from "../types/options";
-import type { IOperationStore } from "../types/operationStore";
-import type { IAtomicStore } from "../types/atomicStore";
-import type { WalletClient, PublicClient } from "viem";
-import { BaseController } from "./base";
-/**
- * Controller for managing asynchronous operations.
- *
- * This controller provides methods to check the status of pending operations
- * and recover from interrupted transactions.
- *
- * @category Controllers
- * @example
- * ```typescript
- * // Recover an orphaned operation
- * try {
- *   const result = await vana.permissions.grant(...);
- * } catch (error) {
- *   if (error instanceof TransactionPendingError) {
- *     // Save the operation ID
- *     localStorage.setItem('pendingOp', error.operationId);
- *
- *     // Later, check the status
- *     const operationId = localStorage.getItem('pendingOp');
- *     const status = await vana.operations.getStatus(operationId);
- *
- *     if (status.type === 'confirmed') {
- *       console.log('Transaction confirmed:', status.receipt);
- *     }
- *   }
- * }
- * ```
- */
-export declare class OperationsController extends BaseController {
-    constructor(context: ControllerContext);
-    /**
-     * Gets the current status of an operation.
-     *
-     * @remarks
-     * This method allows recovery of operations that were interrupted due to:
-     * - Browser tab closure
-     * - Network disconnection
-     * - Application errors
-     * - Timeout during polling
-     *
-     * The method queries the backend for the current operation state without
-     * starting a new polling session.
-     *
-     * @param operationId - The unique identifier of the operation to check
-     * @returns Promise resolving to the current operation status
-     * @throws {Error} When relayer is not configured
-     * @throws {Error} When operation is not found
-     *
-     * @example
-     * ```typescript
-     * const status = await vana.operations.getStatus('550e8400-e29b-41d4-a716-446655440000');
-     *
-     * switch(status.type) {
-     *   case 'pending':
-     *     console.log('Still processing...');
-     *     break;
-     *   case 'queued':
-     *     console.log(`Position in queue: ${status.position}`);
-     *     break;
-     *   case 'confirmed':
-     *     console.log(`Transaction confirmed: ${status.receipt.transactionHash}`);
-     *     break;
-     *   case 'failed':
-     *     console.error(`Operation failed: ${status.error}`);
-     *     break;
-     * }
-     * ```
-     */
-    getStatus(operationId: string): Promise<OperationStatus>;
-    /**
-     * Waits for an operation to complete and returns the final result.
-     *
-     * @remarks
-     * This method is useful for resuming polling of an operation that was
-     * previously interrupted. Unlike `getStatus`, this method will actively
-     * poll until the operation reaches a final state (confirmed or failed).
-     *
-     * @param operationId - The unique identifier of the operation to wait for
-     * @param options - Optional configuration for polling behavior
-     * @returns Promise resolving when the operation is confirmed
-     * @throws {TransactionPendingError} When polling times out
-     * @throws {Error} When the operation fails
-     *
-     * @example
-     * ```typescript
-     * // Resume polling with status updates
-     * const result = await vana.operations.waitForConfirmation(operationId, {
-     *   onStatusUpdate: (status) => {
-     *     console.log(`Current status: ${status.type}`);
-     *   },
-     *   timeout: 600000 // 10 minutes
-     * });
-     *
-     * console.log('Transaction confirmed:', result.hash);
-     * ```
-     */
-    waitForConfirmation(operationId: string, options?: {
-        signal?: AbortSignal;
-        onStatusUpdate?: (status: OperationStatus) => void;
-        timeout?: number;
-        initialInterval?: number;
-        maxInterval?: number;
-    }): Promise<{
-        hash: string;
-        receipt?: any;
-    }>;
-    /**
-     * Cancels a pending operation if supported by the backend.
-     *
-     * @remarks
-     * Not all backends support operation cancellation. This method will
-     * attempt to cancel the operation but success is not guaranteed.
-     *
-     * @param operationId - The unique identifier of the operation to cancel
-     * @returns Promise resolving to true if cancellation was successful
-     * @throws {Error} When cancellation is not supported or fails
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   const cancelled = await vana.operations.cancel(operationId);
-     *   if (cancelled) {
-     *     console.log('Operation cancelled successfully');
-     *   }
-     * } catch (error) {
-     *   console.error('Failed to cancel operation:', error);
-     * }
-     * ```
-     */
-    cancel(_operationId: string): Promise<boolean>;
-    /**
-     * Processes queued operations from the operation store.
-     *
-     * @remarks
-     * This method is designed for worker processes that handle asynchronous
-     * operation processing. It fetches queued operations, processes them with
-     * proper nonce management and gas escalation, and handles retries.
-     *
-     * This is typically called from a background worker or cron job to process
-     * operations that were queued for asynchronous execution.
-     *
-     * @param config - Configuration for queue processing
-     * @returns Promise resolving to processing results
-     *
-     * @example
-     * ```typescript
-     * // In a worker process
-     * const results = await vana.operations.processQueue({
-     *   operationStore,
-     *   atomicStore,
-     *   walletClient,
-     *   publicClient,
-     *   maxOperations: 10,
-     *   onOperationComplete: (id, success) => {
-     *     console.log(`Operation ${id}: ${success ? 'completed' : 'failed'}`);
-     *   }
-     * });
-     *
-     * console.log(`Processed ${results.processed} operations`);
-     * ```
-     */
-    processQueue(config: {
-        operationStore: IOperationStore;
-        atomicStore: IAtomicStore;
-        walletClient: WalletClient;
-        publicClient: PublicClient;
-        maxOperations?: number;
-        maxRetries?: number;
-        gasEscalationFactor?: number;
-        maxGasMultiplier?: number;
-        onOperationComplete?: (operationId: string, success: boolean) => void;
-        onError?: (operationId: string, error: Error) => void;
-    }): Promise<{
-        processed: number;
-        succeeded: number;
-        failed: number;
-        errors: Array<{
-            operationId: string;
-            error: string;
-        }>;
-    }>;
-    /**
-     * Burns a stuck nonce by sending a minimal self-transfer.
-     *
-     * @remarks
-     * This method is used to unblock the transaction queue when a transaction
-     * is stuck. It sends a minimal amount to the same address with the stuck
-     * nonce and higher gas to ensure it gets mined.
-     *
-     * @param config - Configuration for nonce burning
-     * @returns Promise resolving to the burn transaction hash
-     *
-     * @example
-     * ```typescript
-     * const hash = await vana.operations.burnStuckNonce({
-     *   walletClient,
-     *   publicClient,
-     *   atomicStore,
-     *   address: relayerAddress,
-     *   stuckNonce: 42
-     * });
-     *
-     * console.log(`Burned stuck nonce with tx: ${hash}`);
-     * ```
-     */
-    burnStuckNonce(config: {
-        walletClient: WalletClient;
-        publicClient: PublicClient;
-        atomicStore: IAtomicStore;
-        address: `0x${string}`;
-        stuckNonce: number;
-    }): Promise<string>;
-    /**
-     * Maps a relayer response to an OperationStatus object.
-     * @internal
-     */
-    private mapResponseToStatus;
-}

package/dist/controllers/operations.js

@@ -1,406 +0,0 @@
-import { BaseController } from "./base";
-import { PollingManager } from "../core/pollingManager";
-import { DistributedNonceManager } from "../core/nonceManager";
-import { InMemoryNonceManager } from "../core/inMemoryNonceManager";
-import { parseEther } from "viem";
-class OperationsController extends BaseController {
-  constructor(context) {
-    super(context);
-  }
-  /**
-   * Gets the current status of an operation.
-   *
-   * @remarks
-   * This method allows recovery of operations that were interrupted due to:
-   * - Browser tab closure
-   * - Network disconnection
-   * - Application errors
-   * - Timeout during polling
-   *
-   * The method queries the backend for the current operation state without
-   * starting a new polling session.
-   *
-   * @param operationId - The unique identifier of the operation to check
-   * @returns Promise resolving to the current operation status
-   * @throws {Error} When relayer is not configured
-   * @throws {Error} When operation is not found
-   *
-   * @example
-   * ```typescript
-   * const status = await vana.operations.getStatus('550e8400-e29b-41d4-a716-446655440000');
-   *
-   * switch(status.type) {
-   *   case 'pending':
-   *     console.log('Still processing...');
-   *     break;
-   *   case 'queued':
-   *     console.log(`Position in queue: ${status.position}`);
-   *     break;
-   *   case 'confirmed':
-   *     console.log(`Transaction confirmed: ${status.receipt.transactionHash}`);
-   *     break;
-   *   case 'failed':
-   *     console.error(`Operation failed: ${status.error}`);
-   *     break;
-   * }
-   * ```
-   */
-  async getStatus(operationId) {
-    if (!this.context.relayer) {
-      throw new Error("Relayer not configured");
-    }
-    const request = {
-      type: "status_check",
-      operationId
-    };
-    const response = await this.context.relayer(request);
-    return this.mapResponseToStatus(response, operationId);
-  }
-  /**
-   * Waits for an operation to complete and returns the final result.
-   *
-   * @remarks
-   * This method is useful for resuming polling of an operation that was
-   * previously interrupted. Unlike `getStatus`, this method will actively
-   * poll until the operation reaches a final state (confirmed or failed).
-   *
-   * @param operationId - The unique identifier of the operation to wait for
-   * @param options - Optional configuration for polling behavior
-   * @returns Promise resolving when the operation is confirmed
-   * @throws {TransactionPendingError} When polling times out
-   * @throws {Error} When the operation fails
-   *
-   * @example
-   * ```typescript
-   * // Resume polling with status updates
-   * const result = await vana.operations.waitForConfirmation(operationId, {
-   *   onStatusUpdate: (status) => {
-   *     console.log(`Current status: ${status.type}`);
-   *   },
-   *   timeout: 600000 // 10 minutes
-   * });
-   *
-   * console.log('Transaction confirmed:', result.hash);
-   * ```
-   */
-  async waitForConfirmation(operationId, options) {
-    if (!this.context.relayer) {
-      throw new Error("Relayer not configured");
-    }
-    const currentStatus = await this.getStatus(operationId);
-    if (currentStatus.type === "confirmed") {
-      return {
-        hash: currentStatus.hash,
-        receipt: currentStatus.receipt
-      };
-    }
-    if (currentStatus.type === "failed") {
-      throw new Error(currentStatus.error);
-    }
-    const pollingManager = new PollingManager(this.context.relayer);
-    return await pollingManager.startPolling(operationId, {
-      signal: options?.signal,
-      onStatusUpdate: options?.onStatusUpdate,
-      timeout: options?.timeout,
-      initialInterval: options?.initialInterval,
-      maxInterval: options?.maxInterval
-    });
-  }
-  /**
-   * Cancels a pending operation if supported by the backend.
-   *
-   * @remarks
-   * Not all backends support operation cancellation. This method will
-   * attempt to cancel the operation but success is not guaranteed.
-   *
-   * @param operationId - The unique identifier of the operation to cancel
-   * @returns Promise resolving to true if cancellation was successful
-   * @throws {Error} When cancellation is not supported or fails
-   *
-   * @example
-   * ```typescript
-   * try {
-   *   const cancelled = await vana.operations.cancel(operationId);
-   *   if (cancelled) {
-   *     console.log('Operation cancelled successfully');
-   *   }
-   * } catch (error) {
-   *   console.error('Failed to cancel operation:', error);
-   * }
-   * ```
-   */
-  async cancel(_operationId) {
-    if (!this.context.relayer) {
-      throw new Error("Relayer not configured");
-    }
-    throw new Error("Operation cancellation is not yet implemented");
-  }
-  /**
-   * Processes queued operations from the operation store.
-   *
-   * @remarks
-   * This method is designed for worker processes that handle asynchronous
-   * operation processing. It fetches queued operations, processes them with
-   * proper nonce management and gas escalation, and handles retries.
-   *
-   * This is typically called from a background worker or cron job to process
-   * operations that were queued for asynchronous execution.
-   *
-   * @param config - Configuration for queue processing
-   * @returns Promise resolving to processing results
-   *
-   * @example
-   * ```typescript
-   * // In a worker process
-   * const results = await vana.operations.processQueue({
-   *   operationStore,
-   *   atomicStore,
-   *   walletClient,
-   *   publicClient,
-   *   maxOperations: 10,
-   *   onOperationComplete: (id, success) => {
-   *     console.log(`Operation ${id}: ${success ? 'completed' : 'failed'}`);
-   *   }
-   * });
-   *
-   * console.log(`Processed ${results.processed} operations`);
-   * ```
-   */
-  async processQueue(config) {
-    const {
-      operationStore,
-      atomicStore,
-      walletClient,
-      publicClient,
-      maxOperations = 10,
-      maxRetries = 3,
-      gasEscalationFactor = 1.2,
-      maxGasMultiplier = 3,
-      onOperationComplete,
-      onError
-    } = config;
-    const results = {
-      processed: 0,
-      succeeded: 0,
-      failed: 0,
-      errors: []
-    };
-    const nonceManager = atomicStore ? new DistributedNonceManager({
-      atomicStore,
-      publicClient
-    }) : new InMemoryNonceManager(publicClient);
-    const operations = await operationStore.getQueuedOperations({
-      limit: maxOperations
-    });
-    console.log(
-      `[OperationsController] Processing ${operations.length} queued operations`
-    );
-    for (const operation of operations) {
-      results.processed++;
-      try {
-        await operationStore.updateStatus(operation.id, "processing");
-        const storedTx = JSON.parse(operation.data, (_key, value) => {
-          if (typeof value === "string" && value.startsWith("__BIGINT__")) {
-            return BigInt(value.slice(10));
-          }
-          return value;
-        });
-        const chainId = await walletClient.getChainId();
-        const [address] = await walletClient.getAddresses();
-        const nonce = await nonceManager.assignNonce(address, chainId);
-        if (nonce === null || nonce === void 0) {
-          throw new Error("Failed to acquire nonce");
-        }
-        const retryCount = operation.retryCount ?? 0;
-        const gasMultiplier = Math.min(
-          Math.pow(gasEscalationFactor, retryCount),
-          maxGasMultiplier
-        );
-        const escalatedTx = {
-          ...storedTx,
-          nonce,
-          maxFeePerGas: storedTx.maxFeePerGas ? BigInt(Math.floor(Number(storedTx.maxFeePerGas) * gasMultiplier)) : void 0,
-          maxPriorityFeePerGas: storedTx.maxPriorityFeePerGas ? BigInt(
-            Math.floor(
-              Number(storedTx.maxPriorityFeePerGas) * gasMultiplier
-            )
-          ) : void 0,
-          gasPrice: storedTx.gasPrice ? BigInt(Math.floor(Number(storedTx.gasPrice) * gasMultiplier)) : void 0
-        };
-        console.log(
-          `[OperationsController] Processing operation ${operation.id} with nonce ${nonce} (retry ${retryCount})`
-        );
-        const hash = await walletClient.sendTransaction(escalatedTx);
-        await operationStore.updateStatus(operation.id, "submitted", {
-          hash,
-          nonce,
-          submittedAt: Date.now()
-        });
-        console.log(
-          `[OperationsController] Operation ${operation.id} submitted: ${hash}`
-        );
-        const receipt = await publicClient.waitForTransactionReceipt({
-          hash,
-          timeout: 6e4
-          // 1 minute timeout
-        });
-        if (receipt.status === "success") {
-          await operationStore.updateStatus(operation.id, "completed", {
-            receipt,
-            completedAt: Date.now()
-          });
-          results.succeeded++;
-          onOperationComplete?.(operation.id, true);
-          console.log(
-            `[OperationsController] Operation ${operation.id} completed successfully`
-          );
-        } else {
-          throw new Error(`Transaction reverted: ${hash}`);
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error(
-          `[OperationsController] Operation ${operation.id} failed:`,
-          errorMessage
-        );
-        results.failed++;
-        results.errors.push({
-          operationId: operation.id,
-          error: errorMessage
-        });
-        const retryCount = (operation.retryCount ?? 0) + 1;
-        if (retryCount >= maxRetries) {
-          await operationStore.updateStatus(operation.id, "failed", {
-            error: errorMessage,
-            failedAt: Date.now()
-          });
-        } else {
-          await operationStore.updateStatus(operation.id, "queued", {
-            retryCount,
-            lastError: errorMessage,
-            lastAttemptAt: Date.now()
-          });
-        }
-        onOperationComplete?.(operation.id, false);
-        onError?.(
-          operation.id,
-          error instanceof Error ? error : new Error(errorMessage)
-        );
-      }
-    }
-    return results;
-  }
-  /**
-   * Burns a stuck nonce by sending a minimal self-transfer.
-   *
-   * @remarks
-   * This method is used to unblock the transaction queue when a transaction
-   * is stuck. It sends a minimal amount to the same address with the stuck
-   * nonce and higher gas to ensure it gets mined.
-   *
-   * @param config - Configuration for nonce burning
-   * @returns Promise resolving to the burn transaction hash
-   *
-   * @example
-   * ```typescript
-   * const hash = await vana.operations.burnStuckNonce({
-   *   walletClient,
-   *   publicClient,
-   *   atomicStore,
-   *   address: relayerAddress,
-   *   stuckNonce: 42
-   * });
-   *
-   * console.log(`Burned stuck nonce with tx: ${hash}`);
-   * ```
-   */
-  async burnStuckNonce(config) {
-    const { walletClient, publicClient, atomicStore, address, stuckNonce } = config;
-    console.log(
-      `[OperationsController] Burning stuck nonce ${stuckNonce} for ${address}`
-    );
-    const gasPrice = await publicClient.getGasPrice();
-    const premiumGasPrice = gasPrice * 150n / 100n;
-    const hash = await walletClient.sendTransaction({
-      account: walletClient.account,
-      chain: walletClient.chain,
-      to: address,
-      value: parseEther("0.00001"),
-      // Minimal amount
-      nonce: stuckNonce,
-      gasPrice: premiumGasPrice,
-      gas: 21000n
-      // Standard transfer gas
-    });
-    console.log(`[OperationsController] Nonce burn transaction sent: ${hash}`);
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash,
-      timeout: 12e4
-      // 2 minutes
-    });
-    if (receipt.status === "success") {
-      console.log(
-        `[OperationsController] Nonce ${stuckNonce} successfully burned`
-      );
-      const chainId = await walletClient.getChainId();
-      const lastUsedKey = `nonce:${chainId}:${address}:lastUsed`;
-      const currentLastUsed = await atomicStore.get(lastUsedKey);
-      if (!currentLastUsed || parseInt(currentLastUsed) < stuckNonce) {
-        await atomicStore.set(lastUsedKey, stuckNonce.toString());
-      }
-    } else {
-      throw new Error(`Nonce burn transaction failed: ${hash}`);
-    }
-    return hash;
-  }
-  /**
-   * Maps a relayer response to an OperationStatus object.
-   * @internal
-   */
-  mapResponseToStatus(response, operationId) {
-    switch (response.type) {
-      case "pending":
-        return {
-          type: "pending",
-          operationId: response.operationId
-        };
-      case "submitted":
-        return {
-          type: "submitted",
-          hash: response.hash
-        };
-      case "confirmed":
-        return {
-          type: "confirmed",
-          hash: response.hash,
-          receipt: response.receipt
-        };
-      case "error":
-        return {
-          type: "failed",
-          error: response.error || "Unknown error",
-          operationId
-        };
-      case "signed":
-        return {
-          type: "submitted",
-          hash: response.hash
-        };
-      case "direct":
-        return {
-          type: "confirmed",
-          hash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-          receipt: void 0
-        };
-      default:
-        return {
-          type: "pending",
-          operationId
-        };
-    }
-  }
-}
-export {
-  OperationsController
-};
-//# sourceMappingURL=operations.js.map

package/dist/controllers/operations.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/controllers/operations.ts"],"sourcesContent":["/**\n * Operations controller for managing and recovering asynchronous relayer operations.\n *\n * @module\n */\n\nimport type { ControllerContext } from \"./permissions\";\nimport type { OperationStatus } from \"../types/options\";\nimport type {\n  UnifiedRelayerRequest,\n  UnifiedRelayerResponse,\n} from \"../types/relayer\";\nimport type { IOperationStore } from \"../types/operationStore\";\nimport type { IAtomicStore } from \"../types/atomicStore\";\nimport type { WalletClient, PublicClient } from \"viem\";\nimport { BaseController } from \"./base\";\nimport { PollingManager } from \"../core/pollingManager\";\nimport { DistributedNonceManager } from \"../core/nonceManager\";\nimport { InMemoryNonceManager } from \"../core/inMemoryNonceManager\";\nimport { parseEther } from \"viem\";\n\n/**\n * Controller for managing asynchronous operations.\n *\n * This controller provides methods to check the status of pending operations\n * and recover from interrupted transactions.\n *\n * @category Controllers\n * @example\n * ```typescript\n * // Recover an orphaned operation\n * try {\n *   const result = await vana.permissions.grant(...);\n * } catch (error) {\n *   if (error instanceof TransactionPendingError) {\n *     // Save the operation ID\n *     localStorage.setItem('pendingOp', error.operationId);\n *\n *     // Later, check the status\n *     const operationId = localStorage.getItem('pendingOp');\n *     const status = await vana.operations.getStatus(operationId);\n *\n *     if (status.type === 'confirmed') {\n *       console.log('Transaction confirmed:', status.receipt);\n *     }\n *   }\n * }\n * ```\n */\nexport class OperationsController extends BaseController {\n  constructor(context: ControllerContext) {\n    super(context);\n  }\n\n  /**\n   * Gets the current status of an operation.\n   *\n   * @remarks\n   * This method allows recovery of operations that were interrupted due to:\n   * - Browser tab closure\n   * - Network disconnection\n   * - Application errors\n   * - Timeout during polling\n   *\n   * The method queries the backend for the current operation state without\n   * starting a new polling session.\n   *\n   * @param operationId - The unique identifier of the operation to check\n   * @returns Promise resolving to the current operation status\n   * @throws {Error} When relayer is not configured\n   * @throws {Error} When operation is not found\n   *\n   * @example\n   * ```typescript\n   * const status = await vana.operations.getStatus('550e8400-e29b-41d4-a716-446655440000');\n   *\n   * switch(status.type) {\n   *   case 'pending':\n   *     console.log('Still processing...');\n   *     break;\n   *   case 'queued':\n   *     console.log(`Position in queue: ${status.position}`);\n   *     break;\n   *   case 'confirmed':\n   *     console.log(`Transaction confirmed: ${status.receipt.transactionHash}`);\n   *     break;\n   *   case 'failed':\n   *     console.error(`Operation failed: ${status.error}`);\n   *     break;\n   * }\n   * ```\n   */\n  async getStatus(operationId: string): Promise<OperationStatus> {\n    if (!this.context.relayer) {\n      throw new Error(\"Relayer not configured\");\n    }\n\n    const request: UnifiedRelayerRequest = {\n      type: \"status_check\",\n      operationId,\n    };\n\n    const response = await this.context.relayer(request);\n\n    return this.mapResponseToStatus(response, operationId);\n  }\n\n  /**\n   * Waits for an operation to complete and returns the final result.\n   *\n   * @remarks\n   * This method is useful for resuming polling of an operation that was\n   * previously interrupted. Unlike `getStatus`, this method will actively\n   * poll until the operation reaches a final state (confirmed or failed).\n   *\n   * @param operationId - The unique identifier of the operation to wait for\n   * @param options - Optional configuration for polling behavior\n   * @returns Promise resolving when the operation is confirmed\n   * @throws {TransactionPendingError} When polling times out\n   * @throws {Error} When the operation fails\n   *\n   * @example\n   * ```typescript\n   * // Resume polling with status updates\n   * const result = await vana.operations.waitForConfirmation(operationId, {\n   *   onStatusUpdate: (status) => {\n   *     console.log(`Current status: ${status.type}`);\n   *   },\n   *   timeout: 600000 // 10 minutes\n   * });\n   *\n   * console.log('Transaction confirmed:', result.hash);\n   * ```\n   */\n  async waitForConfirmation(\n    operationId: string,\n    options?: {\n      signal?: AbortSignal;\n      onStatusUpdate?: (status: OperationStatus) => void;\n      timeout?: number;\n      initialInterval?: number;\n      maxInterval?: number;\n    },\n  ): Promise<{ hash: string; receipt?: any }> {\n    if (!this.context.relayer) {\n      throw new Error(\"Relayer not configured\");\n    }\n\n    // First check if already completed\n    const currentStatus = await this.getStatus(operationId);\n\n    if (currentStatus.type === \"confirmed\") {\n      return {\n        hash: currentStatus.hash,\n        receipt: currentStatus.receipt,\n      };\n    }\n\n    if (currentStatus.type === \"failed\") {\n      throw new Error(currentStatus.error);\n    }\n\n    // Start polling if still pending\n    const pollingManager = new PollingManager(this.context.relayer);\n\n    return await pollingManager.startPolling(operationId, {\n      signal: options?.signal,\n      onStatusUpdate: options?.onStatusUpdate,\n      timeout: options?.timeout,\n      initialInterval: options?.initialInterval,\n      maxInterval: options?.maxInterval,\n    });\n  }\n\n  /**\n   * Cancels a pending operation if supported by the backend.\n   *\n   * @remarks\n   * Not all backends support operation cancellation. This method will\n   * attempt to cancel the operation but success is not guaranteed.\n   *\n   * @param operationId - The unique identifier of the operation to cancel\n   * @returns Promise resolving to true if cancellation was successful\n   * @throws {Error} When cancellation is not supported or fails\n   *\n   * @example\n   * ```typescript\n   * try {\n   *   const cancelled = await vana.operations.cancel(operationId);\n   *   if (cancelled) {\n   *     console.log('Operation cancelled successfully');\n   *   }\n   * } catch (error) {\n   *   console.error('Failed to cancel operation:', error);\n   * }\n   * ```\n   */\n  async cancel(_operationId: string): Promise<boolean> {\n    if (!this.context.relayer) {\n      throw new Error(\"Relayer not configured\");\n    }\n\n    // This would require a new request type in the relayer protocol\n    // For now, we'll throw an error indicating it's not implemented\n    throw new Error(\"Operation cancellation is not yet implemented\");\n\n    // Future implementation would look like:\n    // const request: UnifiedRelayerRequest = {\n    //   type: 'cancel_operation',\n    //   operationId: _operationId\n    // };\n    //\n    // const response = await this.context.relayer(request);\n    // return response.type === 'success';\n  }\n\n  /**\n   * Processes queued operations from the operation store.\n   *\n   * @remarks\n   * This method is designed for worker processes that handle asynchronous\n   * operation processing. It fetches queued operations, processes them with\n   * proper nonce management and gas escalation, and handles retries.\n   *\n   * This is typically called from a background worker or cron job to process\n   * operations that were queued for asynchronous execution.\n   *\n   * @param config - Configuration for queue processing\n   * @returns Promise resolving to processing results\n   *\n   * @example\n   * ```typescript\n   * // In a worker process\n   * const results = await vana.operations.processQueue({\n   *   operationStore,\n   *   atomicStore,\n   *   walletClient,\n   *   publicClient,\n   *   maxOperations: 10,\n   *   onOperationComplete: (id, success) => {\n   *     console.log(`Operation ${id}: ${success ? 'completed' : 'failed'}`);\n   *   }\n   * });\n   *\n   * console.log(`Processed ${results.processed} operations`);\n   * ```\n   */\n  async processQueue(config: {\n    operationStore: IOperationStore;\n    atomicStore: IAtomicStore;\n    walletClient: WalletClient;\n    publicClient: PublicClient;\n    maxOperations?: number;\n    maxRetries?: number;\n    gasEscalationFactor?: number;\n    maxGasMultiplier?: number;\n    onOperationComplete?: (operationId: string, success: boolean) => void;\n    onError?: (operationId: string, error: Error) => void;\n  }): Promise<{\n    processed: number;\n    succeeded: number;\n    failed: number;\n    errors: Array<{ operationId: string; error: string }>;\n  }> {\n    const {\n      operationStore,\n      atomicStore,\n      walletClient,\n      publicClient,\n      maxOperations = 10,\n      maxRetries = 3,\n      gasEscalationFactor = 1.2,\n      maxGasMultiplier = 3,\n      onOperationComplete,\n      onError,\n    } = config;\n\n    const results = {\n      processed: 0,\n      succeeded: 0,\n      failed: 0,\n      errors: [] as Array<{ operationId: string; error: string }>,\n    };\n\n    // Initialize appropriate nonce manager based on configuration\n    // If we have an atomicStore, use distributed nonce manager for multi-instance safety\n    // Otherwise use in-memory for single-instance simplicity\n    const nonceManager = atomicStore\n      ? new DistributedNonceManager({\n          atomicStore,\n          publicClient,\n        })\n      : new InMemoryNonceManager(publicClient);\n\n    // Get queued operations\n    const operations = await operationStore.getQueuedOperations({\n      limit: maxOperations,\n    });\n\n    console.log(\n      `[OperationsController] Processing ${operations.length} queued operations`,\n    );\n\n    for (const operation of operations) {\n      results.processed++;\n\n      try {\n        // Mark as processing\n        await operationStore.updateStatus(operation.id, \"processing\");\n\n        // Parse the stored transaction\n        const storedTx = JSON.parse(operation.data, (_key, value) => {\n          if (typeof value === \"string\" && value.startsWith(\"__BIGINT__\")) {\n            return BigInt(value.slice(10));\n          }\n          return value;\n        });\n\n        // Get chain ID from wallet client\n        const chainId = await walletClient.getChainId();\n\n        // Get relayer address\n        const [address] = await walletClient.getAddresses();\n\n        // Assign nonce atomically\n        const nonce = await nonceManager.assignNonce(address, chainId);\n\n        if (nonce === null || nonce === undefined) {\n          throw new Error(\"Failed to acquire nonce\");\n        }\n\n        // Calculate gas with escalation based on retry count\n        const retryCount = operation.retryCount ?? 0;\n        const gasMultiplier = Math.min(\n          Math.pow(gasEscalationFactor, retryCount),\n          maxGasMultiplier,\n        );\n\n        // Apply gas escalation\n        const escalatedTx = {\n          ...storedTx,\n          nonce,\n          maxFeePerGas: storedTx.maxFeePerGas\n            ? BigInt(Math.floor(Number(storedTx.maxFeePerGas) * gasMultiplier))\n            : undefined,\n          maxPriorityFeePerGas: storedTx.maxPriorityFeePerGas\n            ? BigInt(\n                Math.floor(\n                  Number(storedTx.maxPriorityFeePerGas) * gasMultiplier,\n                ),\n              )\n            : undefined,\n          gasPrice: storedTx.gasPrice\n            ? BigInt(Math.floor(Number(storedTx.gasPrice) * gasMultiplier))\n            : undefined,\n        };\n\n        console.log(\n          `[OperationsController] Processing operation ${operation.id} with nonce ${nonce} (retry ${retryCount})`,\n        );\n\n        // Send transaction\n        const hash = await walletClient.sendTransaction(escalatedTx);\n\n        // Update status to submitted\n        await operationStore.updateStatus(operation.id, \"submitted\", {\n          hash,\n          nonce,\n          submittedAt: Date.now(),\n        });\n\n        console.log(\n          `[OperationsController] Operation ${operation.id} submitted: ${hash}`,\n        );\n\n        // Wait for confirmation (with timeout)\n        const receipt = await publicClient.waitForTransactionReceipt({\n          hash,\n          timeout: 60000, // 1 minute timeout\n        });\n\n        if (receipt.status === \"success\") {\n          // Update to completed\n          await operationStore.updateStatus(operation.id, \"completed\", {\n            receipt,\n            completedAt: Date.now(),\n          });\n\n          results.succeeded++;\n          onOperationComplete?.(operation.id, true);\n\n          console.log(\n            `[OperationsController] Operation ${operation.id} completed successfully`,\n          );\n        } else {\n          // Transaction reverted\n          throw new Error(`Transaction reverted: ${hash}`);\n        }\n      } catch (error) {\n        const errorMessage =\n          error instanceof Error ? error.message : \"Unknown error\";\n        console.error(\n          `[OperationsController] Operation ${operation.id} failed:`,\n          errorMessage,\n        );\n\n        results.failed++;\n        results.errors.push({\n          operationId: operation.id,\n          error: errorMessage,\n        });\n\n        const retryCount = (operation.retryCount ?? 0) + 1;\n\n        if (retryCount >= maxRetries) {\n          // Max retries reached, mark as failed\n          await operationStore.updateStatus(operation.id, \"failed\", {\n            error: errorMessage,\n            failedAt: Date.now(),\n          });\n        } else {\n          // Return to queue for retry\n          await operationStore.updateStatus(operation.id, \"queued\", {\n            retryCount,\n            lastError: errorMessage,\n            lastAttemptAt: Date.now(),\n          });\n        }\n\n        onOperationComplete?.(operation.id, false);\n        onError?.(\n          operation.id,\n          error instanceof Error ? error : new Error(errorMessage),\n        );\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Burns a stuck nonce by sending a minimal self-transfer.\n   *\n   * @remarks\n   * This method is used to unblock the transaction queue when a transaction\n   * is stuck. It sends a minimal amount to the same address with the stuck\n   * nonce and higher gas to ensure it gets mined.\n   *\n   * @param config - Configuration for nonce burning\n   * @returns Promise resolving to the burn transaction hash\n   *\n   * @example\n   * ```typescript\n   * const hash = await vana.operations.burnStuckNonce({\n   *   walletClient,\n   *   publicClient,\n   *   atomicStore,\n   *   address: relayerAddress,\n   *   stuckNonce: 42\n   * });\n   *\n   * console.log(`Burned stuck nonce with tx: ${hash}`);\n   * ```\n   */\n  async burnStuckNonce(config: {\n    walletClient: WalletClient;\n    publicClient: PublicClient;\n    atomicStore: IAtomicStore;\n    address: `0x${string}`;\n    stuckNonce: number;\n  }): Promise<string> {\n    const { walletClient, publicClient, atomicStore, address, stuckNonce } =\n      config;\n\n    console.log(\n      `[OperationsController] Burning stuck nonce ${stuckNonce} for ${address}`,\n    );\n\n    // Get current gas prices with 50% premium\n    const gasPrice = await publicClient.getGasPrice();\n    const premiumGasPrice = (gasPrice * 150n) / 100n;\n\n    // Send minimal self-transfer\n    const hash = await walletClient.sendTransaction({\n      account: walletClient.account!,\n      chain: walletClient.chain,\n      to: address,\n      value: parseEther(\"0.00001\"), // Minimal amount\n      nonce: stuckNonce,\n      gasPrice: premiumGasPrice,\n      gas: 21000n, // Standard transfer gas\n    });\n\n    console.log(`[OperationsController] Nonce burn transaction sent: ${hash}`);\n\n    // Wait for confirmation\n    const receipt = await publicClient.waitForTransactionReceipt({\n      hash,\n      timeout: 120000, // 2 minutes\n    });\n\n    if (receipt.status === \"success\") {\n      console.log(\n        `[OperationsController] Nonce ${stuckNonce} successfully burned`,\n      );\n\n      // Update stored nonce to reflect the burn\n      const chainId = await walletClient.getChainId();\n      const lastUsedKey = `nonce:${chainId}:${address}:lastUsed`;\n\n      // Only update if this nonce was higher than stored\n      const currentLastUsed = await atomicStore.get(lastUsedKey);\n      if (!currentLastUsed || parseInt(currentLastUsed) < stuckNonce) {\n        await atomicStore.set(lastUsedKey, stuckNonce.toString());\n      }\n    } else {\n      throw new Error(`Nonce burn transaction failed: ${hash}`);\n    }\n\n    return hash;\n  }\n\n  /**\n   * Maps a relayer response to an OperationStatus object.\n   * @internal\n   */\n  private mapResponseToStatus(\n    response: UnifiedRelayerResponse,\n    operationId: string,\n  ): OperationStatus {\n    switch (response.type) {\n      case \"pending\":\n        return {\n          type: \"pending\",\n          operationId: response.operationId,\n        };\n\n      case \"submitted\":\n        return {\n          type: \"submitted\",\n          hash: response.hash,\n        };\n\n      case \"confirmed\":\n        return {\n          type: \"confirmed\",\n          hash: response.hash,\n          receipt: response.receipt,\n        };\n\n      case \"error\":\n        return {\n          type: \"failed\",\n          error: response.error || \"Unknown error\",\n          operationId,\n        };\n\n      case \"signed\":\n        // Signed responses are considered submitted\n        return {\n          type: \"submitted\",\n          hash: response.hash,\n        };\n\n      case \"direct\":\n        // Direct responses are immediately confirmed\n        // For direct operations, we don't have a transaction hash\n        return {\n          type: \"confirmed\",\n          hash: \"0x0000000000000000000000000000000000000000000000000000000000000000\",\n          receipt: undefined,\n        };\n\n      default:\n        // Handle other response types as pending\n        return {\n          type: \"pending\",\n          operationId,\n        };\n    }\n  }\n}\n"],"mappings":"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","names":[]}