agentvault 1.0.0 → 1.0.2

package/dist/src/wallet/transaction-queue.js

@@ -0,0 +1,195 @@
+/**
+ * Transaction Queue Processor (Phase 5B)
+ *
+ * Advanced transaction queue with priority, retries, and scheduling.
+ * Handles agent-initiated transactions queued in canister.
+ */
+/**
+ * Transaction queue processor
+ */
+export class TransactionQueueProcessor {
+    actor;
+    maxRetries;
+    constructor(_canisterId, actor, options) {
+        this.actor = actor;
+        this.maxRetries = options?.maxRetries ?? 3;
+    }
+    /**
+     * Fetch pending transactions from canister
+     */
+    async fetchPendingTransactions() {
+        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) {
+        const pending = await this.fetchPendingTransactions();
+        const results = [];
+        for (const tx of pending) {
+            const result = await this.processTransaction(tx, signCallback);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Process a single transaction
+     */
+    async processTransaction(tx, signCallback) {
+        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
+     */
+    mapActionToRequest(action) {
+        const params = new Map(action.parameters);
+        return {
+            to: params.get('to') || '',
+            amount: params.get('amount') || '0',
+            chain: (params.get('chain') || 'cketh'),
+            memo: params.get('memo'),
+            gasPrice: params.get('gasPrice'),
+            gasLimit: params.get('gasLimit'),
+        };
+    }
+    /**
+     * Mark transaction as signed in canister
+     */
+    async markSigned(txId, signature) {
+        try {
+            await this.actor.markTransactionSigned(txId, signature);
+        }
+        catch (error) {
+            console.error('Failed to mark transaction as signed:', error);
+        }
+    }
+    /**
+     * Mark transaction as failed in canister
+     */
+    async markFailed(txId, error) {
+        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, txHash) {
+        try {
+            await this.actor.markTransactionCompleted(txId, txHash);
+        }
+        catch (error) {
+            console.error('Failed to mark transaction as completed:', error);
+        }
+    }
+    /**
+     * Get queue statistics
+     */
+    async getStats() {
+        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, scheduledAt) {
+        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() {
+        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, actor, options) {
+    return new TransactionQueueProcessor(canisterId, actor, options);
+}
+//# sourceMappingURL=transaction-queue.js.map

package/dist/src/wallet/types.d.ts

@@ -0,0 +1,167 @@
+/**
+ * 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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/wallet/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for wallet operations
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/wallet/vetkeys-adapter.d.ts

@@ -0,0 +1,134 @@
+/**
+ * VetKeys Adapter (Phase 5D)
+ *
+ * Mock VetKeys canister integration for threshold signatures.
+ * Uses local-only implementation until VetKeys canister is deployed.
+ */
+import type { WalletData, TransactionRequest } from './types.js';
+/**
+ * Threshold signature result
+ */
+export interface ThresholdSignatureResult {
+    transactionId: string;
+    success: boolean;
+    signature?: string;
+    partialSignatures?: string[];
+    error?: string;
+    thresholdMet: boolean;
+}
+/**
+ * Encrypted secret for canister storage
+ */
+export interface EncryptedSecret {
+    id: string;
+    ciphertext: Uint8Array;
+    iv: Uint8Array;
+    tag: Uint8Array;
+    createdAt: number;
+}
+/**
+ * VetKeys adapter options
+ */
+export interface VetKeysAdapterOptions {
+    threshold?: number;
+    totalParties?: number;
+    encryptionAlgorithm?: 'aes-256-gcm' | 'chacha20-poly1305';
+    /** VetKeys canister ID for canister-based operations */
+    canisterId?: string;
+}
+/**
+ * VetKeys adapter
+ *
+ * VetKeys integration with optional canister support.
+ * Real VetKeys canister integration requires canisterId to be set.
+ */
+export declare class VetKeysAdapter {
+    private options;
+    private canisterId?;
+    constructor(options?: VetKeysAdapterOptions);
+    /**
+     * Encrypt secret for canister storage
+     *
+     * @param secret - Secret data to encrypt
+     * @param transactionId - Transaction ID for reference
+     * @returns Encrypted secret
+     */
+    encryptSecret(secret: string, transactionId?: string): Promise<EncryptedSecret>;
+    /**
+     * Decrypt secret from canister
+     *
+     * @param encrypted - Encrypted secret data
+     * @param key - Decryption key
+     * @returns Decrypted secret
+     */
+    decryptSecret(encrypted: EncryptedSecret, key: Buffer): Promise<string>;
+    /**
+     * Initiate threshold signature (mock)
+     *
+     * @param transactionId - Transaction ID
+     * @param wallet - Wallet to use
+     * @param request - Transaction request
+     * @returns Threshold signature result
+     */
+    initiateThresholdSignature(transactionId: string, wallet: WalletData, request: TransactionRequest): Promise<ThresholdSignatureResult>;
+    /**
+     * Combine partial signatures
+     *
+     * IMPORTANT: This requires a deployed VetKeys canister for proper threshold
+     * signature combination. Without the canister, this implementation validates
+     * signature format but cannot perform cryptographic combination.
+     *
+     * @param partialSignatures - Array of partial signatures
+     * @param canisterConnected - Whether VetKeys canister is available
+     * @returns Combined signature or error
+     */
+    combineSignatures(partialSignatures: string[], canisterConnected?: boolean): Promise<{
+        success: boolean;
+        combinedSignature?: string;
+        error?: string;
+    }>;
+    /**
+     * Verify threshold signature
+     *
+     * IMPORTANT: This requires a deployed VetKeys canister for proper threshold
+     * signature verification. Without the canister, this validates format only.
+     *
+     * @param signature - Signature to verify
+     * @param transaction - Transaction data
+     * @param canisterConnected - Whether VetKeys canister is available
+     * @returns Verification result
+     */
+    verifySignature(signature: string, transaction: TransactionRequest, canisterConnected?: boolean): Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get VetKeys status
+     *
+     * @returns VetKeys configuration status
+     */
+    getStatus(): {
+        thresholdSupported: boolean;
+        currentThreshold: number;
+        totalParties: number;
+        encryptionAlgorithm: string;
+        mode: 'mock' | 'production';
+    };
+    /**
+     * Check if canister is connected
+     *
+     * Attempts to ping the VetKeys canister to verify connectivity.
+     * Returns false if canisterId is not configured or canister is unreachable.
+     *
+     * @returns True if VetKeys canister is accessible
+     */
+    isCanisterConnected(): Promise<boolean>;
+}
+/**
+ * Create VetKeys adapter
+ *
+ * @param options - Adapter options
+ * @returns VetKeys adapter instance
+ */
+export declare function createVetKeysAdapter(options?: VetKeysAdapterOptions): VetKeysAdapter;
+//# sourceMappingURL=vetkeys-adapter.d.ts.map