agentvault 1.0.0 → 1.0.2

package/dist/src/wallet/providers/solana-provider.js

@@ -0,0 +1,393 @@
+/**
+ * Solana Wallet Provider (Full Implementation)
+ *
+ * Complete provider for Solana wallet operations.
+ * Integrates with @solana/web3.js for key derivation.
+ * Uses Connection for real RPC network interactions.
+ */
+import { BaseWalletProvider } from './base-provider.js';
+import { Connection, Keypair, PublicKey, SystemProgram, Transaction as SolanaTransaction, LAMPORTS_PER_SOL, } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+/**
+ * Solana wallet provider
+ */
+export class SolanaProvider extends BaseWalletProvider {
+    connection = null;
+    keypair = null;
+    network;
+    commitment;
+    constructor(config) {
+        super(config);
+        this.network = config.network || 'mainnet';
+        this.commitment = config.commitment || 'confirmed';
+    }
+    /**
+     * Connect to Solana network via RPC
+     */
+    async connect() {
+        try {
+            const rpcUrl = this.config.rpcUrl || this.getDefaultRpcUrl();
+            this.connection = new Connection(rpcUrl, this.commitment);
+            // Verify connection by getting latest slot
+            const slot = await this.connection.getSlot();
+            this.connected = true;
+            console.log(`Connected to Solana ${this.network} at slot ${slot}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to connect to Solana network: ${message}`);
+        }
+    }
+    /**
+     * Disconnect from Solana network
+     */
+    async disconnect() {
+        this.connection = null;
+        this.keypair = null;
+        this.connected = false;
+    }
+    /**
+     * Get wallet balance
+     */
+    async getBalance(address) {
+        if (!this.connected || !this.connection) {
+            throw new Error('Provider not connected');
+        }
+        try {
+            const publicKey = new PublicKey(address);
+            const balanceInLamports = await this.connection.getBalance(publicKey);
+            const balanceInSol = balanceInLamports / LAMPORTS_PER_SOL;
+            const slot = await this.connection.getSlot();
+            return {
+                amount: balanceInSol.toString(),
+                denomination: 'SOL',
+                chain: 'solana',
+                address,
+                blockNumber: slot,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to get balance: ${message}`);
+        }
+    }
+    /**
+     * Send transaction
+     */
+    async sendTransaction(from, request) {
+        if (!this.connected || !this.connection || !this.keypair) {
+            throw new Error('Provider not connected or no wallet loaded');
+        }
+        try {
+            const toPublicKey = new PublicKey(request.to);
+            const fromPublicKey = new PublicKey(from);
+            const amountInLamports = this.parseSolAmount(request.amount);
+            // Get latest blockhash
+            const { blockhash } = await this.connection.getLatestBlockhash();
+            // Create SystemProgram transfer instruction
+            const instruction = SystemProgram.transfer({
+                fromPubkey: fromPublicKey,
+                toPubkey: toPublicKey,
+                lamports: amountInLamports,
+            });
+            // Create transaction
+            const transaction = new SolanaTransaction().add(instruction);
+            transaction.recentBlockhash = blockhash;
+            transaction.feePayer = fromPublicKey;
+            // Sign and send transaction
+            const signature = await this.connection.sendTransaction(transaction, [this.keypair]);
+            const fee = await this.estimateFee(request);
+            return {
+                hash: signature,
+                from,
+                to: request.to,
+                amount: request.amount,
+                chain: 'solana',
+                timestamp: Date.now(),
+                status: 'pending',
+                fee,
+                data: { memo: request.memo },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to send transaction: ${message}`);
+        }
+    }
+    /**
+     * Sign transaction
+     */
+    async signTransaction(tx, privateKey) {
+        if (!this.connection) {
+            throw new Error('Provider not connected');
+        }
+        try {
+            const keypair = this.createKeypairFromPrivateKey(privateKey);
+            const toPublicKey = new PublicKey(tx.to);
+            const fromPublicKey = keypair.publicKey;
+            const amountInLamports = this.parseSolAmount(tx.amount);
+            // Get latest blockhash
+            const { blockhash } = await this.connection.getLatestBlockhash();
+            // Create transaction
+            const instruction = SystemProgram.transfer({
+                fromPubkey: fromPublicKey,
+                toPubkey: toPublicKey,
+                lamports: amountInLamports,
+            });
+            const transaction = new SolanaTransaction().add(instruction);
+            transaction.recentBlockhash = blockhash;
+            transaction.feePayer = fromPublicKey;
+            // Sign transaction
+            transaction.sign(keypair);
+            return {
+                txHash: transaction.signature?.toString() || '',
+                signedTx: transaction.serialize().toString('base64'),
+                signature: Buffer.from(transaction.signature).toString('hex'),
+                request: tx,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to sign transaction: ${message}`);
+        }
+    }
+    /**
+     * Get transaction history
+     */
+    async getTransactionHistory(address) {
+        if (!this.connected || !this.connection) {
+            throw new Error('Provider not connected');
+        }
+        try {
+            const publicKey = new PublicKey(address);
+            const transactions = [];
+            // Get recent signatures for this address (limit to 20)
+            const signatures = await this.connection.getSignaturesForAddress(publicKey, { limit: 20 });
+            // Fetch detailed transaction info for each signature
+            for (const sig of signatures) {
+                try {
+                    const tx = await this.connection.getParsedTransaction(sig.signature, { maxSupportedTransactionVersion: 0 });
+                    if (!tx || !tx.meta)
+                        continue;
+                    // Find transfer instruction
+                    const transfer = tx.transaction.message.instructions.find((ix) => ix.programId.toBase58() === SystemProgram.programId.toBase58());
+                    if (!transfer)
+                        continue;
+                    const parsedIx = transfer.parsed;
+                    if (parsedIx?.type !== 'transfer')
+                        continue;
+                    const { from, to, lamports } = parsedIx.info;
+                    // Only include transactions involving this address
+                    if (from !== address && to !== address)
+                        continue;
+                    transactions.push({
+                        hash: sig.signature,
+                        from,
+                        to,
+                        amount: (lamports / LAMPORTS_PER_SOL).toFixed(9),
+                        chain: 'solana',
+                        timestamp: (sig.blockTime || Date.now() / 1000) * 1000,
+                        status: 'confirmed',
+                        fee: tx.meta.fee
+                            ? (tx.meta.fee / LAMPORTS_PER_SOL).toFixed(9)
+                            : '0',
+                    });
+                }
+                catch (error) {
+                    console.warn(`Failed to fetch transaction ${sig.signature}:`, error);
+                    continue;
+                }
+            }
+            return transactions;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.warn(`Failed to get transaction history: ${message}`);
+            return [];
+        }
+    }
+    /**
+     * Validate Solana address (Base58 format)
+     */
+    validateAddress(address) {
+        try {
+            new PublicKey(address);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Estimate transaction fee
+     */
+    async estimateFee(request) {
+        if (!this.connected || !this.connection || !this.keypair) {
+            return '0.000005'; // Default minimum
+        }
+        try {
+            const toPublicKey = new PublicKey(request.to);
+            const fromPublicKey = this.keypair.publicKey;
+            const amountInLamports = this.parseSolAmount(request.amount);
+            // Get latest blockhash
+            const { blockhash } = await this.connection.getLatestBlockhash();
+            // Create transaction
+            const instruction = SystemProgram.transfer({
+                fromPubkey: fromPublicKey,
+                toPubkey: toPublicKey,
+                lamports: amountInLamports,
+            });
+            const transaction = new SolanaTransaction().add(instruction);
+            transaction.recentBlockhash = blockhash;
+            transaction.feePayer = fromPublicKey;
+            // Estimate fee
+            const fee = await transaction.getEstimatedFee(this.connection);
+            if (!fee)
+                return '0.000005';
+            const feeInSol = fee / LAMPORTS_PER_SOL;
+            return feeInSol.toFixed(9);
+        }
+        catch (_error) {
+            return '0.000005';
+        }
+    }
+    /**
+     * Get current block number (slot)
+     */
+    async getBlockNumber() {
+        if (!this.connected || !this.connection) {
+            throw new Error('Provider not connected');
+        }
+        try {
+            return await this.connection.getSlot();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to get block number: ${message}`);
+        }
+    }
+    /**
+     * Get transaction by hash
+     */
+    async getTransaction(txHash) {
+        if (!this.connected || !this.connection) {
+            throw new Error('Provider not connected');
+        }
+        try {
+            const tx = await this.connection.getParsedTransaction(txHash, { maxSupportedTransactionVersion: 0 });
+            if (!tx || !tx.meta)
+                return null;
+            // Find transfer instruction
+            const transfer = tx.transaction.message.instructions.find((ix) => ix.programId.toBase58() === SystemProgram.programId.toBase58());
+            if (!transfer)
+                return null;
+            const parsedIx = transfer.parsed;
+            if (parsedIx?.type !== 'transfer')
+                return null;
+            const { from, to, lamports } = parsedIx.info;
+            return {
+                hash: txHash,
+                from,
+                to,
+                amount: (lamports / LAMPORTS_PER_SOL).toFixed(9),
+                chain: 'solana',
+                timestamp: (tx.blockTime || Date.now() / 1000) * 1000,
+                status: 'confirmed',
+                fee: tx.meta.fee
+                    ? (tx.meta.fee / LAMPORTS_PER_SOL).toFixed(9)
+                    : '0',
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to get transaction: ${message}`);
+        }
+    }
+    /**
+     * Initialize keypair from wallet data
+     */
+    async initKeypair(mnemonic, derivationPath) {
+        try {
+            const { generateSeedFromMnemonic, deriveSolanaKey } = await import('../key-derivation.js');
+            const seed = generateSeedFromMnemonic(mnemonic);
+            const path = derivationPath || "m/44'/501'/0'/0'/0'";
+            const derived = deriveSolanaKey(seed, path);
+            const privateKeyBytes = Uint8Array.from(Buffer.from(derived.privateKey, 'hex'));
+            this.keypair = Keypair.fromSecretKey(privateKeyBytes);
+            console.log('Solana keypair initialized for derivation:', path);
+            console.log('Address:', this.getAddress());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to initialize Solana keypair: ${message}`);
+        }
+    }
+    /**
+     * Initialize from private key
+     */
+    async initFromPrivateKey(privateKey) {
+        try {
+            this.keypair = this.createKeypairFromPrivateKey(privateKey);
+            console.log('Solana keypair initialized from private key');
+            console.log('Address:', this.getAddress());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to initialize Solana keypair from private key: ${message}`);
+        }
+    }
+    /**
+     * Create Keypair from private key
+     */
+    createKeypairFromPrivateKey(privateKeyHex) {
+        const privateKeyBytes = Buffer.from(privateKeyHex, 'hex');
+        return Keypair.fromSecretKey(privateKeyBytes.subarray(0, 32));
+    }
+    /**
+     * Get address from keypair
+     */
+    getAddress() {
+        if (!this.keypair) {
+            return null;
+        }
+        return this.keypair.publicKey.toBase58();
+    }
+    /**
+     * Get public key
+     */
+    getPublicKey() {
+        if (!this.keypair) {
+            return null;
+        }
+        return Buffer.from(this.keypair.publicKey.toBytes()).toString('hex');
+    }
+    /**
+     * Parse SOL amount to lamports
+     */
+    parseSolAmount(amountStr) {
+        try {
+            const cleanAmount = amountStr.replace(/,/g, '').trim();
+            const amount = parseFloat(cleanAmount);
+            return Math.floor(amount * LAMPORTS_PER_SOL);
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Get default RPC URL for network type
+     * Checks environment variables first, then falls back to public RPC endpoints
+     */
+    getDefaultRpcUrl() {
+        const envUrls = {
+            mainnet: process.env.SOLANA_MAINNET_RPC_URL || process.env.SOLANA_RPC_URL,
+            devnet: process.env.SOLANA_DEVNET_RPC_URL || process.env.SOLANA_RPC_URL,
+        };
+        const publicUrls = {
+            mainnet: 'https://api.mainnet-beta.solana.com',
+            devnet: 'https://api.devnet.solana.com',
+        };
+        return envUrls[this.network] || publicUrls[this.network] || publicUrls.mainnet;
+    }
+}
+//# sourceMappingURL=solana-provider.js.map

package/dist/src/wallet/transaction-queue.d.ts

@@ -0,0 +1,133 @@
+/**
+ * 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 declare class TransactionQueueProcessor {
+    private actor;
+    private maxRetries;
+    constructor(_canisterId: string, actor: any, options?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    });
+    /**
+     * Fetch pending transactions from canister
+     */
+    fetchPendingTransactions(): Promise<QueuedTransaction[]>;
+    /**
+     * Process all pending transactions
+     *
+     * @param signCallback - Callback to sign transactions
+     * @returns Processing results
+     */
+    processPendingTransactions(signCallback: (wallet: WalletData, action: TransactionRequest) => Promise<SignedTransaction | null>): Promise<ProcessResult[]>;
+    /**
+     * Process a single transaction
+     */
+    private processTransaction;
+    /**
+     * Map canister action to transaction request
+     */
+    private mapActionToRequest;
+    /**
+     * Mark transaction as signed in canister
+     */
+    private markSigned;
+    /**
+     * Mark transaction as failed in canister
+     */
+    private markFailed;
+    /**
+     * Mark transaction as completed in canister
+     */
+    markCompleted(txId: string, txHash: string): Promise<void>;
+    /**
+     * Get queue statistics
+     */
+    getStats(): Promise<QueueStats | null>;
+    /**
+     * Schedule transaction for future execution
+     */
+    scheduleTransaction(txId: string, scheduledAt: Date): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Clear completed transactions
+     */
+    clearCompleted(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+/**
+ * Create transaction queue processor
+ *
+ * @param canisterId - Canister ID
+ * @param actor - Canister actor instance
+ * @returns Queue processor instance
+ */
+export declare function createQueueProcessor(canisterId: string, actor: any, options?: {
+    maxRetries?: number;
+    retryDelay?: number;
+}): TransactionQueueProcessor;
+//# sourceMappingURL=transaction-queue.d.ts.map