@opendatalabs/vana-sdk 0.1.0-alpha.7ee7635 → 0.1.0-alpha.8117ac2

package/dist/platform/ports/pgp-port.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Port interface for PGP operations
+ *
+ * This interface abstracts away the complexity of the underlying PGP library
+ * and provides a clean, testable API for PGP operations.
+ */
+export interface PgpKeyPairOptions {
+    name?: string;
+    email?: string;
+    passphrase?: string;
+}
+export interface PgpKeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+export interface PgpEncryptInput {
+    text: string;
+    publicKeyArmored: string;
+}
+export interface PgpDecryptInput {
+    messageArmored: string;
+    privateKeyArmored: string;
+    passphrase?: string;
+}
+export interface PgpResult {
+    data: string;
+}
+/**
+ * Clean interface for PGP operations
+ */
+export interface PgpPort {
+    encrypt(input: PgpEncryptInput): Promise<PgpResult>;
+    decrypt(input: PgpDecryptInput): Promise<PgpResult>;
+    generateKeyPair(options?: PgpKeyPairOptions): Promise<PgpKeyPair>;
+}

package/dist/platform/ports/pgp-port.js

@@ -0,0 +1 @@
+//# sourceMappingURL=pgp-port.js.map

package/dist/platform/ports/pgp-port.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/platform/shared/error-utils.d.ts

@@ -12,7 +12,7 @@
  * @param error The original error that occurred
  * @returns Wrapped error with consistent format
  */
-declare function wrapCryptoError(operation: string, error: unknown): Error;
+export declare function wrapCryptoError(operation: string, error: unknown): Error;
 /**
  * Validate encrypted data structure has required fields
  * Ensures encrypted data objects contain the expected properties
@@ -20,6 +20,4 @@ declare function wrapCryptoError(operation: string, error: unknown): Error;
  * @param data The data structure to validate
  * @throws Error if data structure is invalid
  */
-declare function validateEncryptedDataStructure(data: unknown): void;
-
-export { validateEncryptedDataStructure, wrapCryptoError };
+export declare function validateEncryptedDataStructure(data: unknown): void;

package/dist/platform/shared/pgp-utils.cjs

@@ -31,8 +31,8 @@ const STANDARD_PGP_CONFIG = {
 };
 function processPGPKeyOptions(options) {
   return {
-    name: options?.name || "Vana User",
-    email: options?.email || "user@vana.org",
+    name: options?.name ?? "Vana User",
+    email: options?.email ?? "user@vana.org",
     passphrase: options?.passphrase
   };
 }

package/dist/platform/shared/pgp-utils.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/platform/shared/pgp-utils.ts"],"sourcesContent":["/**\n * Shared PGP utilities for platform adapters\n *\n * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.\n * All functions are pure utilities that can be safely shared across platforms.\n */\n\n/**\n * Standard OpenPGP configuration for consistent behavior across platforms\n * Uses enum values instead of importing openpgp to avoid loading issues\n */\nexport const STANDARD_PGP_CONFIG = {\n  preferredCompressionAlgorithm: 2, // zlib (openpgp.enums.compression.zlib)\n  preferredSymmetricAlgorithm: 7, // aes256 (openpgp.enums.symmetric.aes256)\n} as const;\n\n/**\n * Process PGP key generation options with sensible defaults\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Processed options with defaults applied\n */\nexport function processPGPKeyOptions(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  return {\n    name: options?.name || \"Vana User\",\n    email: options?.email || \"user@vana.org\",\n    passphrase: options?.passphrase,\n  };\n}\n\n/**\n * Get standard PGP key generation parameters\n * Combines default values with standard configuration\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Complete key generation parameters object\n */\nexport function getPGPKeyGenParams(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  const { name, email, passphrase } = processPGPKeyOptions(options);\n\n  return {\n    type: \"rsa\" as const,\n    rsaBits: 2048,\n    userIDs: [{ name, email }],\n    passphrase,\n    config: STANDARD_PGP_CONFIG,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWO,MAAM,sBAAsB;AAAA,EACjC,+BAA+B;AAAA;AAAA,EAC/B,6BAA6B;AAAA;AAC/B;AAWO,SAAS,qBAAqB,SAIlC;AACD,SAAO;AAAA,IACL,MAAM,SAAS,QAAQ;AAAA,IACvB,OAAO,SAAS,SAAS;AAAA,IACzB,YAAY,SAAS;AAAA,EACvB;AACF;AAYO,SAAS,mBAAmB,SAIhC;AACD,QAAM,EAAE,MAAM,OAAO,WAAW,IAAI,qBAAqB,OAAO;AAEhE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;AAAA,IACzB;AAAA,IACA,QAAQ;AAAA,EACV;AACF;","names":[]}
+{"version":3,"sources":["../../../src/platform/shared/pgp-utils.ts"],"sourcesContent":["/**\n * Shared PGP utilities for platform adapters\n *\n * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.\n * All functions are pure utilities that can be safely shared across platforms.\n */\n\n/**\n * Standard OpenPGP configuration for consistent behavior across platforms\n * Uses enum values instead of importing openpgp to avoid loading issues\n */\nexport const STANDARD_PGP_CONFIG = {\n  preferredCompressionAlgorithm: 2, // zlib (openpgp.enums.compression.zlib)\n  preferredSymmetricAlgorithm: 7, // aes256 (openpgp.enums.symmetric.aes256)\n} as const;\n\n/**\n * Process PGP key generation options with sensible defaults\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Processed options with defaults applied\n */\nexport function processPGPKeyOptions(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  return {\n    name: options?.name ?? \"Vana User\",\n    email: options?.email ?? \"user@vana.org\",\n    passphrase: options?.passphrase,\n  };\n}\n\n/**\n * Get standard PGP key generation parameters\n * Combines default values with standard configuration\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Complete key generation parameters object\n */\nexport function getPGPKeyGenParams(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  const { name, email, passphrase } = processPGPKeyOptions(options);\n\n  return {\n    type: \"rsa\" as const,\n    rsaBits: 2048,\n    userIDs: [{ name, email }],\n    passphrase,\n    config: STANDARD_PGP_CONFIG,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWO,MAAM,sBAAsB;AAAA,EACjC,+BAA+B;AAAA;AAAA,EAC/B,6BAA6B;AAAA;AAC/B;AAWO,SAAS,qBAAqB,SAIlC;AACD,SAAO;AAAA,IACL,MAAM,SAAS,QAAQ;AAAA,IACvB,OAAO,SAAS,SAAS;AAAA,IACzB,YAAY,SAAS;AAAA,EACvB;AACF;AAYO,SAAS,mBAAmB,SAIhC;AACD,QAAM,EAAE,MAAM,OAAO,WAAW,IAAI,qBAAqB,OAAO;AAEhE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;AAAA,IACzB;AAAA,IACA,QAAQ;AAAA,EACV;AACF;","names":[]}

package/dist/platform/shared/pgp-utils.d.ts

@@ -8,7 +8,7 @@
  * Standard OpenPGP configuration for consistent behavior across platforms
  * Uses enum values instead of importing openpgp to avoid loading issues
  */
-declare const STANDARD_PGP_CONFIG: {
+export declare const STANDARD_PGP_CONFIG: {
     readonly preferredCompressionAlgorithm: 2;
     readonly preferredSymmetricAlgorithm: 7;
 };
@@ -21,7 +21,7 @@ declare const STANDARD_PGP_CONFIG: {
  * @param options.passphrase - Optional passphrase to protect the private key
  * @returns Processed options with defaults applied
  */
-declare function processPGPKeyOptions(options?: {
+export declare function processPGPKeyOptions(options?: {
     name?: string;
     email?: string;
     passphrase?: string;
@@ -40,7 +40,7 @@ declare function processPGPKeyOptions(options?: {
  * @param options.passphrase - Optional passphrase to protect the private key
  * @returns Complete key generation parameters object
  */
-declare function getPGPKeyGenParams(options?: {
+export declare function getPGPKeyGenParams(options?: {
     name?: string;
     email?: string;
     passphrase?: string;
@@ -57,5 +57,3 @@ declare function getPGPKeyGenParams(options?: {
         readonly preferredSymmetricAlgorithm: 7;
     };
 };
-
-export { STANDARD_PGP_CONFIG, getPGPKeyGenParams, processPGPKeyOptions };

package/dist/platform/shared/pgp-utils.js

@@ -6,8 +6,8 @@ const STANDARD_PGP_CONFIG = {
 };
 function processPGPKeyOptions(options) {
   return {
-    name: options?.name || "Vana User",
-    email: options?.email || "user@vana.org",
+    name: options?.name ?? "Vana User",
+    email: options?.email ?? "user@vana.org",
     passphrase: options?.passphrase
   };
 }

package/dist/platform/shared/pgp-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/platform/shared/pgp-utils.ts"],"sourcesContent":["/**\n * Shared PGP utilities for platform adapters\n *\n * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.\n * All functions are pure utilities that can be safely shared across platforms.\n */\n\n/**\n * Standard OpenPGP configuration for consistent behavior across platforms\n * Uses enum values instead of importing openpgp to avoid loading issues\n */\nexport const STANDARD_PGP_CONFIG = {\n  preferredCompressionAlgorithm: 2, // zlib (openpgp.enums.compression.zlib)\n  preferredSymmetricAlgorithm: 7, // aes256 (openpgp.enums.symmetric.aes256)\n} as const;\n\n/**\n * Process PGP key generation options with sensible defaults\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Processed options with defaults applied\n */\nexport function processPGPKeyOptions(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  return {\n    name: options?.name || \"Vana User\",\n    email: options?.email || \"user@vana.org\",\n    passphrase: options?.passphrase,\n  };\n}\n\n/**\n * Get standard PGP key generation parameters\n * Combines default values with standard configuration\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Complete key generation parameters object\n */\nexport function getPGPKeyGenParams(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  const { name, email, passphrase } = processPGPKeyOptions(options);\n\n  return {\n    type: \"rsa\" as const,\n    rsaBits: 2048,\n    userIDs: [{ name, email }],\n    passphrase,\n    config: STANDARD_PGP_CONFIG,\n  };\n}\n"],"mappings":"AAWO,MAAM,sBAAsB;AAAA,EACjC,+BAA+B;AAAA;AAAA,EAC/B,6BAA6B;AAAA;AAC/B;AAWO,SAAS,qBAAqB,SAIlC;AACD,SAAO;AAAA,IACL,MAAM,SAAS,QAAQ;AAAA,IACvB,OAAO,SAAS,SAAS;AAAA,IACzB,YAAY,SAAS;AAAA,EACvB;AACF;AAYO,SAAS,mBAAmB,SAIhC;AACD,QAAM,EAAE,MAAM,OAAO,WAAW,IAAI,qBAAqB,OAAO;AAEhE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;AAAA,IACzB;AAAA,IACA,QAAQ;AAAA,EACV;AACF;","names":[]}
+{"version":3,"sources":["../../../src/platform/shared/pgp-utils.ts"],"sourcesContent":["/**\n * Shared PGP utilities for platform adapters\n *\n * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.\n * All functions are pure utilities that can be safely shared across platforms.\n */\n\n/**\n * Standard OpenPGP configuration for consistent behavior across platforms\n * Uses enum values instead of importing openpgp to avoid loading issues\n */\nexport const STANDARD_PGP_CONFIG = {\n  preferredCompressionAlgorithm: 2, // zlib (openpgp.enums.compression.zlib)\n  preferredSymmetricAlgorithm: 7, // aes256 (openpgp.enums.symmetric.aes256)\n} as const;\n\n/**\n * Process PGP key generation options with sensible defaults\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Processed options with defaults applied\n */\nexport function processPGPKeyOptions(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  return {\n    name: options?.name ?? \"Vana User\",\n    email: options?.email ?? \"user@vana.org\",\n    passphrase: options?.passphrase,\n  };\n}\n\n/**\n * Get standard PGP key generation parameters\n * Combines default values with standard configuration\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Complete key generation parameters object\n */\nexport function getPGPKeyGenParams(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  const { name, email, passphrase } = processPGPKeyOptions(options);\n\n  return {\n    type: \"rsa\" as const,\n    rsaBits: 2048,\n    userIDs: [{ name, email }],\n    passphrase,\n    config: STANDARD_PGP_CONFIG,\n  };\n}\n"],"mappings":"AAWO,MAAM,sBAAsB;AAAA,EACjC,+BAA+B;AAAA;AAAA,EAC/B,6BAA6B;AAAA;AAC/B;AAWO,SAAS,qBAAqB,SAIlC;AACD,SAAO;AAAA,IACL,MAAM,SAAS,QAAQ;AAAA,IACvB,OAAO,SAAS,SAAS;AAAA,IACzB,YAAY,SAAS;AAAA,EACvB;AACF;AAYO,SAAS,mBAAmB,SAIhC;AACD,QAAM,EAAE,MAAM,OAAO,WAAW,IAAI,qBAAqB,OAAO;AAEhE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;AAAA,IACzB;AAAA,IACA,QAAQ;AAAA,EACV;AACF;","names":[]}

package/dist/platform/shared/stream-utils.d.ts

@@ -11,6 +11,4 @@
  * @param stream The ReadableStream to convert
  * @returns Promise resolving to Uint8Array containing all stream data
  */
-declare function streamToUint8Array(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
-
-export { streamToUint8Array };
+export declare function streamToUint8Array(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;

package/dist/platform/utils.d.ts

@@ -1,25 +1,23 @@
-import { PlatformType, VanaPlatformAdapter } from './interface.js';
-
 /**
  * Platform detection and adapter utilities
  *
  * This module provides utilities for detecting the current runtime environment
  * and creating appropriate platform adapters automatically.
  */
-
+import type { VanaPlatformAdapter, PlatformType } from "./interface";
 /**
  * Detects the current runtime environment
  *
  * @returns The detected platform type
  */
-declare function detectPlatform(): PlatformType;
+export declare function detectPlatform(): PlatformType;
 /**
  * Creates the appropriate platform adapter based on the current environment
  *
  * @returns A platform adapter instance for the current environment
  * @throws {Error} If platform adapters cannot be imported or created
  */
-declare function createPlatformAdapter(): Promise<VanaPlatformAdapter>;
+export declare function createPlatformAdapter(): Promise<VanaPlatformAdapter>;
 /**
  * Creates a platform adapter for a specific platform type
  *
@@ -27,20 +25,20 @@ declare function createPlatformAdapter(): Promise<VanaPlatformAdapter>;
  * @returns A platform adapter instance for the specified platform
  * @throws {Error} If platform adapters cannot be imported or created
  */
-declare function createPlatformAdapterFor(platformType: PlatformType): Promise<VanaPlatformAdapter>;
+export declare function createPlatformAdapterFor(platformType: PlatformType): Promise<VanaPlatformAdapter>;
 /**
  * Checks if the current environment supports the given platform adapter
  *
  * @param platformType - The platform type to check
  * @returns True if the platform is supported, false otherwise
  */
-declare function isPlatformSupported(platformType: PlatformType): boolean;
+export declare function isPlatformSupported(platformType: PlatformType): boolean;
 /**
  * Gets platform-specific capabilities
  *
  * @returns Object describing available platform capabilities
  */
-declare function getPlatformCapabilities(): {
+export declare function getPlatformCapabilities(): {
     platform: PlatformType;
     crypto: {
         webCrypto: false | SubtleCrypto;
@@ -49,5 +47,3 @@ declare function getPlatformCapabilities(): {
     fetch: boolean;
     streams: boolean;
 };
-
-export { createPlatformAdapter, createPlatformAdapterFor, detectPlatform, getPlatformCapabilities, isPlatformSupported };

package/dist/platform/utils.test.d.ts

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

package/dist/platform.browser.d.ts

@@ -1,4 +1,9 @@
-export { BrowserPlatformAdapter } from './platform/browser.js';
-export { VanaPlatformAdapter } from './platform/interface.js';
-export { createBrowserPlatformAdapter, createPlatformAdapterSafe } from './platform/browser-only.js';
-export { detectPlatform, getPlatformCapabilities, isPlatformSupported } from './platform/utils.js';
+/**
+ * Browser-specific platform adapters entry point
+ *
+ * This module provides browser-safe platform utilities without Node.js dependencies.
+ */
+export { BrowserPlatformAdapter } from "./platform/browser";
+export type { VanaPlatformAdapter } from "./platform/interface";
+export { createBrowserPlatformAdapter, createPlatformAdapterSafe, } from "./platform/browser-only";
+export { detectPlatform, isPlatformSupported, getPlatformCapabilities, } from "./platform/utils";

package/dist/platform.d.ts

@@ -1,5 +1,11 @@
-export { BrowserPlatformAdapter } from './platform/browser.js';
-export { NodePlatformAdapter } from './platform/node.js';
-export { VanaPlatformAdapter } from './platform/interface.js';
-export { createPlatformAdapter, createPlatformAdapterFor, detectPlatform, getPlatformCapabilities, isPlatformSupported } from './platform/utils.js';
-export { createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe } from './platform/browser-safe.js';
+/**
+ * Platform adapters entry point
+ *
+ * This module provides platform-specific utilities for different environments.
+ * Use this when you need platform detection or adapter creation.
+ */
+export { BrowserPlatformAdapter } from "./platform/browser";
+export { NodePlatformAdapter } from "./platform/node";
+export type { VanaPlatformAdapter } from "./platform/interface";
+export { detectPlatform, createPlatformAdapter, createPlatformAdapterFor, isPlatformSupported, getPlatformCapabilities, } from "./platform/utils";
+export { createNodePlatformAdapter, createBrowserPlatformAdapter, createPlatformAdapterSafe, } from "./platform/browser-safe";

package/dist/platform.node.d.ts

@@ -1,5 +1,10 @@
-export { BrowserPlatformAdapter } from './platform/browser.js';
-export { NodePlatformAdapter } from './platform/node.js';
-export { VanaPlatformAdapter } from './platform/interface.js';
-export { createPlatformAdapter, createPlatformAdapterFor, detectPlatform, getPlatformCapabilities, isPlatformSupported } from './platform/utils.js';
-export { createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe } from './platform/browser-safe.js';
+/**
+ * Node.js-specific platform adapters entry point
+ *
+ * This module provides full platform utilities including Node.js support.
+ */
+export { BrowserPlatformAdapter } from "./platform/browser";
+export { NodePlatformAdapter } from "./platform/node";
+export type { VanaPlatformAdapter } from "./platform/interface";
+export { detectPlatform, createPlatformAdapter, createPlatformAdapterFor, isPlatformSupported, getPlatformCapabilities, } from "./platform/utils";
+export { createNodePlatformAdapter, createBrowserPlatformAdapter, createPlatformAdapterSafe, } from "./platform/browser-safe";

package/dist/server/relayerHandler.cjs

@@ -0,0 +1,337 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 relayerHandler_exports = {};
+__export(relayerHandler_exports, {
+  handleRelayerOperation: () => handleRelayerOperation
+});
+module.exports = __toCommonJS(relayerHandler_exports);
+var import_uuid = require("uuid");
+var import_errors = require("../errors");
+var import_viem = require("viem");
+async function handleRelayerOperation(sdk, request, options) {
+  const store = sdk.operationStore;
+  if (store) {
+    if (request.type === "status_check") {
+      const state = await store.get(request.operationId);
+      if (!state) return { type: "error", error: "Operation not found" };
+      if (state.status === "confirmed")
+        return {
+          type: "confirmed",
+          hash: state.transactionHash,
+          receipt: state.finalReceipt
+        };
+      if (state.status === "failed")
+        return { type: "error", error: state.error ?? "Operation failed" };
+      if (state.status === "pending") {
+        try {
+          const publicClient = sdk.publicClient;
+          if (publicClient) {
+            let receipt;
+            try {
+              receipt = await publicClient.getTransactionReceipt({
+                hash: state.transactionHash
+              });
+            } catch (receiptError) {
+              if (receiptError?.name !== "TransactionReceiptNotFoundError") {
+                console.warn(
+                  `\u26A0\uFE0F [Relayer] Unexpected error checking receipt:`,
+                  receiptError?.message ?? receiptError
+                );
+              }
+              receipt = null;
+            }
+            if (receipt) {
+              const updatedState = {
+                ...state,
+                status: receipt.status === "success" ? "confirmed" : "failed",
+                finalReceipt: receipt,
+                ...receipt.status !== "success" && {
+                  error: "Transaction reverted on chain"
+                }
+              };
+              await store.set(request.operationId, updatedState);
+              if (receipt.status === "success") {
+                return {
+                  type: "confirmed",
+                  hash: state.transactionHash,
+                  receipt
+                };
+              } else {
+                return {
+                  type: "error",
+                  error: "Transaction reverted on chain"
+                };
+              }
+            }
+          } else {
+            console.warn(
+              "\u26A0\uFE0F [Relayer] No public client available for status checking"
+            );
+          }
+        } catch (error) {
+          console.error(
+            `\u274C [Relayer] Unexpected error in status check:`,
+            error
+          );
+        }
+      }
+      return { type: "pending", operationId: request.operationId };
+    }
+    const operationId = (0, import_uuid.v4)();
+    try {
+      const txResult = await routeAndExecuteRequest(sdk, request, options);
+      if ("hash" in txResult) {
+        await store.set(operationId, {
+          status: "pending",
+          transactionHash: txResult.hash,
+          originalRequest: request,
+          nonce: options?.nonce,
+          retryCount: 0,
+          lastAttemptedGas: {
+            maxFeePerGas: options?.maxFeePerGas?.toString(),
+            maxPriorityFeePerGas: options?.maxPriorityFeePerGas?.toString()
+          },
+          submittedAt: Date.now()
+        });
+        return { type: "pending", operationId };
+      } else {
+        return { type: "direct", result: txResult };
+      }
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error("Unknown error during operation submission");
+      return { type: "error", error: error.message };
+    }
+  } else {
+    if (request.type === "status_check") {
+      return {
+        type: "error",
+        error: "Stateless relayer does not support operation status checks."
+      };
+    }
+    try {
+      const txResult = await routeAndExecuteRequest(sdk, request, options);
+      if ("hash" in txResult) {
+        return { type: "submitted", hash: txResult.hash };
+      } else {
+        return { type: "direct", result: txResult };
+      }
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error("Unknown error during operation submission");
+      return { type: "error", error: error.message };
+    }
+  }
+}
+async function routeAndExecuteRequest(sdk, request, options) {
+  if (request.type === "signed") {
+    const { typedData, signature, expectedUserAddress } = request;
+    let recoveredAddress;
+    try {
+      recoveredAddress = await (0, import_viem.recoverTypedDataAddress)({
+        domain: {
+          ...typedData.domain,
+          chainId: typedData.domain.chainId ? BigInt(typedData.domain.chainId) : void 0
+        },
+        types: typedData.types,
+        primaryType: typedData.primaryType,
+        message: typedData.message,
+        signature
+      });
+    } catch (error) {
+      throw new import_errors.SignatureError(
+        `Signature verification failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    if (expectedUserAddress) {
+      const normalizedExpected = (0, import_viem.getAddress)(expectedUserAddress);
+      const normalizedSigner = (0, import_viem.getAddress)(recoveredAddress);
+      if (normalizedSigner !== normalizedExpected) {
+        throw new import_errors.SignatureError(
+          `Security verification failed: Recovered signer address (${normalizedSigner}) does not match expected user address (${normalizedExpected})`
+        );
+      }
+    }
+    return await routeSignedOperation(sdk, typedData, signature, options);
+  } else if (request.type === "direct") {
+    return await handleDirectOperation(sdk, request, options);
+  }
+  throw new Error("Invalid request type for execution");
+}
+async function routeSignedOperation(sdk, typedData, signature, options) {
+  const validPrimaryTypes = [
+    "Permission",
+    "RevokePermission",
+    "TrustServer",
+    "AddServer",
+    "UntrustServer",
+    "ServerFilesAndPermission"
+  ];
+  if (!validPrimaryTypes.includes(typedData.primaryType)) {
+    throw new Error(
+      `Unsupported operation type: ${typedData.primaryType}. Supported types: ${validPrimaryTypes.join(", ")}`
+    );
+  }
+  const primaryType = typedData.primaryType;
+  switch (primaryType) {
+    case "Permission":
+      return sdk.permissions.submitSignedGrant(
+        {
+          ...typedData,
+          primaryType: "Permission"
+        },
+        signature,
+        options
+      );
+    case "RevokePermission":
+      return sdk.permissions.submitSignedRevoke(
+        {
+          ...typedData,
+          primaryType: "RevokePermission"
+        },
+        signature,
+        options
+      );
+    case "TrustServer":
+      return sdk.permissions.submitSignedTrustServer(
+        {
+          ...typedData,
+          primaryType: "TrustServer"
+        },
+        signature,
+        options
+      );
+    case "AddServer":
+      return sdk.permissions.submitSignedAddAndTrustServer(
+        {
+          ...typedData,
+          primaryType: "AddServer"
+        },
+        signature,
+        options
+      );
+    case "UntrustServer":
+      return sdk.permissions.submitSignedUntrustServer(
+        {
+          ...typedData,
+          primaryType: "UntrustServer"
+        },
+        signature,
+        options
+      );
+    case "ServerFilesAndPermission":
+      return sdk.permissions.submitSignedAddServerFilesAndPermissions(
+        {
+          ...typedData,
+          primaryType: "ServerFilesAndPermission"
+        },
+        signature,
+        options
+      );
+    // TODO: RegisterGrantee with signature is not supported until
+    // DataPortabilityGrantees contract adds registerGranteeWithSignature function
+    // case "RegisterGrantee":
+    //   return sdk.permissions.submitSignedRegisterGrantee(...);
+    default:
+      throw new Error(
+        `Unsupported operation type: ${typedData.primaryType}. Supported types: Permission, RevokePermission, TrustServer, AddServer, UntrustServer, ServerFilesAndPermission`
+      );
+  }
+}
+async function handleDirectOperation(sdk, request, options) {
+  switch (request.operation) {
+    case "submitFileAddition": {
+      const { url, userAddress } = request.params;
+      const result = await sdk.data.addFileWithPermissions(
+        url,
+        userAddress,
+        [],
+        // No permissions
+        options
+      );
+      return result;
+    }
+    case "submitFileAdditionWithPermissions": {
+      const { url, userAddress, permissions } = request.params;
+      const result = await sdk.data.addFileWithPermissions(
+        url,
+        userAddress,
+        permissions,
+        options
+      );
+      return result;
+    }
+    case "submitFileAdditionComplete": {
+      const { url, userAddress, permissions, schemaId, ownerAddress } = request.params;
+      const txResult = await sdk.data.addFileWithEncryptedPermissionsAndSchema(
+        url,
+        ownerAddress ?? userAddress,
+        permissions,
+        // Already in correct format with encrypted 'key' field
+        schemaId,
+        options
+      );
+      const eventResult = await sdk.waitForTransactionEvents(txResult);
+      const fileAddedEvent = eventResult.expectedEvents?.FileAdded;
+      if (!fileAddedEvent || !fileAddedEvent.fileId) {
+        console.error("Event result:", eventResult);
+        throw new Error("FileAdded event not found in transaction");
+      }
+      const fileId = Number(fileAddedEvent.fileId);
+      return {
+        fileId,
+        transactionHash: txResult.hash
+      };
+    }
+    case "storeGrantFile": {
+      const grantFile = request.params;
+      const dataController = sdk.data;
+      const context = dataController.context;
+      if (!context?.storageManager) {
+        throw new Error(
+          "Storage configuration is required for storing grant files"
+        );
+      }
+      const blob = new Blob([JSON.stringify(grantFile)], {
+        type: "application/json"
+      });
+      const uploadResult = await context.storageManager.upload(
+        blob,
+        `grant-${Date.now()}.json`
+      );
+      return { url: uploadResult.url };
+    }
+    case "submitRegisterGrantee": {
+      const { owner, granteeAddress, publicKey } = request.params;
+      const result = await sdk.permissions.submitRegisterGrantee({
+        owner,
+        granteeAddress,
+        publicKey
+      });
+      return result;
+    }
+    default: {
+      const exhaustiveCheck = request;
+      return exhaustiveCheck;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleRelayerOperation
+});
+//# sourceMappingURL=relayerHandler.cjs.map