@opendatalabs/vana-sdk 0.1.0-alpha.ffe4659 → 2.1.0

package/dist/controllers/operations.d.ts

@@ -0,0 +1,229 @@
+/**
+ * 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

@@ -0,0 +1,406 @@
+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

@@ -0,0 +1 @@
+{"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":"AAeA,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAC/B,SAAS,+BAA+B;AACxC,SAAS,4BAA4B;AACrC,SAAS,kBAAkB;AA8BpB,MAAM,6BAA6B,eAAe;AAAA,EACvD,YAAY,SAA4B;AACtC,UAAM,OAAO;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwCA,MAAM,UAAU,aAA+C;AAC7D,QAAI,CAAC,KAAK,QAAQ,SAAS;AACzB,YAAM,IAAI,MAAM,wBAAwB;AAAA,IAC1C;AAEA,UAAM,UAAiC;AAAA,MACrC,MAAM;AAAA,MACN;AAAA,IACF;AAEA,UAAM,WAAW,MAAM,KAAK,QAAQ,QAAQ,OAAO;AAEnD,WAAO,KAAK,oBAAoB,UAAU,WAAW;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6BA,MAAM,oBACJ,aACA,SAO0C;AAC1C,QAAI,CAAC,KAAK,QAAQ,SAAS;AACzB,YAAM,IAAI,MAAM,wBAAwB;AAAA,IAC1C;AAGA,UAAM,gBAAgB,MAAM,KAAK,UAAU,WAAW;AAEtD,QAAI,cAAc,SAAS,aAAa;AACtC,aAAO;AAAA,QACL,MAAM,cAAc;AAAA,QACpB,SAAS,cAAc;AAAA,MACzB;AAAA,IACF;AAEA,QAAI,cAAc,SAAS,UAAU;AACnC,YAAM,IAAI,MAAM,cAAc,KAAK;AAAA,IACrC;AAGA,UAAM,iBAAiB,IAAI,eAAe,KAAK,QAAQ,OAAO;AAE9D,WAAO,MAAM,eAAe,aAAa,aAAa;AAAA,MACpD,QAAQ,SAAS;AAAA,MACjB,gBAAgB,SAAS;AAAA,MACzB,SAAS,SAAS;AAAA,MAClB,iBAAiB,SAAS;AAAA,MAC1B,aAAa,SAAS;AAAA,IACxB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAyBA,MAAM,OAAO,cAAwC;AACnD,QAAI,CAAC,KAAK,QAAQ,SAAS;AACzB,YAAM,IAAI,MAAM,wBAAwB;AAAA,IAC1C;AAIA,UAAM,IAAI,MAAM,+CAA+C;AAAA,EAUjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiCA,MAAM,aAAa,QAgBhB;AACD,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,gBAAgB;AAAA,MAChB,aAAa;AAAA,MACb,sBAAsB;AAAA,MACtB,mBAAmB;AAAA,MACnB;AAAA,MACA;AAAA,IACF,IAAI;AAEJ,UAAM,UAAU;AAAA,MACd,WAAW;AAAA,MACX,WAAW;AAAA,MACX,QAAQ;AAAA,MACR,QAAQ,CAAC;AAAA,IACX;AAKA,UAAM,eAAe,cACjB,IAAI,wBAAwB;AAAA,MAC1B;AAAA,MACA;AAAA,IACF,CAAC,IACD,IAAI,qBAAqB,YAAY;AAGzC,UAAM,aAAa,MAAM,eAAe,oBAAoB;AAAA,MAC1D,OAAO;AAAA,IACT,CAAC;AAED,YAAQ;AAAA,MACN,qCAAqC,WAAW,MAAM;AAAA,IACxD;AAEA,eAAW,aAAa,YAAY;AAClC,cAAQ;AAER,UAAI;AAEF,cAAM,eAAe,aAAa,UAAU,IAAI,YAAY;AAG5D,cAAM,WAAW,KAAK,MAAM,UAAU,MAAM,CAAC,MAAM,UAAU;AAC3D,cAAI,OAAO,UAAU,YAAY,MAAM,WAAW,YAAY,GAAG;AAC/D,mBAAO,OAAO,MAAM,MAAM,EAAE,CAAC;AAAA,UAC/B;AACA,iBAAO;AAAA,QACT,CAAC;AAGD,cAAM,UAAU,MAAM,aAAa,WAAW;AAG9C,cAAM,CAAC,OAAO,IAAI,MAAM,aAAa,aAAa;AAGlD,cAAM,QAAQ,MAAM,aAAa,YAAY,SAAS,OAAO;AAE7D,YAAI,UAAU,QAAQ,UAAU,QAAW;AACzC,gBAAM,IAAI,MAAM,yBAAyB;AAAA,QAC3C;AAGA,cAAM,aAAa,UAAU,cAAc;AAC3C,cAAM,gBAAgB,KAAK;AAAA,UACzB,KAAK,IAAI,qBAAqB,UAAU;AAAA,UACxC;AAAA,QACF;AAGA,cAAM,cAAc;AAAA,UAClB,GAAG;AAAA,UACH;AAAA,UACA,cAAc,SAAS,eACnB,OAAO,KAAK,MAAM,OAAO,SAAS,YAAY,IAAI,aAAa,CAAC,IAChE;AAAA,UACJ,sBAAsB,SAAS,uBAC3B;AAAA,YACE,KAAK;AAAA,cACH,OAAO,SAAS,oBAAoB,IAAI;AAAA,YAC1C;AAAA,UACF,IACA;AAAA,UACJ,UAAU,SAAS,WACf,OAAO,KAAK,MAAM,OAAO,SAAS,QAAQ,IAAI,aAAa,CAAC,IAC5D;AAAA,QACN;AAEA,gBAAQ;AAAA,UACN,+CAA+C,UAAU,EAAE,eAAe,KAAK,WAAW,UAAU;AAAA,QACtG;AAGA,cAAM,OAAO,MAAM,aAAa,gBAAgB,WAAW;AAG3D,cAAM,eAAe,aAAa,UAAU,IAAI,aAAa;AAAA,UAC3D;AAAA,UACA;AAAA,UACA,aAAa,KAAK,IAAI;AAAA,QACxB,CAAC;AAED,gBAAQ;AAAA,UACN,oCAAoC,UAAU,EAAE,eAAe,IAAI;AAAA,QACrE;AAGA,cAAM,UAAU,MAAM,aAAa,0BAA0B;AAAA,UAC3D;AAAA,UACA,SAAS;AAAA;AAAA,QACX,CAAC;AAED,YAAI,QAAQ,WAAW,WAAW;AAEhC,gBAAM,eAAe,aAAa,UAAU,IAAI,aAAa;AAAA,YAC3D;AAAA,YACA,aAAa,KAAK,IAAI;AAAA,UACxB,CAAC;AAED,kBAAQ;AACR,gCAAsB,UAAU,IAAI,IAAI;AAExC,kBAAQ;AAAA,YACN,oCAAoC,UAAU,EAAE;AAAA,UAClD;AAAA,QACF,OAAO;AAEL,gBAAM,IAAI,MAAM,yBAAyB,IAAI,EAAE;AAAA,QACjD;AAAA,MACF,SAAS,OAAO;AACd,cAAM,eACJ,iBAAiB,QAAQ,MAAM,UAAU;AAC3C,gBAAQ;AAAA,UACN,oCAAoC,UAAU,EAAE;AAAA,UAChD;AAAA,QACF;AAEA,gBAAQ;AACR,gBAAQ,OAAO,KAAK;AAAA,UAClB,aAAa,UAAU;AAAA,UACvB,OAAO;AAAA,QACT,CAAC;AAED,cAAM,cAAc,UAAU,cAAc,KAAK;AAEjD,YAAI,cAAc,YAAY;AAE5B,gBAAM,eAAe,aAAa,UAAU,IAAI,UAAU;AAAA,YACxD,OAAO;AAAA,YACP,UAAU,KAAK,IAAI;AAAA,UACrB,CAAC;AAAA,QACH,OAAO;AAEL,gBAAM,eAAe,aAAa,UAAU,IAAI,UAAU;AAAA,YACxD;AAAA,YACA,WAAW;AAAA,YACX,eAAe,KAAK,IAAI;AAAA,UAC1B,CAAC;AAAA,QACH;AAEA,8BAAsB,UAAU,IAAI,KAAK;AACzC;AAAA,UACE,UAAU;AAAA,UACV,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,YAAY;AAAA,QACzD;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0BA,MAAM,eAAe,QAMD;AAClB,UAAM,EAAE,cAAc,cAAc,aAAa,SAAS,WAAW,IACnE;AAEF,YAAQ;AAAA,MACN,8CAA8C,UAAU,QAAQ,OAAO;AAAA,IACzE;AAGA,UAAM,WAAW,MAAM,aAAa,YAAY;AAChD,UAAM,kBAAmB,WAAW,OAAQ;AAG5C,UAAM,OAAO,MAAM,aAAa,gBAAgB;AAAA,MAC9C,SAAS,aAAa;AAAA,MACtB,OAAO,aAAa;AAAA,MACpB,IAAI;AAAA,MACJ,OAAO,WAAW,SAAS;AAAA;AAAA,MAC3B,OAAO;AAAA,MACP,UAAU;AAAA,MACV,KAAK;AAAA;AAAA,IACP,CAAC;AAED,YAAQ,IAAI,uDAAuD,IAAI,EAAE;AAGzE,UAAM,UAAU,MAAM,aAAa,0BAA0B;AAAA,MAC3D;AAAA,MACA,SAAS;AAAA;AAAA,IACX,CAAC;AAED,QAAI,QAAQ,WAAW,WAAW;AAChC,cAAQ;AAAA,QACN,gCAAgC,UAAU;AAAA,MAC5C;AAGA,YAAM,UAAU,MAAM,aAAa,WAAW;AAC9C,YAAM,cAAc,SAAS,OAAO,IAAI,OAAO;AAG/C,YAAM,kBAAkB,MAAM,YAAY,IAAI,WAAW;AACzD,UAAI,CAAC,mBAAmB,SAAS,eAAe,IAAI,YAAY;AAC9D,cAAM,YAAY,IAAI,aAAa,WAAW,SAAS,CAAC;AAAA,MAC1D;AAAA,IACF,OAAO;AACL,YAAM,IAAI,MAAM,kCAAkC,IAAI,EAAE;AAAA,IAC1D;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,oBACN,UACA,aACiB;AACjB,YAAQ,SAAS,MAAM;AAAA,MACrB,KAAK;AACH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,aAAa,SAAS;AAAA,QACxB;AAAA,MAEF,KAAK;AACH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,MAAM,SAAS;AAAA,QACjB;AAAA,MAEF,KAAK;AACH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,MAAM,SAAS;AAAA,UACf,SAAS,SAAS;AAAA,QACpB;AAAA,MAEF,KAAK;AACH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,OAAO,SAAS,SAAS;AAAA,UACzB;AAAA,QACF;AAAA,MAEF,KAAK;AAEH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,MAAM,SAAS;AAAA,QACjB;AAAA,MAEF,KAAK;AAGH,eAAO;AAAA,UACL,MAAM;AAAA,UACN,MAAM;AAAA,UACN,SAAS;AAAA,QACX;AAAA,MAEF;AAEE,eAAO;AAAA,UACL,MAAM;AAAA,UACN;AAAA,QACF;AAAA,IACJ;AAAA,EACF;AACF;","names":[]}