agentvault 1.0.0

package/src/wallet/transaction-queue.ts

@@ -0,0 +1,284 @@
+/**
+ * Transaction Queue Processor (Phase 5B)
+ *
+ * Advanced transaction queue with priority, retries, and scheduling.
+ * Handles agent-initiated transactions queued in canister.
+ */
+
+import type {
+  WalletData,
+  TransactionRequest,
+  SignedTransaction,
+} from './types.js';
+
+/**
+ * Transaction action type
+ */
+export type TransactionAction = 'send_funds' | 'sign_message' | 'deploy_contract';
+
+/**
+ * Transaction priority
+ */
+export type TransactionPriority = 'low' | 'normal' | 'high';
+
+/**
+ * Transaction status
+ */
+export type TransactionStatus = 'pending' | 'queued' | 'signed' | 'completed' | 'failed';
+
+/**
+ * Queued transaction from canister
+ */
+export interface QueuedTransaction {
+  id: string;
+  action: {
+    walletId: string;
+    action: TransactionAction;
+    parameters: [string, string][];
+    priority: TransactionPriority;
+    threshold?: number;
+  };
+  status: TransactionStatus;
+  result?: string;
+  retryCount: number;
+  scheduledAt?: number;
+  createdAt: number;
+  signedAt?: number;
+  completedAt?: number;
+  errorMessage?: string;
+}
+
+/**
+ * Queue statistics
+ */
+export interface QueueStats {
+  total: number;
+  pending: number;
+  queued: number;
+  signed: number;
+  completed: number;
+  failed: number;
+}
+
+/**
+ * Process result
+ */
+export interface ProcessResult {
+  transactionId: string;
+  success: boolean;
+  txHash?: string;
+  error?: string;
+  processedAt: number;
+}
+
+/**
+ * Transaction queue processor
+ */
+export class TransactionQueueProcessor {
+  private actor: any;
+  private maxRetries: number;
+
+  constructor(_canisterId: string, actor: any, options?: { maxRetries?: number; retryDelay?: number }) {
+    this.actor = actor;
+    this.maxRetries = options?.maxRetries ?? 3;
+  }
+
+  /**
+   * Fetch pending transactions from canister
+   */
+  async fetchPendingTransactions(): Promise<QueuedTransaction[]> {
+    try {
+      return await this.actor.getPendingTransactions();
+    } catch (error) {
+      console.error('Failed to fetch pending transactions:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Process all pending transactions
+   *
+   * @param signCallback - Callback to sign transactions
+   * @returns Processing results
+   */
+  async processPendingTransactions(
+    signCallback: (wallet: WalletData, action: TransactionRequest) => Promise<SignedTransaction | null>
+  ): Promise<ProcessResult[]> {
+    const pending = await this.fetchPendingTransactions();
+    const results: ProcessResult[] = [];
+
+    for (const tx of pending) {
+      const result = await this.processTransaction(tx, signCallback);
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  /**
+   * Process a single transaction
+   */
+  private async processTransaction(
+    tx: QueuedTransaction,
+    signCallback: (wallet: WalletData, action: TransactionRequest) => Promise<SignedTransaction | null>
+  ): Promise<ProcessResult> {
+    const { getWallet } = await import('./wallet-manager.js');
+    const wallet = getWallet('', tx.action.walletId);
+
+    if (!wallet) {
+      await this.markFailed(tx.id, 'Wallet not found');
+      return {
+        transactionId: tx.id,
+        success: false,
+        error: 'Wallet not found',
+        processedAt: Date.now(),
+      };
+    }
+
+    try {
+      const action = this.mapActionToRequest(tx.action);
+
+      const signed = await signCallback(wallet, action);
+
+      if (!signed) {
+        await this.markFailed(tx.id, 'Signing failed');
+        return {
+          transactionId: tx.id,
+          success: false,
+          error: 'Signing failed',
+          processedAt: Date.now(),
+        };
+      }
+
+      await this.markSigned(tx.id, signed.signature || '');
+
+      return {
+        transactionId: tx.id,
+        success: true,
+        txHash: signed.txHash,
+        processedAt: Date.now(),
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+
+      if (tx.retryCount < this.maxRetries) {
+        await this.actor.retryTransaction(tx.id);
+      } else {
+        await this.markFailed(tx.id, message);
+      }
+
+      return {
+        transactionId: tx.id,
+        success: false,
+        error: message,
+        processedAt: Date.now(),
+      };
+    }
+  }
+
+  /**
+   * Map canister action to transaction request
+   */
+  private mapActionToRequest(action: QueuedTransaction['action']): TransactionRequest {
+    const params = new Map(action.parameters);
+
+    return {
+      to: params.get('to') || '',
+      amount: params.get('amount') || '0',
+      chain: (params.get('chain') || 'cketh') as any,
+      memo: params.get('memo'),
+      gasPrice: params.get('gasPrice'),
+      gasLimit: params.get('gasLimit'),
+    };
+  }
+
+  /**
+   * Mark transaction as signed in canister
+   */
+  private async markSigned(txId: string, signature: string): Promise<void> {
+    try {
+      await this.actor.markTransactionSigned(txId, signature);
+    } catch (error) {
+      console.error('Failed to mark transaction as signed:', error);
+    }
+  }
+
+  /**
+   * Mark transaction as failed in canister
+   */
+  private async markFailed(txId: string, error: string): Promise<void> {
+    try {
+      await this.actor.markTransactionFailed(txId, error);
+    } catch (err) {
+      console.error('Failed to mark transaction as failed:', err);
+    }
+  }
+
+  /**
+   * Mark transaction as completed in canister
+   */
+  async markCompleted(txId: string, txHash: string): Promise<void> {
+    try {
+      await this.actor.markTransactionCompleted(txId, txHash);
+    } catch (error) {
+      console.error('Failed to mark transaction as completed:', error);
+    }
+  }
+
+  /**
+   * Get queue statistics
+   */
+  async getStats(): Promise<QueueStats | null> {
+    try {
+      return await this.actor.getTransactionQueueStats();
+    } catch (error) {
+      console.error('Failed to get queue stats:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Schedule transaction for future execution
+   */
+  async scheduleTransaction(txId: string, scheduledAt: Date): Promise<{ success: boolean; error?: string }> {
+    try {
+      await this.actor.scheduleTransaction(txId, BigInt(scheduledAt.getTime()));
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  /**
+   * Clear completed transactions
+   */
+  async clearCompleted(): Promise<{ success: boolean; error?: string }> {
+    try {
+      await this.actor.clearCompletedTransactions();
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+}
+
+/**
+ * Create transaction queue processor
+ *
+ * @param canisterId - Canister ID
+ * @param actor - Canister actor instance
+ * @returns Queue processor instance
+ */
+export function createQueueProcessor(
+  canisterId: string,
+  actor: any,
+  options?: { maxRetries?: number; retryDelay?: number }
+): TransactionQueueProcessor {
+  return new TransactionQueueProcessor(canisterId, actor, options);
+}

package/src/wallet/types.ts

@@ -0,0 +1,178 @@
+/**
+ * Types for wallet operations
+ */
+
+/**
+ * Supported blockchain types
+ */
+export type ChainType = 'cketh' | 'polkadot' | 'solana';
+
+/**
+ * Wallet creation methods
+ */
+export type WalletCreationMethod = 'seed' | 'private-key' | 'mnemonic';
+
+/**
+ * Derivation path for BIP39 seed phrases
+ */
+export type DerivationPath = string;
+
+/**
+ * Wallet data structure (stored encrypted)
+ */
+export interface WalletData {
+  /** Unique wallet ID */
+  id: string;
+  /** Associated agent ID (for per-agent isolation) */
+  agentId: string;
+  /** Blockchain network */
+  chain: ChainType;
+  /** Public address */
+  address: string;
+  /** Encrypted private key (if available) */
+  privateKey?: string;
+  /** Encrypted mnemonic phrase (if available) */
+  mnemonic?: string;
+  /** BIP39 derivation path */
+  seedDerivationPath?: DerivationPath;
+  /** Creation timestamp */
+  createdAt: number;
+  /** Last update timestamp */
+  updatedAt: number;
+  /** Wallet creation method */
+  creationMethod: WalletCreationMethod;
+  /** Chain-specific metadata */
+  chainMetadata?: Record<string, any>;
+}
+
+/**
+ * Wallet connection status
+ */
+export interface WalletConnection {
+  /** Wallet ID */
+  walletId: string;
+  /** Connection status */
+  connected: boolean;
+  /** Chain-specific provider instance */
+  provider: any;
+  /** Connection timestamp */
+  connectedAt?: number;
+}
+
+/**
+ * Transaction data
+ */
+export interface Transaction {
+  /** Transaction hash */
+  hash: string;
+  /** From address */
+  from: string;
+  /** To address */
+  to: string;
+  /** Amount (as string to handle large numbers) */
+  amount: string;
+  /** Blockchain network */
+  chain: ChainType;
+  /** Transaction timestamp */
+  timestamp: number;
+  /** Transaction status */
+  status: 'pending' | 'confirmed' | 'failed';
+  /** Transaction fee */
+  fee?: string;
+  /** Additional data (memo, etc.) */
+  data?: any;
+}
+
+/**
+ * Wallet balance
+ */
+export interface Balance {
+  /** Amount (as string to handle large numbers) */
+  amount: string;
+  /** Denomination (ETH, DOT, SOL, etc.) */
+  denomination: string;
+  /** Blockchain network */
+  chain: ChainType;
+  /** Wallet address */
+  address: string;
+  /** Block number (if available) */
+  blockNumber?: number;
+}
+
+/**
+ * Transaction request
+ */
+export interface TransactionRequest {
+  /** Destination address */
+  to: string;
+  /** Amount to send (as string) */
+  amount: string;
+  /** Chain network */
+  chain: ChainType;
+  /** Optional memo (Solana) */
+  memo?: string;
+  /** Optional gas price (Ethereum/Polkadot) */
+  gasPrice?: string;
+  /** Optional gas limit (Ethereum/Polkadot) */
+  gasLimit?: string;
+}
+
+/**
+ * Signed transaction data
+ */
+export interface SignedTransaction {
+  /** Signed transaction hash */
+  txHash: string;
+  /** Raw signed transaction (hex/base58) */
+  signedTx: string;
+  /** Signature */
+  signature?: string;
+  /** Transaction request that was signed */
+  request: TransactionRequest;
+}
+
+/**
+ * Wallet creation options
+ */
+export interface WalletCreationOptions {
+  /** Agent ID to associate wallet with */
+  agentId: string;
+  /** Blockchain network */
+  chain: ChainType;
+  /** Wallet creation method */
+  method: WalletCreationMethod;
+  /** Seed phrase (for 'seed' and 'mnemonic' methods) */
+  seedPhrase?: string;
+  /** Private key (for 'private-key' method) */
+  privateKey?: string;
+  /** BIP39 derivation path */
+  derivationPath?: DerivationPath;
+  /** Optional custom wallet ID */
+  walletId?: string;
+  /** Optional chain-specific metadata */
+  chainMetadata?: Record<string, any>;
+}
+
+/**
+ * Wallet storage options
+ */
+export interface WalletStorageOptions {
+  /** Base directory for wallet storage */
+  baseDir?: string;
+  /** Enable encryption */
+  encrypt?: boolean;
+}
+
+/**
+ * Provider configuration
+ */
+export interface ProviderConfig {
+  /** Blockchain network */
+  chain: ChainType;
+  /** RPC endpoint URL */
+  rpcUrl?: string;
+  /** Testnet or mainnet */
+  isTestnet?: boolean;
+  /** API key (if required) */
+  apiKey?: string;
+}