agentvault 1.0.0 → 1.0.2

package/dist/src/wallet/cbor-serializer.js

@@ -0,0 +1,282 @@
+/**
+ * CBOR Serializer/Deserializer
+ *
+ * Uses cbor-x to encode/decode wallet data and transactions.
+ * Provides efficient binary serialization for wallet operations.
+ */
+import * as cbor from 'cbor-x';
+/**
+ * Serialize wallet data to CBOR
+ *
+ * @param wallet - Wallet data to serialize
+ * @param options - CBOR encoding options
+ * @returns CBOR-encoded wallet data
+ */
+export function serializeWallet(wallet, _options = {}) {
+    try {
+        const walletObject = {
+            id: wallet.id,
+            agentId: wallet.agentId,
+            chain: wallet.chain,
+            address: wallet.address,
+            privateKey: wallet.privateKey,
+            mnemonic: wallet.mnemonic,
+            seedDerivationPath: wallet.seedDerivationPath,
+            createdAt: wallet.createdAt,
+            updatedAt: wallet.updatedAt,
+            creationMethod: wallet.creationMethod,
+            chainMetadata: wallet.chainMetadata,
+        };
+        const encoded = cbor.encode(walletObject);
+        // Add checksum for tamper detection
+        const checksum = calculateChecksum(encoded);
+        const withChecksum = new Uint8Array(encoded.length + checksum.length);
+        withChecksum.set(encoded);
+        withChecksum.set(checksum, encoded.length);
+        return withChecksum;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to serialize wallet: ${message}`);
+    }
+}
+/**
+ * Deserialize CBOR data to wallet
+ *
+ * @param data - CBOR-encoded wallet data
+ * @returns Deserialized wallet data
+ */
+export function deserializeWallet(data) {
+    try {
+        // Verify checksum
+        const checksumLength = 4;
+        if (data.length < checksumLength) {
+            throw new Error('Invalid wallet data: too short');
+        }
+        const payload = data.slice(0, -checksumLength);
+        const checksum = data.slice(-checksumLength);
+        const expectedChecksum = calculateChecksum(payload);
+        if (!buffersEqual(checksum, expectedChecksum)) {
+            throw new Error('Invalid wallet data: checksum mismatch');
+        }
+        const decoded = cbor.decode(payload);
+        if (!decoded) {
+            throw new Error('Invalid wallet data: decode failed');
+        }
+        return {
+            id: decoded.id || '',
+            agentId: decoded.agentId || '',
+            chain: decoded.chain || 'cketh',
+            address: decoded.address || '',
+            privateKey: decoded.privateKey,
+            mnemonic: decoded.mnemonic,
+            seedDerivationPath: decoded.seedDerivationPath,
+            createdAt: decoded.createdAt || Date.now(),
+            updatedAt: decoded.updatedAt || Date.now(),
+            creationMethod: decoded.creationMethod || 'seed',
+            chainMetadata: decoded.chainMetadata,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to deserialize wallet: ${message}`);
+    }
+}
+/**
+ * Serialize transaction to CBOR
+ *
+ * @param transaction - Transaction to serialize
+ * @returns CBOR-encoded transaction
+ */
+export function serializeTransaction(transaction) {
+    try {
+        const txObject = {
+            hash: transaction.hash,
+            from: transaction.from,
+            to: transaction.to,
+            amount: transaction.amount,
+            chain: transaction.chain,
+            timestamp: transaction.timestamp,
+            status: transaction.status,
+            fee: transaction.fee,
+            data: transaction.data,
+        };
+        return cbor.encode(txObject);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to serialize transaction: ${message}`);
+    }
+}
+/**
+ * Deserialize CBOR data to transaction
+ *
+ * @param data - CBOR-encoded transaction data
+ * @returns Deserialized transaction
+ */
+export function deserializeTransaction(data) {
+    try {
+        const decoded = cbor.decode(data);
+        return {
+            hash: decoded.hash || '',
+            from: decoded.from || '',
+            to: decoded.to || '',
+            amount: decoded.amount || '0',
+            chain: decoded.chain || 'cketh',
+            timestamp: decoded.timestamp || Date.now(),
+            status: decoded.status || 'pending',
+            fee: decoded.fee,
+            data: decoded.data,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to deserialize transaction: ${message}`);
+    }
+}
+/**
+ * Serialize transaction request to CBOR
+ *
+ * @param request - Transaction request to serialize
+ * @returns CBOR-encoded transaction request
+ */
+export function serializeTransactionRequest(request) {
+    try {
+        const requestObject = {
+            to: request.to,
+            amount: request.amount,
+            chain: request.chain,
+            memo: request.memo,
+            gasPrice: request.gasPrice,
+            gasLimit: request.gasLimit,
+        };
+        return cbor.encode(requestObject);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to serialize transaction request: ${message}`);
+    }
+}
+/**
+ * Deserialize CBOR data to transaction request
+ *
+ * @param data - CBOR-encoded transaction request data
+ * @returns Deserialized transaction request
+ */
+export function deserializeTransactionRequest(data) {
+    try {
+        const decoded = cbor.decode(data);
+        return {
+            to: decoded.to || '',
+            amount: decoded.amount || '0',
+            chain: decoded.chain || 'cketh',
+            memo: decoded.memo,
+            gasPrice: decoded.gasPrice,
+            gasLimit: decoded.gasLimit,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to deserialize transaction request: ${message}`);
+    }
+}
+/**
+ * Serialize signed transaction to CBOR
+ *
+ * @param signedTx - Signed transaction to serialize
+ * @returns CBOR-encoded signed transaction
+ */
+export function serializeSignedTransaction(signedTx) {
+    try {
+        const txObject = {
+            txHash: signedTx.txHash,
+            signedTx: signedTx.signedTx,
+            signature: signedTx.signature,
+            request: signedTx.request,
+        };
+        return cbor.encode(txObject);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to serialize signed transaction: ${message}`);
+    }
+}
+/**
+ * Deserialize CBOR data to signed transaction
+ *
+ * @param data - CBOR-encoded signed transaction data
+ * @returns Deserialized signed transaction
+ */
+export function deserializeSignedTransaction(data) {
+    try {
+        const decoded = cbor.decode(data);
+        return {
+            txHash: decoded.txHash || '',
+            signedTx: decoded.signedTx || '',
+            signature: decoded.signature,
+            request: decoded.request,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to deserialize signed transaction: ${message}`);
+    }
+}
+/**
+ * Calculate checksum for data integrity
+ *
+ * @param data - Data to checksum
+ * @returns 4-byte checksum
+ */
+function calculateChecksum(data) {
+    let checksum = 0;
+    for (let i = 0; i < data.length; i++) {
+        const byte = data[i];
+        if (byte !== undefined) {
+            checksum = ((checksum << 8) ^ byte) >>> 0;
+        }
+    }
+    const result = new Uint8Array(4);
+    const view = new DataView(result.buffer);
+    view.setUint32(0, checksum, false); // Big-endian
+    return result;
+}
+/**
+ * Compare two buffers for equality
+ *
+ * @param a - First buffer
+ * @param b - Second buffer
+ * @returns True if buffers are equal
+ */
+function buffersEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Validate CBOR data structure
+ *
+ * @param data - CBOR-encoded data
+ * @returns True if data appears valid
+ */
+export function validateCborData(data) {
+    try {
+        // Attempt to decode
+        const decoded = cbor.decode(data);
+        // Check if it's an object
+        if (!decoded || typeof decoded !== 'object' || decoded === null) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=cbor-serializer.js.map

package/dist/src/wallet/chain-dispatcher.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Chain Dispatcher (Phase 5C)
+ *
+ * Routes transactions to appropriate blockchain providers.
+ * Supports ckETH, Polkadot, and Solana chains.
+ */
+import type { WalletData, TransactionRequest, Transaction, ChainType } from './types.js';
+/**
+ * Chain dispatcher configuration
+ */
+export interface ChainDispatcherConfig {
+    isTestnet?: boolean;
+    apiKey?: string;
+}
+/**
+ * Chain dispatcher
+ *
+ * Routes transactions to appropriate blockchain providers based on wallet chain.
+ */
+export declare class ChainDispatcher {
+    private providers;
+    private config;
+    constructor(config?: ChainDispatcherConfig);
+    /**
+     * Dispatch transaction to appropriate provider
+     *
+     * @param wallet - Wallet to use for signing
+     * @param request - Transaction request
+     * @returns Transaction result
+     */
+    dispatchTransaction(wallet: WalletData, request: TransactionRequest): Promise<Transaction>;
+    /**
+     * Sign transaction without broadcasting
+     *
+     * @param wallet - Wallet to use for signing
+     * @param request - Transaction request
+     * @returns Signed transaction
+     */
+    signTransaction(wallet: WalletData, request: TransactionRequest): Promise<{
+        signedTx: string;
+        signature: string;
+    }>;
+    /**
+     * Get wallet balance
+     *
+     * @param wallet - Wallet to query
+     * @returns Wallet balance
+     */
+    getBalance(wallet: WalletData): Promise<{
+        amount: string;
+        denomination: string;
+    }>;
+    /**
+     * Get transaction history
+     *
+     * @param wallet - Wallet to query
+     * @param limit - Maximum number of transactions
+     * @returns Transaction history
+     */
+    getTransactionHistory(wallet: WalletData, limit?: number): Promise<Transaction[]>;
+    /**
+     * Estimate transaction fee
+     *
+     * @param wallet - Wallet to use
+     * @param request - Transaction request
+     * @returns Estimated fee
+     */
+    estimateFee(wallet: WalletData, request: TransactionRequest): Promise<string>;
+    /**
+     * Validate address
+     *
+     * @param address - Address to validate
+     * @param chain - Chain to validate against
+     * @returns True if valid
+     */
+    validateAddress(address: string, chain: ChainType): Promise<boolean>;
+    /**
+     * Get current block number
+     *
+     * @param chain - Chain to query
+     * @returns Current block number
+     */
+    getBlockNumber(chain: ChainType): Promise<number>;
+    /**
+     * Get transaction by hash
+     *
+     * @param chain - Chain to query
+     * @param txHash - Transaction hash
+     * @returns Transaction details
+     */
+    getTransaction(chain: ChainType, txHash: string): Promise<Transaction | null>;
+    /**
+     * Get provider for chain
+     */
+    private getProvider;
+    /**
+     * Connect all providers
+     */
+    connectAll(): Promise<void>;
+    /**
+     * Disconnect all providers
+     */
+    disconnectAll(): Promise<void>;
+}
+/**
+ * Create chain dispatcher
+ *
+ * @param config - Dispatcher configuration
+ * @returns Chain dispatcher instance
+ */
+export declare function createChainDispatcher(config?: ChainDispatcherConfig): ChainDispatcher;
+//# sourceMappingURL=chain-dispatcher.d.ts.map

package/dist/src/wallet/chain-dispatcher.js

@@ -0,0 +1,241 @@
+/**
+ * Chain Dispatcher (Phase 5C)
+ *
+ * Routes transactions to appropriate blockchain providers.
+ * Supports ckETH, Polkadot, and Solana chains.
+ */
+import { CkEthProvider } from './providers/cketh-provider.js';
+import { PolkadotProvider } from './providers/polkadot-provider.js';
+import { SolanaProvider } from './providers/solana-provider.js';
+/**
+ * Chain dispatcher
+ *
+ * Routes transactions to appropriate blockchain providers based on wallet chain.
+ */
+export class ChainDispatcher {
+    providers;
+    config;
+    constructor(config = {}) {
+        this.config = {
+            isTestnet: config.isTestnet ?? false,
+            apiKey: config.apiKey,
+        };
+        this.providers = new Map();
+        this.providers.set('cketh', new CkEthProvider({
+            chain: 'cketh',
+            rpcUrl: '',
+            isTestnet: this.config.isTestnet,
+        }));
+        this.providers.set('polkadot', new PolkadotProvider({
+            chain: 'polkadot',
+            rpcUrl: '',
+            isTestnet: this.config.isTestnet,
+        }));
+        this.providers.set('solana', new SolanaProvider({
+            chain: 'solana',
+            rpcUrl: '',
+            isTestnet: this.config.isTestnet,
+        }));
+    }
+    /**
+     * Dispatch transaction to appropriate provider
+     *
+     * @param wallet - Wallet to use for signing
+     * @param request - Transaction request
+     * @returns Transaction result
+     */
+    async dispatchTransaction(wallet, request) {
+        const provider = this.getProvider(wallet.chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${wallet.chain}`);
+        }
+        await provider.connect();
+        const tx = await provider.sendTransaction(wallet.address, request);
+        return {
+            hash: tx.hash,
+            from: wallet.address,
+            to: request.to,
+            amount: request.amount,
+            chain: wallet.chain,
+            timestamp: Date.now(),
+            status: 'pending',
+            fee: tx.fee,
+        };
+    }
+    /**
+     * Sign transaction without broadcasting
+     *
+     * @param wallet - Wallet to use for signing
+     * @param request - Transaction request
+     * @returns Signed transaction
+     */
+    async signTransaction(wallet, request) {
+        const provider = this.getProvider(wallet.chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${wallet.chain}`);
+        }
+        await provider.connect();
+        const signed = await provider.signTransaction(request, wallet.privateKey);
+        return {
+            signedTx: signed.signedTx,
+            signature: signed.signature || '',
+        };
+    }
+    /**
+     * Get wallet balance
+     *
+     * @param wallet - Wallet to query
+     * @returns Wallet balance
+     */
+    async getBalance(wallet) {
+        const provider = this.getProvider(wallet.chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${wallet.chain}`);
+        }
+        await provider.connect();
+        const balance = await provider.getBalance(wallet.address);
+        return {
+            amount: balance.amount,
+            denomination: balance.denomination,
+        };
+    }
+    /**
+     * Get transaction history
+     *
+     * @param wallet - Wallet to query
+     * @param limit - Maximum number of transactions
+     * @returns Transaction history
+     */
+    async getTransactionHistory(wallet, limit = 20) {
+        const provider = this.getProvider(wallet.chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${wallet.chain}`);
+        }
+        await provider.connect();
+        const history = await provider.getTransactionHistory(wallet.address);
+        return history.slice(0, limit);
+    }
+    /**
+     * Estimate transaction fee
+     *
+     * @param wallet - Wallet to use
+     * @param request - Transaction request
+     * @returns Estimated fee
+     */
+    async estimateFee(wallet, request) {
+        const provider = this.getProvider(wallet.chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${wallet.chain}`);
+        }
+        await provider.connect();
+        const fee = await provider.estimateFee(request);
+        return fee;
+    }
+    /**
+     * Validate address
+     *
+     * @param address - Address to validate
+     * @param chain - Chain to validate against
+     * @returns True if valid
+     */
+    async validateAddress(address, chain) {
+        const provider = this.getProvider(chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${chain}`);
+        }
+        return await provider.validateAddress(address);
+    }
+    /**
+     * Get current block number
+     *
+     * @param chain - Chain to query
+     * @returns Current block number
+     */
+    async getBlockNumber(chain) {
+        const provider = this.getProvider(chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${chain}`);
+        }
+        await provider.connect();
+        const block = await provider.getBlockNumber();
+        return block;
+    }
+    /**
+     * Get transaction by hash
+     *
+     * @param chain - Chain to query
+     * @param txHash - Transaction hash
+     * @returns Transaction details
+     */
+    async getTransaction(chain, txHash) {
+        const provider = this.getProvider(chain);
+        if (!provider) {
+            throw new Error(`Unsupported chain: ${chain}`);
+        }
+        await provider.connect();
+        const tx = await provider.getTransaction(txHash);
+        if (!tx) {
+            return null;
+        }
+        return {
+            hash: tx.hash,
+            from: tx.from,
+            to: tx.to,
+            amount: tx.amount,
+            chain,
+            timestamp: tx.timestamp,
+            status: tx.status,
+            fee: tx.fee,
+        };
+    }
+    /**
+     * Get provider for chain
+     */
+    getProvider(chain) {
+        const provider = this.providers.get(chain);
+        if (!provider) {
+            throw new Error(`No provider found for chain: ${chain}`);
+        }
+        return provider;
+    }
+    /**
+     * Connect all providers
+     */
+    async connectAll() {
+        const connections = Array.from(this.providers.entries()).map(async ([chain, provider]) => {
+            try {
+                await provider.connect();
+                return { chain, success: true };
+            }
+            catch (error) {
+                return { chain, success: false, error };
+            }
+        });
+        await Promise.all(connections);
+    }
+    /**
+     * Disconnect all providers
+     */
+    async disconnectAll() {
+        const disconnections = Array.from(this.providers.entries()).map(async ([chain, provider]) => {
+            try {
+                await provider.disconnect();
+                return { chain, success: true };
+            }
+            catch (error) {
+                return { chain, success: false, error };
+            }
+        });
+        await Promise.all(disconnections);
+    }
+}
+/**
+ * Create chain dispatcher
+ *
+ * @param config - Dispatcher configuration
+ * @returns Chain dispatcher instance
+ */
+export function createChainDispatcher(config) {
+    return new ChainDispatcher(config);
+}
+//# sourceMappingURL=chain-dispatcher.js.map