agentvault 1.0.0

package/src/testing/local-runner.ts

@@ -0,0 +1,264 @@
+/**
+ * Local test runner for canister testing
+ *
+ * Provides test execution for unit, integration, and load tests against local canisters
+ */
+
+import { execa } from 'execa';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import type {
+  TestRunnerOptions,
+  TestSuite,
+  LoadTestConfig,
+  LoadTestResult,
+} from './types.js';
+
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const TEST_RESULTS_DIR = path.join(AGENTVAULT_DIR, 'test-results');
+
+/**
+ * Ensure test results directory exists
+ */
+function ensureTestResultsDir(): void {
+  if (!fs.existsSync(AGENTVAULT_DIR)) {
+    fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(TEST_RESULTS_DIR)) {
+    fs.mkdirSync(TEST_RESULTS_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get test results file path
+ */
+function getTestResultsPath(agentName: string, testType: string): string {
+  ensureTestResultsDir();
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return path.join(TEST_RESULTS_DIR, `${agentName}-${testType}-${timestamp}.json`);
+}
+
+/**
+ * Parse vitest output to extract test results
+ */
+function parseVitestOutput(stdout: string): TestSuite {
+  const lines = stdout.split('\n');
+  const tests: TestSuite['tests'] = [];
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let duration = 0;
+
+  for (const line of lines) {
+    const match = line.match(/^(PASS|FAIL|SKIP)\s+(.+) \((\d+)ms\)$/);
+    if (match) {
+      const [, status, nameRaw, timeRaw] = match;
+      const name = nameRaw?.trim() || 'unknown';
+      const time = timeRaw || '0';
+      tests.push({
+        name,
+        status: status === 'PASS' ? 'passed' : status === 'FAIL' ? 'failed' : 'skipped',
+        duration: parseInt(time, 10),
+      });
+      total++;
+      if (status === 'PASS') passed++;
+      else if (status === 'FAIL') failed++;
+      else skipped++;
+    }
+
+    const durationMatch = line.match(/Test Files\s+(\d+)\s+passed\s+\((\d+)\)/);
+    if (durationMatch && durationMatch[2]) {
+      duration = parseInt(durationMatch[2], 10);
+    }
+  }
+
+  return {
+    name: 'canister-tests',
+    total,
+    passed,
+    failed,
+    skipped,
+    duration,
+    tests,
+  };
+}
+
+/**
+ * Run unit tests
+ */
+export async function runUnitTests(options: TestRunnerOptions): Promise<TestSuite> {
+  const vitestArgs = [
+    'run',
+    '--reporter=verbose',
+  ];
+
+  if (options.network) {
+    vitestArgs.push(`--env.network=${options.network}`);
+  }
+
+  if (options.outputFormat === 'json') {
+    vitestArgs.push('--reporter=json');
+  }
+
+  vitestArgs.push('tests/unit');
+
+  const result = await execa('npx', ['vitest', ...vitestArgs], {
+    reject: false,
+    timeout: 120_000,
+  });
+
+  const testSuite = parseVitestOutput(result.stdout);
+
+  if (options.outputFormat === 'json') {
+    const resultsPath = getTestResultsPath(options.agentName, 'unit');
+    fs.writeFileSync(resultsPath, JSON.stringify(testSuite, null, 2), 'utf8');
+    console.log(`Test results saved to ${resultsPath}`);
+  }
+
+  return testSuite;
+}
+
+/**
+ * Run integration tests
+ */
+export async function runIntegrationTests(options: TestRunnerOptions): Promise<TestSuite> {
+  const vitestArgs = [
+    'run',
+    '--reporter=verbose',
+  ];
+
+  if (options.network) {
+    vitestArgs.push(`--env.network=${options.network}`);
+  }
+
+  if (options.outputFormat === 'json') {
+    vitestArgs.push('--reporter=json');
+  }
+
+  vitestArgs.push('tests/integration');
+
+  const result = await execa('npx', ['vitest', ...vitestArgs], {
+    reject: false,
+    timeout: 300_000,
+  });
+
+  const testSuite = parseVitestOutput(result.stdout);
+
+  if (options.outputFormat === 'json') {
+    const resultsPath = getTestResultsPath(options.agentName, 'integration');
+    fs.writeFileSync(resultsPath, JSON.stringify(testSuite, null, 2), 'utf8');
+    console.log(`Test results saved to ${resultsPath}`);
+  }
+
+  return testSuite;
+}
+
+/**
+ * Run load tests
+ */
+export async function runLoadTests(config: LoadTestConfig): Promise<LoadTestResult> {
+  const errors: Record<string, number> = {};
+  let totalRequests = 0;
+  let successfulRequests = 0;
+  let failedRequests = 0;
+  const responseTimes: number[] = [];
+  const startTime = Date.now();
+  const endTime = startTime + (config.duration * 1000);
+  const interval = config.duration * 1000 / (config.concurrency * 10);
+
+  const requestPromises: Array<Promise<{ success: boolean; responseTime: number; error?: string }>> = [];
+
+  for (let i = 0; i < config.concurrency * 10; i++) {
+    if (Date.now() >= endTime) break;
+
+    const startTimeMs = Date.now();
+
+    const request = execa('npx', ['icp', 'canister', 'call', config.canisterId, config.method, ...(config.args ? [config.args] : [])], {
+      reject: false,
+      timeout: 30_000,
+    });
+
+    const requestPromise = request.then((result) => {
+      const responseTime = Date.now() - startTimeMs;
+      if (result.exitCode === 0) {
+        return { success: true, responseTime };
+      } else {
+        const error = result.stderr || 'Unknown error';
+        errors[error] = (errors[error] || 0) + 1;
+        return { success: false, responseTime, error };
+      }
+    });
+
+    requestPromises.push(requestPromise);
+
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+
+  const results = await Promise.all(requestPromises);
+
+  for (const result of results) {
+    totalRequests++;
+    if (result.success) {
+      successfulRequests++;
+      responseTimes.push(result.responseTime);
+    } else {
+      failedRequests++;
+      if (result.error) {
+        errors[result.error] = (errors[result.error] || 0) + 1;
+      }
+    }
+  }
+
+  const actualDuration = (Date.now() - startTime) / 1000;
+  const requestsPerSecond = totalRequests / actualDuration;
+
+  const sortedTimes = responseTimes.sort((a, b) => a - b);
+  const minResponseTime = sortedTimes[0] || 0;
+  const maxResponseTime = sortedTimes[sortedTimes.length - 1] || 0;
+  const avgResponseTime = responseTimes.length > 0 
+    ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length 
+    : 0;
+
+  const percentiles = {
+    p50: sortedTimes[Math.floor(sortedTimes.length * 0.5)] || 0,
+    p90: sortedTimes[Math.floor(sortedTimes.length * 0.9)] || 0,
+    p95: sortedTimes[Math.floor(sortedTimes.length * 0.95)] || 0,
+    p99: sortedTimes[Math.floor(sortedTimes.length * 0.99)] || 0,
+  };
+
+  return {
+    totalRequests,
+    successfulRequests,
+    failedRequests,
+    requestsPerSecond,
+    avgResponseTime,
+    minResponseTime,
+    maxResponseTime,
+    percentiles,
+    errors,
+  };
+}
+
+/**
+ * Run tests based on options
+ */
+export async function runTests(options: TestRunnerOptions): Promise<TestSuite | LoadTestResult> {
+  switch (options.testType) {
+    case 'unit':
+      return runUnitTests(options);
+    case 'integration':
+      return runIntegrationTests(options);
+    case 'load-test':
+      if (!options.concurrency) {
+        throw new Error('Concurrency is required for load tests');
+      }
+      if (!options.loadDuration) {
+        throw new Error('Load duration is required for load tests');
+      }
+      throw new Error('Load test requires specific LoadTestConfig');
+    default:
+      throw new Error(`Unknown test type: ${options.testType}`);
+  }
+}

package/src/testing/types.ts

@@ -0,0 +1,104 @@
+/**
+ * Types for local test runner
+ */
+
+/** Test type */
+export type TestType = 'unit' | 'integration' | 'load-test';
+
+/** Test result status */
+export type TestStatus = 'passed' | 'failed' | 'skipped';
+
+/** Individual test case result */
+export interface TestCase {
+  /** Test name */
+  name: string;
+  /** Test status */
+  status: TestStatus;
+  /** Duration in milliseconds */
+  duration: number;
+  /** Error message if failed */
+  error?: string;
+  /** Error stack if failed */
+  stack?: string;
+}
+
+/** Test suite result */
+export interface TestSuite {
+  /** Suite name */
+  name: string;
+  /** Total number of tests */
+  total: number;
+  /** Number of passed tests */
+  passed: number;
+  /** Number of failed tests */
+  failed: number;
+  /** Number of skipped tests */
+  skipped: number;
+  /** Duration in milliseconds */
+  duration: number;
+  /** Individual test cases */
+  tests: TestCase[];
+}
+
+/** Test runner options */
+export interface TestRunnerOptions {
+  /** Agent name to test */
+  agentName: string;
+  /** Network to run tests against */
+  network: string;
+  /** Test type */
+  testType: TestType;
+  /** Enable watch mode */
+  watch?: boolean;
+  /** Load test concurrency */
+  concurrency?: number;
+  /** Load test duration in seconds */
+  loadDuration?: number;
+  /** Output format */
+  outputFormat?: 'json' | 'junit' | 'html';
+  /** Verbose output */
+  verbose?: boolean;
+}
+
+/** Load test configuration */
+export interface LoadTestConfig {
+  /** Number of concurrent requests */
+  concurrency: number;
+  /** Test duration in seconds */
+  duration: number;
+  /** Target canister ID */
+  canisterId: string;
+  /** Method to call */
+  method: string;
+  /** Request arguments (Candid format) */
+  args?: string;
+  /** Ramp-up time in seconds */
+  rampUp?: number;
+}
+
+/** Load test result */
+export interface LoadTestResult {
+  /** Total requests sent */
+  totalRequests: number;
+  /** Successful requests */
+  successfulRequests: number;
+  /** Failed requests */
+  failedRequests: number;
+  /** Requests per second */
+  requestsPerSecond: number;
+  /** Average response time in milliseconds */
+  avgResponseTime: number;
+  /** Minimum response time in milliseconds */
+  minResponseTime: number;
+  /** Maximum response time in milliseconds */
+  maxResponseTime: number;
+  /** Percentiles */
+  percentiles: {
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+  };
+  /** Error breakdown */
+  errors: Record<string, number>;
+}

package/src/wallet/cbor-serializer.ts

@@ -0,0 +1,323 @@
+/**
+ * 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';
+import type {
+  WalletData,
+  Transaction,
+  TransactionRequest,
+  SignedTransaction,
+} from './types.js';
+
+/**
+ * CBOR serializer options
+ */
+interface CborOptions {
+  /** Include diagnostic info */
+  diagnostic?: boolean;
+  /** Use indefinite-length encoding */
+  indefinite?: boolean;
+}
+
+/**
+ * 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: WalletData,
+  _options: CborOptions = {}
+): Uint8Array {
+  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: Uint8Array): WalletData {
+  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) as any;
+
+    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,
+    } as WalletData;
+  } 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: Transaction): Uint8Array {
+  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: Uint8Array): Transaction {
+  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,
+    } as Transaction;
+  } 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: TransactionRequest): Uint8Array {
+  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: Uint8Array): TransactionRequest {
+  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,
+    } as TransactionRequest;
+  } 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: SignedTransaction): Uint8Array {
+  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: Uint8Array): SignedTransaction {
+  try {
+    const decoded = cbor.decode(data);
+
+    return {
+      txHash: decoded.txHash || '',
+      signedTx: decoded.signedTx || '',
+      signature: decoded.signature,
+      request: decoded.request,
+    } as SignedTransaction;
+  } 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: Uint8Array): Uint8Array {
+  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: Uint8Array, b: Uint8Array): boolean {
+  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: Uint8Array): boolean {
+  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;
+  }
+}