@opendatalabs/vana-sdk 0.1.0-alpha.d44f792 → 0.1.0-alpha.d596df3

package/dist/types/index.js

@@ -0,0 +1,42 @@
+import {
+  isWalletConfig,
+  isChainConfig,
+  isReadOnlyConfig,
+  isAddressOnlyConfig,
+  hasStorageConfig
+} from "./config";
+import { isVanaChainId, isVanaChain } from "./chains";
+import { StorageError } from "./storage";
+import {
+  SchemaValidationError,
+  SchemaValidator,
+  validateDataSchemaAgainstMetaSchema,
+  validateDataAgainstSchema,
+  fetchAndValidateSchema
+} from "../utils/schemaValidation";
+import {
+  isReplicateAPIResponse,
+  isAPIResponse,
+  safeParseJSON,
+  parseReplicateOutput
+} from "./external-apis";
+export {
+  SchemaValidationError,
+  SchemaValidator,
+  StorageError,
+  fetchAndValidateSchema,
+  hasStorageConfig,
+  isAPIResponse,
+  isAddressOnlyConfig,
+  isChainConfig,
+  isReadOnlyConfig,
+  isReplicateAPIResponse,
+  isVanaChain,
+  isVanaChainId,
+  isWalletConfig,
+  parseReplicateOutput,
+  safeParseJSON,
+  validateDataAgainstSchema,
+  validateDataSchemaAgainstMetaSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/index.ts"],"sourcesContent":["/**\n * Centralized type exports for the Vana SDK.\n *\n * @remarks\n * This module re-exports all public types from their respective modules,\n * providing a single import point for SDK consumers. Types are organized\n * by category for easy discovery and usage.\n *\n * **Import Strategy:**\n * - Import types from this module for application code\n * - Import from specific modules only for advanced use cases\n * - Avoid importing from internal paths\n *\n * @example\n * ```typescript\n * // Recommended: Import from types module\n * import type { VanaConfig, UserFile, GrantPermissionParams } from '@opendatalabs/vana-sdk';\n *\n * // Alternative: Import from specific category\n * import type { StorageProvider } from '@opendatalabs/vana-sdk';\n * ```\n *\n * @category Types\n * @module types\n */\n\n// Configuration types\nexport type {\n  BaseConfig,\n  BaseConfigWithStorage,\n  WalletConfig,\n  WalletConfigWithStorage,\n  ChainConfig,\n  ChainConfigWithStorage,\n  VanaConfig,\n  VanaConfigWithStorage,\n  VanaConfigWithWallet,\n  VanaConfigReadOnly,\n  VanaConfigAddressOnly,\n  VanaConfigWithWalletWithStorage,\n  VanaConfigReadOnlyWithStorage,\n  VanaConfigAddressOnlyWithStorage,\n  RuntimeConfig,\n  StorageConfig,\n  ConfigValidationOptions,\n  ConfigValidationResult,\n  DownloadRelayerCallbacks,\n  StorageRequiredMarker,\n  RelayerRequiredMarker,\n} from \"./config\";\n\nexport {\n  isWalletConfig,\n  isChainConfig,\n  isReadOnlyConfig,\n  isAddressOnlyConfig,\n  hasStorageConfig,\n} from \"./config\";\n\n// Chain types\nexport type { VanaChainId, VanaChain } from \"./chains\";\n\nexport { isVanaChainId, isVanaChain } from \"./chains\";\n\n// Contract types\nexport type {\n  VanaContractName,\n  ContractInfo,\n  ContractDeployment,\n  VanaContractInstance,\n  ContractAddresses,\n  ContractMethodParams,\n  ContractMethodReturnType,\n} from \"./contracts\";\n\n// Note: VanaContract and ContractAbis are exported directly from src/index.ts\n// to avoid circular dependencies. Do not re-export them here.\n\n// Storage types\nexport type {\n  StorageProvider,\n  StorageUploadResult,\n  StorageFile,\n  StorageListOptions,\n  StorageProviderConfig,\n} from \"./storage\";\n\nexport { StorageError } from \"./storage\";\n\n// Data types\nexport type {\n  UserFile,\n  FileMetadata,\n  UploadParams,\n  FilePermissionParams,\n  LegacyPermissionParams,\n  EncryptedUploadParams,\n  UnencryptedUploadParams,\n  UploadResult,\n  UploadFileParams,\n  UploadFileResult,\n  UploadEncryptedFileResult,\n  EncryptionInfo,\n  GetUserFilesParams,\n  GetFileParams,\n  EncryptFileOptions,\n  EncryptFileResult,\n  DecryptFileOptions,\n  UploadFileWithPermissionsParams,\n  AddFilePermissionParams,\n  DecryptFileWithPermissionOptions,\n  DownloadFileParams,\n  DownloadFileResult,\n  DeleteFileParams,\n  DeleteFileResult,\n  FileAccessPermissions,\n  FileSharingConfig,\n  BatchUploadParams,\n  BatchUploadResult,\n  SchemaMetadata,\n  CompleteSchema,\n  Schema,\n  Refiner,\n  AddSchemaParams,\n  AddSchemaResult,\n  AddRefinerParams,\n  AddRefinerResult,\n  UpdateSchemaIdParams,\n  UpdateSchemaIdResult,\n  TrustedServer,\n  GetUserTrustedServersParams,\n} from \"./data\";\n\n// Schema types\nexport type {\n  CreateSchemaParams,\n  CreateSchemaResult,\n} from \"../controllers/schemas\";\n\n// Schema validation types\nexport type { DataSchema } from \"../utils/schemaValidation\";\nexport {\n  SchemaValidationError,\n  SchemaValidator,\n  validateDataSchemaAgainstMetaSchema,\n  validateDataAgainstSchema,\n  fetchAndValidateSchema,\n} from \"../utils/schemaValidation\";\n\n// Permission types\nexport type {\n  OnChainPermissionGrant,\n  GetUserPermissionsOptions,\n  GrantPermissionParams,\n  RevokePermissionParams,\n  CheckPermissionParams,\n  PermissionCheckResult,\n  PermissionGrantDomain,\n  PermissionGrantMessage,\n  PermissionInputMessage,\n  SimplifiedPermissionMessage,\n  GrantFile,\n  PermissionGrantTypedData,\n  RevokePermissionTypedData,\n  GenericTypedData,\n  TypedDataPrimaryType,\n  SpecificTypedData,\n  PermissionOperation,\n  PermissionStatus,\n  QueryPermissionsParams,\n  PermissionQueryResult,\n  PermissionAnalytics,\n  PermissionEvent,\n  GrantedPermission,\n  Server,\n  AddAndTrustServerParams,\n  TrustServerParams,\n  UntrustServerParams,\n  AddAndTrustServerInput,\n  TrustServerInput,\n  UntrustServerInput,\n  AddAndTrustServerTypedData,\n  TrustServerTypedData,\n  UntrustServerTypedData,\n  PermissionInfo,\n  RevokePermissionInput,\n  TrustedServerInfo,\n  PaginatedTrustedServers,\n  TrustedServerQueryOptions,\n  BatchServerInfoResult,\n  ServerTrustStatus,\n  ServerInfo,\n  Grantee,\n  GranteeInfo,\n  RegisterGranteeParams,\n  RegisterGranteeInput,\n  RegisterGranteeTypedData,\n  GranteeQueryOptions,\n  PaginatedGrantees,\n  ServerFilesAndPermissionParams,\n  ServerFilesAndPermissionTypedData,\n  Permission,\n} from \"./permissions\";\n\n// Personal server types\nexport type {\n  PostRequestParams,\n  CreateOperationParams,\n  InitPersonalServerParams,\n  PersonalServerIdentity,\n} from \"./personal\";\n\n// Server API types (auto-generated via fetch-server-types.ts)\nexport type * from \"../generated/server/server-exports\";\n\n// External API types\nexport type {\n  ReplicateAPIResponse,\n  ReplicateStatus,\n  PinataUploadResponse,\n  PinataPin,\n  PinataListResponse,\n  APIResponse,\n} from \"./external-apis\";\n\nexport {\n  isReplicateAPIResponse,\n  isAPIResponse,\n  safeParseJSON,\n  parseReplicateOutput,\n} from \"./external-apis\";\n\n// Relayer types\nexport type {\n  RelayerStorageResponse,\n  RelayerTransactionResponse,\n  RelayerStoreParams,\n  RelayerSubmitParams,\n  RelayerStatus,\n  RelayerConfig,\n  UnifiedRelayerRequest,\n  UnifiedRelayerResponse,\n  SignedRelayerRequest,\n  DirectRelayerRequest,\n  RelayerRequestOptions,\n  RelayerErrorResponse,\n  RelayerQueueInfo,\n  RelayerTransactionStatus,\n  RelayerMetrics,\n  RelayerWebhookConfig,\n  RelayerWebhookPayload,\n} from \"./relayer\";\n\n// Utility types\nexport type {\n  PartialExcept,\n  RequiredExcept,\n  Awaited,\n  MaybePromise,\n  MaybeArray,\n  PaginationParams,\n  PaginationResult,\n  BlockRange,\n  ApiResponse,\n  CacheConfig,\n  ValidationResult,\n  StatusInfo,\n  RateLimitInfo,\n  UploadProgress,\n  NetworkInfo,\n  GasEstimate,\n  TimeRange,\n} from \"./utils\";\n\n// Operation types\nexport type {\n  TransactionOptions,\n  TransactionReceipt,\n  TransactionResult,\n} from \"./operations\";\n\n// Operation store types\nexport type {\n  IOperationStore,\n  StoredOperation,\n  IRelayerStateStore,\n  OperationState,\n} from \"./operationStore\";\n\n// Options types\nexport type {\n  ConsistencyOptions,\n  DataSource,\n  PaginationOptions,\n  ListOptions,\n  WriteOptions,\n  LegacyTransactionOptions,\n} from \"./options\";\n\n// Generic types for extensibility\nexport type {\n  GenericRequest,\n  GenericResponse,\n  AsyncResult,\n  ContractCall,\n  EventFilter,\n  EventLog,\n  ControllerContext,\n  Controller,\n  Cache,\n  RetryConfig,\n  RateLimiterConfig,\n  Middleware,\n  Plugin,\n  Factory,\n  Repository,\n  Validator,\n  Transformer,\n  Service,\n  Observer,\n  Observable,\n  StateMachine,\n  ConditionalOptional,\n  PromiseResult,\n  AllKeys,\n  DeepPartial,\n  DeepReadonly,\n  RequireKeys,\n  OptionalKeys,\n  NonNullable,\n  PickByType,\n  OmitByType,\n  Brand,\n  Nominal,\n} from \"./generics\";\n\n// Re-export viem types that are commonly used\nexport type {\n  Address,\n  Hash,\n  Abi,\n  Chain,\n  WalletClient,\n  PublicClient,\n  Account,\n  GetContractReturnType,\n} from \"viem\";\n"],"mappings":"AAmDA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP,SAAS,eAAe,mBAAmB;AAyB3C,SAAS,oBAAoB;AAsD7B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AA8EP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;","names":[]}

package/dist/types/operationStore.cjs

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

package/dist/types/operationStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/operationStore.ts"],"sourcesContent":["/**\n * Operation storage interfaces for queuing and managing asynchronous operations.\n *\n * @module\n */\n\nimport type { Hash, TransactionReceipt } from \"viem\";\nimport type { UnifiedRelayerRequest } from \"./relayer\";\n\n/**\n * The state of an asynchronous, relayed operation.\n *\n * @remarks\n * This is the data the application backend is responsible for persisting.\n * It serves as a complete recovery log for a given operation.\n *\n * @category Operations\n */\nexport interface OperationState {\n  status: \"pending\" | \"confirmed\" | \"failed\";\n  transactionHash: Hash;\n  originalRequest: UnifiedRelayerRequest;\n  nonce?: number;\n  retryCount: number;\n  lastAttemptedGas: { maxFeePerGas?: string; maxPriorityFeePerGas?: string };\n  submittedAt: number; // Unix timestamp (ms)\n  finalReceipt?: TransactionReceipt;\n  error?: string;\n}\n\n/**\n * Simple storage interface for operation state tracking.\n *\n * @remarks\n * This interface is used by the relayer handler to track operation state\n * in a stateful mode. Implementations can use any backend storage system.\n *\n * @category Operations\n */\nexport interface IRelayerStateStore {\n  /**\n   * Gets the state of an operation.\n   *\n   * @param operationId - The operation ID\n   * @returns The operation state or null if not found\n   */\n  get(operationId: string): Promise<OperationState | null>;\n\n  /**\n   * Sets the state of an operation.\n   *\n   * @param operationId - The operation ID\n   * @param state - The operation state to store\n   */\n  set(operationId: string, state: OperationState): Promise<void>;\n}\n\n/**\n * Represents a stored operation in the queue.\n */\nexport interface StoredOperation {\n  /** Unique identifier for the operation */\n  id: string;\n  /** Current status of the operation */\n  status: \"queued\" | \"processing\" | \"submitted\" | \"completed\" | \"failed\";\n  /** Serialized transaction or operation data */\n  data: string;\n  /** Number of retry attempts */\n  retryCount?: number;\n  /** Timestamp when the operation was created */\n  createdAt?: number;\n  /** Additional metadata */\n  metadata?: any;\n}\n\n/**\n * Interface for operation storage backends.\n *\n * @remarks\n * Implementations of this interface provide persistent storage for queued\n * operations in a distributed relayer system. This allows operations to\n * be processed asynchronously and recovered after failures.\n *\n * Common implementations include:\n * - PostgreSQL for production environments\n * - MongoDB for document-based storage\n * - DynamoDB for serverless deployments\n * - In-memory storage for testing\n *\n * @example\n * ```typescript\n * class PostgresOperationStore implements IOperationStore {\n *   async storeOperation(operation) {\n *     await this.db.query(\n *       'INSERT INTO operations (id, status, data) VALUES ($1, $2, $3)',\n *       [operation.id, 'queued', operation.data]\n *     );\n *   }\n *\n *   async getQueuedOperations(options) {\n *     const result = await this.db.query(\n *       'SELECT * FROM operations WHERE status = $1 LIMIT $2',\n *       ['queued', options.limit || 100]\n *     );\n *     return result.rows;\n *   }\n * }\n * ```\n *\n * @category Storage\n */\nexport interface IOperationStore {\n  /**\n   * Stores a new operation in the queue.\n   *\n   * @param operation - The operation to store\n   * @returns Promise that resolves when the operation is stored\n   */\n  storeOperation(operation: {\n    id: string;\n    data: any;\n    metadata?: any;\n  }): Promise<void>;\n\n  /**\n   * Retrieves queued operations for processing.\n   *\n   * @param options - Query options\n   * @returns Promise resolving to an array of queued operations\n   */\n  getQueuedOperations(options?: { limit?: number }): Promise<StoredOperation[]>;\n\n  /**\n   * Updates the status of an operation.\n   *\n   * @param operationId - The ID of the operation to update\n   * @param status - The new status\n   * @param metadata - Optional metadata to store with the update\n   * @returns Promise that resolves when the status is updated\n   */\n  updateStatus(\n    operationId: string,\n    status: string,\n    metadata?: any,\n  ): Promise<void>;\n\n  /**\n   * Gets operations currently being processed.\n   *\n   * @param options - Query options\n   * @returns Promise resolving to an array of processing operations\n   */\n  getProcessingOperations?(options?: {\n    limit?: number;\n  }): Promise<StoredOperation[]>;\n\n  /**\n   * Gets failed operations.\n   *\n   * @param options - Query options\n   * @returns Promise resolving to an array of failed operations\n   */\n  getFailedOperations?(options?: {\n    limit?: number;\n  }): Promise<StoredOperation[]>;\n\n  /**\n   * Gets the status of a specific operation.\n   *\n   * @param operationId - The ID of the operation to check\n   * @returns Promise resolving to the operation or null if not found\n   */\n  getOperation?(operationId: string): Promise<StoredOperation | null>;\n\n  /**\n   * Deletes an operation from storage.\n   *\n   * @param operationId - The ID of the operation to delete\n   * @returns Promise that resolves when the operation is deleted\n   */\n  deleteOperation?(operationId: string): Promise<void>;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/types/operationStore.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Operation storage interfaces for queuing and managing asynchronous operations.
+ *
+ * @module
+ */
+import type { Hash, TransactionReceipt } from "viem";
+import type { UnifiedRelayerRequest } from "./relayer";
+/**
+ * The state of an asynchronous, relayed operation.
+ *
+ * @remarks
+ * This is the data the application backend is responsible for persisting.
+ * It serves as a complete recovery log for a given operation.
+ *
+ * @category Operations
+ */
+export interface OperationState {
+    status: "pending" | "confirmed" | "failed";
+    transactionHash: Hash;
+    originalRequest: UnifiedRelayerRequest;
+    nonce?: number;
+    retryCount: number;
+    lastAttemptedGas: {
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+    };
+    submittedAt: number;
+    finalReceipt?: TransactionReceipt;
+    error?: string;
+}
+/**
+ * Simple storage interface for operation state tracking.
+ *
+ * @remarks
+ * This interface is used by the relayer handler to track operation state
+ * in a stateful mode. Implementations can use any backend storage system.
+ *
+ * @category Operations
+ */
+export interface IRelayerStateStore {
+    /**
+     * Gets the state of an operation.
+     *
+     * @param operationId - The operation ID
+     * @returns The operation state or null if not found
+     */
+    get(operationId: string): Promise<OperationState | null>;
+    /**
+     * Sets the state of an operation.
+     *
+     * @param operationId - The operation ID
+     * @param state - The operation state to store
+     */
+    set(operationId: string, state: OperationState): Promise<void>;
+}
+/**
+ * Represents a stored operation in the queue.
+ */
+export interface StoredOperation {
+    /** Unique identifier for the operation */
+    id: string;
+    /** Current status of the operation */
+    status: "queued" | "processing" | "submitted" | "completed" | "failed";
+    /** Serialized transaction or operation data */
+    data: string;
+    /** Number of retry attempts */
+    retryCount?: number;
+    /** Timestamp when the operation was created */
+    createdAt?: number;
+    /** Additional metadata */
+    metadata?: any;
+}
+/**
+ * Interface for operation storage backends.
+ *
+ * @remarks
+ * Implementations of this interface provide persistent storage for queued
+ * operations in a distributed relayer system. This allows operations to
+ * be processed asynchronously and recovered after failures.
+ *
+ * Common implementations include:
+ * - PostgreSQL for production environments
+ * - MongoDB for document-based storage
+ * - DynamoDB for serverless deployments
+ * - In-memory storage for testing
+ *
+ * @example
+ * ```typescript
+ * class PostgresOperationStore implements IOperationStore {
+ *   async storeOperation(operation) {
+ *     await this.db.query(
+ *       'INSERT INTO operations (id, status, data) VALUES ($1, $2, $3)',
+ *       [operation.id, 'queued', operation.data]
+ *     );
+ *   }
+ *
+ *   async getQueuedOperations(options) {
+ *     const result = await this.db.query(
+ *       'SELECT * FROM operations WHERE status = $1 LIMIT $2',
+ *       ['queued', options.limit || 100]
+ *     );
+ *     return result.rows;
+ *   }
+ * }
+ * ```
+ *
+ * @category Storage
+ */
+export interface IOperationStore {
+    /**
+     * Stores a new operation in the queue.
+     *
+     * @param operation - The operation to store
+     * @returns Promise that resolves when the operation is stored
+     */
+    storeOperation(operation: {
+        id: string;
+        data: any;
+        metadata?: any;
+    }): Promise<void>;
+    /**
+     * Retrieves queued operations for processing.
+     *
+     * @param options - Query options
+     * @returns Promise resolving to an array of queued operations
+     */
+    getQueuedOperations(options?: {
+        limit?: number;
+    }): Promise<StoredOperation[]>;
+    /**
+     * Updates the status of an operation.
+     *
+     * @param operationId - The ID of the operation to update
+     * @param status - The new status
+     * @param metadata - Optional metadata to store with the update
+     * @returns Promise that resolves when the status is updated
+     */
+    updateStatus(operationId: string, status: string, metadata?: any): Promise<void>;
+    /**
+     * Gets operations currently being processed.
+     *
+     * @param options - Query options
+     * @returns Promise resolving to an array of processing operations
+     */
+    getProcessingOperations?(options?: {
+        limit?: number;
+    }): Promise<StoredOperation[]>;
+    /**
+     * Gets failed operations.
+     *
+     * @param options - Query options
+     * @returns Promise resolving to an array of failed operations
+     */
+    getFailedOperations?(options?: {
+        limit?: number;
+    }): Promise<StoredOperation[]>;
+    /**
+     * Gets the status of a specific operation.
+     *
+     * @param operationId - The ID of the operation to check
+     * @returns Promise resolving to the operation or null if not found
+     */
+    getOperation?(operationId: string): Promise<StoredOperation | null>;
+    /**
+     * Deletes an operation from storage.
+     *
+     * @param operationId - The ID of the operation to delete
+     * @returns Promise that resolves when the operation is deleted
+     */
+    deleteOperation?(operationId: string): Promise<void>;
+}

package/dist/types/operationStore.js

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

package/dist/types/operationStore.js.map

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

package/dist/types/operations.cjs

@@ -0,0 +1,65 @@
+"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 operations_exports = {};
+__export(operations_exports, {
+  getOperationId: () => getOperationId,
+  getTransactionHash: () => getTransactionHash,
+  isOperation: () => isOperation,
+  isTransactionResult: () => isTransactionResult,
+  toOperation: () => toOperation
+});
+module.exports = __toCommonJS(operations_exports);
+function isOperation(obj) {
+  return typeof obj === "object" && obj !== null && "id" in obj && "status" in obj && typeof obj.id === "string" && typeof obj.status === "string";
+}
+function isTransactionResult(obj) {
+  if (typeof obj !== "object" || obj === null || !("hash" in obj)) {
+    return false;
+  }
+  const { hash } = obj;
+  return typeof hash === "string" && hash.startsWith("0x");
+}
+function toOperation(response) {
+  return {
+    id: response.id,
+    status: response.status,
+    createdAt: Date.now(),
+    // Server doesn't provide this, so we use current time
+    result: response.status === "succeeded" ? response.result : void 0,
+    error: response.status === "failed" ? response.result ?? void 0 : void 0
+  };
+}
+function getOperationId(opOrId) {
+  return typeof opOrId === "string" ? opOrId : opOrId.id;
+}
+function getTransactionHash(txOrHash) {
+  if (typeof txOrHash === "string") {
+    return txOrHash;
+  }
+  return txOrHash.hash;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getOperationId,
+  getTransactionHash,
+  isOperation,
+  isTransactionResult,
+  toOperation
+});
+//# sourceMappingURL=operations.cjs.map

package/dist/types/operations.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/operations.ts"],"sourcesContent":["import type { Hash, TransactionReceipt as ViemReceipt, Address } from \"viem\";\nimport type { GetOperationResponse } from \"../generated/server/server-exports\";\nimport type { Contract, Fn } from \"../generated/event-types\";\n\n// Re-export TransactionOptions from the new options module\nexport type { TransactionOptions } from \"./options\";\n\n/**\n * Represents a server-side operation status and result.\n *\n * @remarks\n * Operations track asynchronous server processes like data refinement or ML inference.\n * Poll operation status using `vana.server.waitForOperation()` until completion.\n * Fully serializable for API responses and cross-process communication.\n *\n * @category Operations\n * @see {@link https://docs.vana.org/docs/operations | Operations Guide}\n */\nexport interface Operation<T = unknown> {\n  /** Unique operation identifier */\n  id: string;\n  /** Current operation status */\n  status: \"starting\" | \"running\" | \"succeeded\" | \"failed\" | \"canceled\";\n  /** Unix timestamp when operation was created */\n  createdAt: number;\n  /** Unix timestamp when operation was last updated */\n  updatedAt?: number;\n  /** Operation result when status is 'succeeded' */\n  result?: T;\n  /** Error message when status is 'failed' */\n  error?: string;\n  /** Additional operation metadata */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Represents a submitted blockchain transaction as a self-describing POJO.\n *\n * @remarks\n * Transaction results MUST include contract and function for proper event parsing.\n * This strongly-typed design enables automatic event extraction without heuristics.\n * Use `vana.waitForTransactionEvents()` to retrieve typed events from the receipt.\n *\n * **Architecture:**\n * POJOs (Plain Old JavaScript Objects) ensure serialization safety and framework\n * independence. Contract and function fields enable deterministic event parsing.\n *\n * @category Operations\n * @example\n * ```typescript\n * const result: TransactionResult = {\n *   hash: '0x123...',\n *   from: '0x456...',\n *   contract: 'DataRegistry',\n *   fn: 'addFile',\n *   chainId: 14800\n * };\n *\n * // Wait for events\n * const events = await vana.waitForTransactionEvents(result);\n * ```\n */\nexport interface TransactionResult<\n  C extends Contract = Contract,\n  F extends Fn<C> = Fn<C>,\n> {\n  /** Transaction hash for tracking and confirmation */\n  hash: Hash;\n  /** Sender's wallet address */\n  from: Address;\n  /** Contract that was called (required for event parsing) */\n  contract: C;\n  /** Function that was called (required for event parsing) */\n  fn: F;\n  /** Network chain ID where transaction was submitted */\n  chainId?: number;\n  /** Transaction value in wei (for payable functions) */\n  value?: bigint;\n  /** Transaction sequence number for the sender */\n  nonce?: number;\n  /** Contract address (if different from standard deployment) */\n  to?: Address;\n}\n\n/**\n * Extends viem's TransactionReceipt with Vana-specific event data.\n *\n * @remarks\n * Includes parsed event data when available after transaction confirmation.\n * Use this for detailed transaction analysis and event processing.\n *\n * @category Operations\n */\nexport interface TransactionReceipt extends ViemReceipt {\n  /** Parsed event data if available */\n  events?: unknown;\n}\n\n/**\n * Configures polling behavior for asynchronous operations.\n *\n * @remarks\n * Controls how frequently and how long to poll for operation completion.\n * Lower intervals provide faster updates but increase server load.\n *\n * @category Operations\n */\nexport interface PollingOptions {\n  /** Polling interval in milliseconds (default: 500) */\n  pollingInterval?: number;\n  /** Maximum time to wait in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/**\n * Configures transaction confirmation waiting behavior.\n *\n * @remarks\n * Controls confirmation depth and timeout for transaction finality.\n * Higher confirmations provide more security against chain reorganizations.\n *\n * @category Operations\n */\nexport interface TransactionWaitOptions {\n  /** Number of confirmations to wait for (default: 1) */\n  confirmations?: number;\n  /** Polling interval in milliseconds (default: 1000) */\n  pollingInterval?: number;\n  /** Maximum time to wait in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/**\n * Validates whether an object conforms to the Operation interface.\n *\n * @remarks\n * Type guard for runtime validation of operation objects from external sources.\n * Use when deserializing operations from API responses or storage.\n *\n * @param obj - The object to validate as an Operation\n * @returns `true` if the object has required Operation properties, `false` otherwise\n *\n * @example\n * ```typescript\n * const response = await fetch('/api/operation/123');\n * const data = await response.json();\n *\n * if (isOperation(data)) {\n *   console.log(`Operation ${data.id}: ${data.status}`);\n * }\n * ```\n *\n * @category Operations\n */\nexport function isOperation(obj: unknown): obj is Operation {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"id\" in obj &&\n    \"status\" in obj &&\n    typeof (obj as Record<string, unknown>).id === \"string\" &&\n    typeof (obj as Record<string, unknown>).status === \"string\"\n  );\n}\n\n/**\n * Validates whether an object conforms to the TransactionResult interface.\n *\n * @remarks\n * Type guard for runtime validation of transaction results.\n * Checks for required hash field with proper `0x` prefix.\n *\n * @param obj - The object to validate as a TransactionResult\n * @returns `true` if the object has a valid transaction hash, `false` otherwise\n *\n * @example\n * ```typescript\n * if (isTransactionResult(result)) {\n *   await vana.waitForTransactionEvents(result);\n * }\n * ```\n *\n * @category Operations\n */\nexport function isTransactionResult(obj: unknown): obj is TransactionResult {\n  if (typeof obj !== \"object\" || obj === null || !(\"hash\" in obj)) {\n    return false;\n  }\n  const { hash } = obj as Record<string, unknown>;\n  return typeof hash === \"string\" && hash.startsWith(\"0x\");\n}\n\n/**\n * Converts a server response to an Operation POJO.\n *\n * @remarks\n * Normalizes server responses into consistent Operation format.\n * Separates success results from error messages based on status.\n *\n * @param response - The raw server response containing operation status data\n * @returns An Operation object with normalized fields for client consumption\n *\n * @example\n * ```typescript\n * const serverResponse = await api.getOperation('op-123');\n * const operation = toOperation<MLResult>(serverResponse);\n *\n * if (operation.status === 'succeeded') {\n *   console.log('Result:', operation.result);\n * }\n * ```\n *\n * @category Operations\n */\nexport function toOperation<T>(response: GetOperationResponse): Operation<T> {\n  return {\n    id: response.id,\n    status: response.status as Operation[\"status\"],\n    createdAt: Date.now(), // Server doesn't provide this, so we use current time\n    result:\n      response.status === \"succeeded\" ? (response.result as T) : undefined,\n    error:\n      response.status === \"failed\" ? (response.result ?? undefined) : undefined,\n  };\n}\n\n/**\n * Extracts the operation ID from flexible input types.\n *\n * @remarks\n * Utility for handling both Operation objects and raw ID strings.\n * Enables flexible API design accepting either format.\n *\n * @param opOrId - An Operation object containing an `id` field or a raw operation ID string\n * @returns The operation ID string for use in API calls\n *\n * @example\n * ```typescript\n * // Works with both formats\n * await vana.server.getOperation(operation); // Operation object\n * await vana.server.getOperation('op-123');  // ID string\n * ```\n *\n * @category Operations\n */\nexport function getOperationId(opOrId: Operation | string): string {\n  return typeof opOrId === \"string\" ? opOrId : opOrId.id;\n}\n\n/**\n * Extracts the transaction hash from flexible input types.\n *\n * @remarks\n * Utility for handling TransactionResult objects, hash objects, or raw hash strings.\n * Enables consistent hash extraction across different transaction representations.\n *\n * @param txOrHash - A TransactionResult object, any object with a `hash` field, or a raw hash string\n * @returns The transaction hash as a `0x`-prefixed string\n *\n * @example\n * ```typescript\n * // All these work\n * const hash1 = getTransactionHash(transactionResult);\n * const hash2 = getTransactionHash({ hash: '0x123...' });\n * const hash3 = getTransactionHash('0x123...');\n * ```\n *\n * @category Operations\n */\nexport function getTransactionHash(\n  txOrHash: TransactionResult | { hash: Hash } | Hash,\n): Hash {\n  if (typeof txOrHash === \"string\") {\n    return txOrHash;\n  }\n  return txOrHash.hash;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0JO,SAAS,YAAY,KAAgC;AAC1D,SACE,OAAO,QAAQ,YACf,QAAQ,QACR,QAAQ,OACR,YAAY,OACZ,OAAQ,IAAgC,OAAO,YAC/C,OAAQ,IAAgC,WAAW;AAEvD;AAqBO,SAAS,oBAAoB,KAAwC;AAC1E,MAAI,OAAO,QAAQ,YAAY,QAAQ,QAAQ,EAAE,UAAU,MAAM;AAC/D,WAAO;AAAA,EACT;AACA,QAAM,EAAE,KAAK,IAAI;AACjB,SAAO,OAAO,SAAS,YAAY,KAAK,WAAW,IAAI;AACzD;AAwBO,SAAS,YAAe,UAA8C;AAC3E,SAAO;AAAA,IACL,IAAI,SAAS;AAAA,IACb,QAAQ,SAAS;AAAA,IACjB,WAAW,KAAK,IAAI;AAAA;AAAA,IACpB,QACE,SAAS,WAAW,cAAe,SAAS,SAAe;AAAA,IAC7D,OACE,SAAS,WAAW,WAAY,SAAS,UAAU,SAAa;AAAA,EACpE;AACF;AAqBO,SAAS,eAAe,QAAoC;AACjE,SAAO,OAAO,WAAW,WAAW,SAAS,OAAO;AACtD;AAsBO,SAAS,mBACd,UACM;AACN,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,EACT;AACA,SAAO,SAAS;AAClB;","names":[]}

package/dist/types/operations.d.ts

@@ -0,0 +1,230 @@
+import type { Hash, TransactionReceipt as ViemReceipt, Address } from "viem";
+import type { GetOperationResponse } from "../generated/server/server-exports";
+import type { Contract, Fn } from "../generated/event-types";
+export type { TransactionOptions } from "./options";
+/**
+ * Represents a server-side operation status and result.
+ *
+ * @remarks
+ * Operations track asynchronous server processes like data refinement or ML inference.
+ * Poll operation status using `vana.server.waitForOperation()` until completion.
+ * Fully serializable for API responses and cross-process communication.
+ *
+ * @category Operations
+ * @see {@link https://docs.vana.org/docs/operations | Operations Guide}
+ */
+export interface Operation<T = unknown> {
+    /** Unique operation identifier */
+    id: string;
+    /** Current operation status */
+    status: "starting" | "running" | "succeeded" | "failed" | "canceled";
+    /** Unix timestamp when operation was created */
+    createdAt: number;
+    /** Unix timestamp when operation was last updated */
+    updatedAt?: number;
+    /** Operation result when status is 'succeeded' */
+    result?: T;
+    /** Error message when status is 'failed' */
+    error?: string;
+    /** Additional operation metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Represents a submitted blockchain transaction as a self-describing POJO.
+ *
+ * @remarks
+ * Transaction results MUST include contract and function for proper event parsing.
+ * This strongly-typed design enables automatic event extraction without heuristics.
+ * Use `vana.waitForTransactionEvents()` to retrieve typed events from the receipt.
+ *
+ * **Architecture:**
+ * POJOs (Plain Old JavaScript Objects) ensure serialization safety and framework
+ * independence. Contract and function fields enable deterministic event parsing.
+ *
+ * @category Operations
+ * @example
+ * ```typescript
+ * const result: TransactionResult = {
+ *   hash: '0x123...',
+ *   from: '0x456...',
+ *   contract: 'DataRegistry',
+ *   fn: 'addFile',
+ *   chainId: 14800
+ * };
+ *
+ * // Wait for events
+ * const events = await vana.waitForTransactionEvents(result);
+ * ```
+ */
+export interface TransactionResult<C extends Contract = Contract, F extends Fn<C> = Fn<C>> {
+    /** Transaction hash for tracking and confirmation */
+    hash: Hash;
+    /** Sender's wallet address */
+    from: Address;
+    /** Contract that was called (required for event parsing) */
+    contract: C;
+    /** Function that was called (required for event parsing) */
+    fn: F;
+    /** Network chain ID where transaction was submitted */
+    chainId?: number;
+    /** Transaction value in wei (for payable functions) */
+    value?: bigint;
+    /** Transaction sequence number for the sender */
+    nonce?: number;
+    /** Contract address (if different from standard deployment) */
+    to?: Address;
+}
+/**
+ * Extends viem's TransactionReceipt with Vana-specific event data.
+ *
+ * @remarks
+ * Includes parsed event data when available after transaction confirmation.
+ * Use this for detailed transaction analysis and event processing.
+ *
+ * @category Operations
+ */
+export interface TransactionReceipt extends ViemReceipt {
+    /** Parsed event data if available */
+    events?: unknown;
+}
+/**
+ * Configures polling behavior for asynchronous operations.
+ *
+ * @remarks
+ * Controls how frequently and how long to poll for operation completion.
+ * Lower intervals provide faster updates but increase server load.
+ *
+ * @category Operations
+ */
+export interface PollingOptions {
+    /** Polling interval in milliseconds (default: 500) */
+    pollingInterval?: number;
+    /** Maximum time to wait in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * Configures transaction confirmation waiting behavior.
+ *
+ * @remarks
+ * Controls confirmation depth and timeout for transaction finality.
+ * Higher confirmations provide more security against chain reorganizations.
+ *
+ * @category Operations
+ */
+export interface TransactionWaitOptions {
+    /** Number of confirmations to wait for (default: 1) */
+    confirmations?: number;
+    /** Polling interval in milliseconds (default: 1000) */
+    pollingInterval?: number;
+    /** Maximum time to wait in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * Validates whether an object conforms to the Operation interface.
+ *
+ * @remarks
+ * Type guard for runtime validation of operation objects from external sources.
+ * Use when deserializing operations from API responses or storage.
+ *
+ * @param obj - The object to validate as an Operation
+ * @returns `true` if the object has required Operation properties, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch('/api/operation/123');
+ * const data = await response.json();
+ *
+ * if (isOperation(data)) {
+ *   console.log(`Operation ${data.id}: ${data.status}`);
+ * }
+ * ```
+ *
+ * @category Operations
+ */
+export declare function isOperation(obj: unknown): obj is Operation;
+/**
+ * Validates whether an object conforms to the TransactionResult interface.
+ *
+ * @remarks
+ * Type guard for runtime validation of transaction results.
+ * Checks for required hash field with proper `0x` prefix.
+ *
+ * @param obj - The object to validate as a TransactionResult
+ * @returns `true` if the object has a valid transaction hash, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isTransactionResult(result)) {
+ *   await vana.waitForTransactionEvents(result);
+ * }
+ * ```
+ *
+ * @category Operations
+ */
+export declare function isTransactionResult(obj: unknown): obj is TransactionResult;
+/**
+ * Converts a server response to an Operation POJO.
+ *
+ * @remarks
+ * Normalizes server responses into consistent Operation format.
+ * Separates success results from error messages based on status.
+ *
+ * @param response - The raw server response containing operation status data
+ * @returns An Operation object with normalized fields for client consumption
+ *
+ * @example
+ * ```typescript
+ * const serverResponse = await api.getOperation('op-123');
+ * const operation = toOperation<MLResult>(serverResponse);
+ *
+ * if (operation.status === 'succeeded') {
+ *   console.log('Result:', operation.result);
+ * }
+ * ```
+ *
+ * @category Operations
+ */
+export declare function toOperation<T>(response: GetOperationResponse): Operation<T>;
+/**
+ * Extracts the operation ID from flexible input types.
+ *
+ * @remarks
+ * Utility for handling both Operation objects and raw ID strings.
+ * Enables flexible API design accepting either format.
+ *
+ * @param opOrId - An Operation object containing an `id` field or a raw operation ID string
+ * @returns The operation ID string for use in API calls
+ *
+ * @example
+ * ```typescript
+ * // Works with both formats
+ * await vana.server.getOperation(operation); // Operation object
+ * await vana.server.getOperation('op-123');  // ID string
+ * ```
+ *
+ * @category Operations
+ */
+export declare function getOperationId(opOrId: Operation | string): string;
+/**
+ * Extracts the transaction hash from flexible input types.
+ *
+ * @remarks
+ * Utility for handling TransactionResult objects, hash objects, or raw hash strings.
+ * Enables consistent hash extraction across different transaction representations.
+ *
+ * @param txOrHash - A TransactionResult object, any object with a `hash` field, or a raw hash string
+ * @returns The transaction hash as a `0x`-prefixed string
+ *
+ * @example
+ * ```typescript
+ * // All these work
+ * const hash1 = getTransactionHash(transactionResult);
+ * const hash2 = getTransactionHash({ hash: '0x123...' });
+ * const hash3 = getTransactionHash('0x123...');
+ * ```
+ *
+ * @category Operations
+ */
+export declare function getTransactionHash(txOrHash: TransactionResult | {
+    hash: Hash;
+} | Hash): Hash;

package/dist/types/operations.js

@@ -0,0 +1,37 @@
+function isOperation(obj) {
+  return typeof obj === "object" && obj !== null && "id" in obj && "status" in obj && typeof obj.id === "string" && typeof obj.status === "string";
+}
+function isTransactionResult(obj) {
+  if (typeof obj !== "object" || obj === null || !("hash" in obj)) {
+    return false;
+  }
+  const { hash } = obj;
+  return typeof hash === "string" && hash.startsWith("0x");
+}
+function toOperation(response) {
+  return {
+    id: response.id,
+    status: response.status,
+    createdAt: Date.now(),
+    // Server doesn't provide this, so we use current time
+    result: response.status === "succeeded" ? response.result : void 0,
+    error: response.status === "failed" ? response.result ?? void 0 : void 0
+  };
+}
+function getOperationId(opOrId) {
+  return typeof opOrId === "string" ? opOrId : opOrId.id;
+}
+function getTransactionHash(txOrHash) {
+  if (typeof txOrHash === "string") {
+    return txOrHash;
+  }
+  return txOrHash.hash;
+}
+export {
+  getOperationId,
+  getTransactionHash,
+  isOperation,
+  isTransactionResult,
+  toOperation
+};
+//# sourceMappingURL=operations.js.map

package/dist/types/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/operations.ts"],"sourcesContent":["import type { Hash, TransactionReceipt as ViemReceipt, Address } from \"viem\";\nimport type { GetOperationResponse } from \"../generated/server/server-exports\";\nimport type { Contract, Fn } from \"../generated/event-types\";\n\n// Re-export TransactionOptions from the new options module\nexport type { TransactionOptions } from \"./options\";\n\n/**\n * Represents a server-side operation status and result.\n *\n * @remarks\n * Operations track asynchronous server processes like data refinement or ML inference.\n * Poll operation status using `vana.server.waitForOperation()` until completion.\n * Fully serializable for API responses and cross-process communication.\n *\n * @category Operations\n * @see {@link https://docs.vana.org/docs/operations | Operations Guide}\n */\nexport interface Operation<T = unknown> {\n  /** Unique operation identifier */\n  id: string;\n  /** Current operation status */\n  status: \"starting\" | \"running\" | \"succeeded\" | \"failed\" | \"canceled\";\n  /** Unix timestamp when operation was created */\n  createdAt: number;\n  /** Unix timestamp when operation was last updated */\n  updatedAt?: number;\n  /** Operation result when status is 'succeeded' */\n  result?: T;\n  /** Error message when status is 'failed' */\n  error?: string;\n  /** Additional operation metadata */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Represents a submitted blockchain transaction as a self-describing POJO.\n *\n * @remarks\n * Transaction results MUST include contract and function for proper event parsing.\n * This strongly-typed design enables automatic event extraction without heuristics.\n * Use `vana.waitForTransactionEvents()` to retrieve typed events from the receipt.\n *\n * **Architecture:**\n * POJOs (Plain Old JavaScript Objects) ensure serialization safety and framework\n * independence. Contract and function fields enable deterministic event parsing.\n *\n * @category Operations\n * @example\n * ```typescript\n * const result: TransactionResult = {\n *   hash: '0x123...',\n *   from: '0x456...',\n *   contract: 'DataRegistry',\n *   fn: 'addFile',\n *   chainId: 14800\n * };\n *\n * // Wait for events\n * const events = await vana.waitForTransactionEvents(result);\n * ```\n */\nexport interface TransactionResult<\n  C extends Contract = Contract,\n  F extends Fn<C> = Fn<C>,\n> {\n  /** Transaction hash for tracking and confirmation */\n  hash: Hash;\n  /** Sender's wallet address */\n  from: Address;\n  /** Contract that was called (required for event parsing) */\n  contract: C;\n  /** Function that was called (required for event parsing) */\n  fn: F;\n  /** Network chain ID where transaction was submitted */\n  chainId?: number;\n  /** Transaction value in wei (for payable functions) */\n  value?: bigint;\n  /** Transaction sequence number for the sender */\n  nonce?: number;\n  /** Contract address (if different from standard deployment) */\n  to?: Address;\n}\n\n/**\n * Extends viem's TransactionReceipt with Vana-specific event data.\n *\n * @remarks\n * Includes parsed event data when available after transaction confirmation.\n * Use this for detailed transaction analysis and event processing.\n *\n * @category Operations\n */\nexport interface TransactionReceipt extends ViemReceipt {\n  /** Parsed event data if available */\n  events?: unknown;\n}\n\n/**\n * Configures polling behavior for asynchronous operations.\n *\n * @remarks\n * Controls how frequently and how long to poll for operation completion.\n * Lower intervals provide faster updates but increase server load.\n *\n * @category Operations\n */\nexport interface PollingOptions {\n  /** Polling interval in milliseconds (default: 500) */\n  pollingInterval?: number;\n  /** Maximum time to wait in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/**\n * Configures transaction confirmation waiting behavior.\n *\n * @remarks\n * Controls confirmation depth and timeout for transaction finality.\n * Higher confirmations provide more security against chain reorganizations.\n *\n * @category Operations\n */\nexport interface TransactionWaitOptions {\n  /** Number of confirmations to wait for (default: 1) */\n  confirmations?: number;\n  /** Polling interval in milliseconds (default: 1000) */\n  pollingInterval?: number;\n  /** Maximum time to wait in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/**\n * Validates whether an object conforms to the Operation interface.\n *\n * @remarks\n * Type guard for runtime validation of operation objects from external sources.\n * Use when deserializing operations from API responses or storage.\n *\n * @param obj - The object to validate as an Operation\n * @returns `true` if the object has required Operation properties, `false` otherwise\n *\n * @example\n * ```typescript\n * const response = await fetch('/api/operation/123');\n * const data = await response.json();\n *\n * if (isOperation(data)) {\n *   console.log(`Operation ${data.id}: ${data.status}`);\n * }\n * ```\n *\n * @category Operations\n */\nexport function isOperation(obj: unknown): obj is Operation {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"id\" in obj &&\n    \"status\" in obj &&\n    typeof (obj as Record<string, unknown>).id === \"string\" &&\n    typeof (obj as Record<string, unknown>).status === \"string\"\n  );\n}\n\n/**\n * Validates whether an object conforms to the TransactionResult interface.\n *\n * @remarks\n * Type guard for runtime validation of transaction results.\n * Checks for required hash field with proper `0x` prefix.\n *\n * @param obj - The object to validate as a TransactionResult\n * @returns `true` if the object has a valid transaction hash, `false` otherwise\n *\n * @example\n * ```typescript\n * if (isTransactionResult(result)) {\n *   await vana.waitForTransactionEvents(result);\n * }\n * ```\n *\n * @category Operations\n */\nexport function isTransactionResult(obj: unknown): obj is TransactionResult {\n  if (typeof obj !== \"object\" || obj === null || !(\"hash\" in obj)) {\n    return false;\n  }\n  const { hash } = obj as Record<string, unknown>;\n  return typeof hash === \"string\" && hash.startsWith(\"0x\");\n}\n\n/**\n * Converts a server response to an Operation POJO.\n *\n * @remarks\n * Normalizes server responses into consistent Operation format.\n * Separates success results from error messages based on status.\n *\n * @param response - The raw server response containing operation status data\n * @returns An Operation object with normalized fields for client consumption\n *\n * @example\n * ```typescript\n * const serverResponse = await api.getOperation('op-123');\n * const operation = toOperation<MLResult>(serverResponse);\n *\n * if (operation.status === 'succeeded') {\n *   console.log('Result:', operation.result);\n * }\n * ```\n *\n * @category Operations\n */\nexport function toOperation<T>(response: GetOperationResponse): Operation<T> {\n  return {\n    id: response.id,\n    status: response.status as Operation[\"status\"],\n    createdAt: Date.now(), // Server doesn't provide this, so we use current time\n    result:\n      response.status === \"succeeded\" ? (response.result as T) : undefined,\n    error:\n      response.status === \"failed\" ? (response.result ?? undefined) : undefined,\n  };\n}\n\n/**\n * Extracts the operation ID from flexible input types.\n *\n * @remarks\n * Utility for handling both Operation objects and raw ID strings.\n * Enables flexible API design accepting either format.\n *\n * @param opOrId - An Operation object containing an `id` field or a raw operation ID string\n * @returns The operation ID string for use in API calls\n *\n * @example\n * ```typescript\n * // Works with both formats\n * await vana.server.getOperation(operation); // Operation object\n * await vana.server.getOperation('op-123');  // ID string\n * ```\n *\n * @category Operations\n */\nexport function getOperationId(opOrId: Operation | string): string {\n  return typeof opOrId === \"string\" ? opOrId : opOrId.id;\n}\n\n/**\n * Extracts the transaction hash from flexible input types.\n *\n * @remarks\n * Utility for handling TransactionResult objects, hash objects, or raw hash strings.\n * Enables consistent hash extraction across different transaction representations.\n *\n * @param txOrHash - A TransactionResult object, any object with a `hash` field, or a raw hash string\n * @returns The transaction hash as a `0x`-prefixed string\n *\n * @example\n * ```typescript\n * // All these work\n * const hash1 = getTransactionHash(transactionResult);\n * const hash2 = getTransactionHash({ hash: '0x123...' });\n * const hash3 = getTransactionHash('0x123...');\n * ```\n *\n * @category Operations\n */\nexport function getTransactionHash(\n  txOrHash: TransactionResult | { hash: Hash } | Hash,\n): Hash {\n  if (typeof txOrHash === \"string\") {\n    return txOrHash;\n  }\n  return txOrHash.hash;\n}\n"],"mappings":"AA0JO,SAAS,YAAY,KAAgC;AAC1D,SACE,OAAO,QAAQ,YACf,QAAQ,QACR,QAAQ,OACR,YAAY,OACZ,OAAQ,IAAgC,OAAO,YAC/C,OAAQ,IAAgC,WAAW;AAEvD;AAqBO,SAAS,oBAAoB,KAAwC;AAC1E,MAAI,OAAO,QAAQ,YAAY,QAAQ,QAAQ,EAAE,UAAU,MAAM;AAC/D,WAAO;AAAA,EACT;AACA,QAAM,EAAE,KAAK,IAAI;AACjB,SAAO,OAAO,SAAS,YAAY,KAAK,WAAW,IAAI;AACzD;AAwBO,SAAS,YAAe,UAA8C;AAC3E,SAAO;AAAA,IACL,IAAI,SAAS;AAAA,IACb,QAAQ,SAAS;AAAA,IACjB,WAAW,KAAK,IAAI;AAAA;AAAA,IACpB,QACE,SAAS,WAAW,cAAe,SAAS,SAAe;AAAA,IAC7D,OACE,SAAS,WAAW,WAAY,SAAS,UAAU,SAAa;AAAA,EACpE;AACF;AAqBO,SAAS,eAAe,QAAoC;AACjE,SAAO,OAAO,WAAW,WAAW,SAAS,OAAO;AACtD;AAsBO,SAAS,mBACd,UACM;AACN,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,EACT;AACA,SAAO,SAAS;AAClB;","names":[]}