@partylayer/conformance-runner 0.2.8 → 0.2.10

package/src/index.ts

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-/**
- * PartyLayer Conformance Runner CLI
- * 
- * Runs adapter conformance tests and generates reports.
- */
-
-import { program } from 'commander';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { loadAdapter } from './loader';
-import { runConformanceTests, createMockContext } from './tests';
-import { generateReport, formatReportText, type ConformanceReport } from './report';
-
-program
-  .name('partylayer-conformance')
-  .description('Run conformance tests for PartyLayer wallet adapters')
-  .version('0.1.0');
-
-program
-  .command('run')
-  .description('Run conformance tests for an adapter')
-  .requiredOption('--adapter <packageOrPath>', 'Adapter package name or path')
-  .option('--network <network>', 'Network to use', 'devnet')
-  .option('--registryUrl <url>', 'Registry URL (optional)')
-  .option('--output <path>', 'Output JSON report path', 'conformance-report.json')
-  .action(async (options) => {
-    try {
-      console.log(`Loading adapter: ${options.adapter}`);
-      const adapter = await loadAdapter(options.adapter);
-
-      console.log(`Running conformance tests for: ${adapter.name} (${adapter.walletId})`);
-      const context = createMockContext();
-      context.network = options.network as 'devnet' | 'testnet' | 'mainnet';
-
-      const startTime = Date.now();
-      const testResults = await runConformanceTests(adapter, context);
-
-      const report = generateReport(
-        {
-          walletId: adapter.walletId,
-          name: adapter.name,
-        },
-        testResults,
-        startTime
-      );
-
-      // Write JSON report
-      writeFileSync(options.output, JSON.stringify(report, null, 2));
-      console.log(`\nReport written to: ${options.output}`);
-
-      // Print human-readable summary
-      console.log('\n' + formatReportText(report));
-
-      // Exit with error code if tests failed
-      if (report.results.failed > 0) {
-        process.exit(1);
-      }
-    } catch (err) {
-      console.error('Error running conformance tests:', err);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('report')
-  .description('Format and display a conformance report')
-  .requiredOption('--input <path>', 'Input JSON report path')
-  .action((options) => {
-    try {
-      if (!existsSync(options.input)) {
-        console.error(`Report file not found: ${options.input}`);
-        process.exit(1);
-      }
-
-      const reportJson = readFileSync(options.input, 'utf-8');
-      const report = JSON.parse(reportJson) as ConformanceReport;
-
-      console.log(formatReportText(report));
-
-      if (report.results.failed > 0) {
-        process.exit(1);
-      }
-    } catch (err) {
-      console.error('Error reading report:', err);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('run-cip0103')
-  .description('Run CIP-0103 conformance tests against a Provider')
-  .option('--output <path>', 'Output JSON report path', 'cip0103-report.json')
-  .action(async (options) => {
-    try {
-      const { runCIP0103ConformanceTests, formatCIP0103Report } = await import('./cip0103-tests');
-      const { PartyLayerProvider } = await import('@partylayer/provider');
-
-      console.log('Running CIP-0103 conformance tests...');
-
-      const provider = new PartyLayerProvider();
-      const report = await runCIP0103ConformanceTests(provider);
-
-      writeFileSync(options.output, JSON.stringify(report, null, 2));
-      console.log(`\nReport written to: ${options.output}`);
-      console.log('\n' + formatCIP0103Report(report));
-
-      if (report.failed > 0) {
-        process.exit(1);
-      }
-    } catch (err) {
-      console.error('Error running CIP-0103 conformance tests:', err);
-      process.exit(1);
-    }
-  });
-
-program.parse();

package/src/loader.ts

@@ -1,78 +0,0 @@
-/**
- * Adapter Module Loader
- * 
- * Dynamically loads adapter modules (ESM/CJS safe)
- */
-
-import { createRequire } from 'module';
-import { resolve } from 'path';
-import { pathToFileURL } from 'url';
-
-import type { WalletAdapter } from '@partylayer/core';
-
-// This package builds to ESM (type: module), where the `require` global is
-// undefined — a bare `require(...)`/`require.resolve(...)` throws at runtime
-// (and would hit esbuild's `__require` shim in bundled consumers). Use a real
-// Node require created from this module's URL instead.
-const nodeRequire = createRequire(import.meta.url);
-
-/**
- * Load adapter from package or path
- */
-export async function loadAdapter(
-  packageNameOrPath: string
-): Promise<WalletAdapter> {
-  let adapterPath: string;
-
-  // Check if it's a path
-  if (packageNameOrPath.startsWith('.') || packageNameOrPath.startsWith('/')) {
-    adapterPath = resolve(packageNameOrPath);
-  } else {
-    // Try to resolve as package
-    try {
-      adapterPath = nodeRequire.resolve(packageNameOrPath);
-    } catch {
-      throw new Error(`Cannot resolve adapter: ${packageNameOrPath}`);
-    }
-  }
-
-  // Try to load as ESM first
-  try {
-    const moduleUrl = pathToFileURL(adapterPath).href;
-    const module = await import(moduleUrl);
-    
-    // Look for default export or named export
-    const adapter = module.default || module[Object.keys(module)[0]];
-    
-    if (!adapter) {
-      throw new Error('No adapter export found');
-    }
-
-    // If it's a class, instantiate it
-    if (typeof adapter === 'function') {
-      return new adapter();
-    }
-
-    return adapter as WalletAdapter;
-  } catch (err) {
-    // Fallback to CJS
-    try {
-      const module = nodeRequire(adapterPath);
-      const adapter = module.default || module[Object.keys(module)[0]];
-      
-      if (!adapter) {
-        throw new Error('No adapter export found');
-      }
-
-      if (typeof adapter === 'function') {
-        return new adapter();
-      }
-
-      return adapter as WalletAdapter;
-    } catch (cjsErr) {
-      throw new Error(
-        `Failed to load adapter: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-}

package/src/report.ts

@@ -1,107 +0,0 @@
-/**
- * Conformance Report Generation
- */
-
-import type { TestResult } from './tests';
-
-/**
- * Conformance report
- */
-export interface ConformanceReport {
-  adapter: {
-    walletId: string;
-    name: string;
-    version?: string;
-  };
-  environment: {
-    nodeVersion: string;
-    platform: string;
-    timestamp: string;
-  };
-  results: {
-    total: number;
-    passed: number;
-    failed: number;
-    duration: number;
-  };
-  tests: TestResult[];
-}
-
-/**
- * Generate conformance report
- */
-export function generateReport(
-  adapter: { walletId: string; name: string; version?: string },
-  tests: TestResult[],
-  startTime: number
-): ConformanceReport {
-  const passed = tests.filter((t) => t.passed).length;
-  const failed = tests.filter((t) => !t.passed).length;
-
-  return {
-    adapter,
-    environment: {
-      nodeVersion: process.version,
-      platform: process.platform,
-      timestamp: new Date().toISOString(),
-    },
-    results: {
-      total: tests.length,
-      passed,
-      failed,
-      duration: Date.now() - startTime,
-    },
-    tests,
-  };
-}
-
-/**
- * Format report as human-readable text
- */
-export function formatReportText(report: ConformanceReport): string {
-  const lines: string[] = [];
-
-  lines.push('='.repeat(60));
-  lines.push('PartyLayer Adapter Conformance Report');
-  lines.push('='.repeat(60));
-  lines.push('');
-  lines.push(`Adapter: ${report.adapter.name} (${report.adapter.walletId})`);
-  if (report.adapter.version) {
-    lines.push(`Version: ${report.adapter.version}`);
-  }
-  lines.push(`Environment: Node ${report.environment.nodeVersion} on ${report.environment.platform}`);
-  lines.push(`Timestamp: ${report.environment.timestamp}`);
-  lines.push('');
-  lines.push('Summary:');
-  lines.push(`  Total Tests: ${report.results.total}`);
-  lines.push(`  Passed: ${report.results.passed}`);
-  lines.push(`  Failed: ${report.results.failed}`);
-  lines.push(`  Duration: ${report.results.duration}ms`);
-  lines.push('');
-  lines.push('Test Results:');
-  lines.push('-'.repeat(60));
-
-  report.tests.forEach((test, index) => {
-    const status = test.passed ? '✓' : '✗';
-    lines.push(`${index + 1}. ${status} ${test.name}`);
-    if (test.details) {
-      Object.entries(test.details).forEach(([key, value]) => {
-        lines.push(`   ${key}: ${JSON.stringify(value)}`);
-      });
-    }
-    if (test.error) {
-      lines.push(`   Error: ${test.error}`);
-    }
-  });
-
-  lines.push('-'.repeat(60));
-  lines.push('');
-
-  if (report.results.failed === 0) {
-    lines.push('✓ All tests passed!');
-  } else {
-    lines.push(`✗ ${report.results.failed} test(s) failed`);
-  }
-
-  return lines.join('\n');
-}

package/src/tests.test.ts

@@ -1,74 +0,0 @@
-/**
- * Conformance: network-truthfulness contract.
- *
- * An adapter's connect() must surface the wallet's EFFECTIVE network in
- * session.network, not merely echo the requested ctx.network.
- */
-import { describe, it, expect } from 'vitest';
-import {
-  toWalletId,
-  toPartyId,
-  type AdapterConnectResult,
-  type AdapterContext,
-  type AdapterDetectResult,
-  type CapabilityKey,
-  type WalletAdapter,
-} from '@partylayer/core';
-import { createMockContext, checkNetworkTruthfulness } from './tests';
-
-/** Base fixture adapter; subclasses decide what session.network they report. */
-abstract class FixtureAdapter implements WalletAdapter {
-  readonly walletId = toWalletId('fixture');
-  readonly name = 'Fixture';
-  getCapabilities(): CapabilityKey[] {
-    return ['connect'];
-  }
-  async detectInstalled(): Promise<AdapterDetectResult> {
-    return { installed: true };
-  }
-  abstract connect(ctx: AdapterContext): Promise<AdapterConnectResult>;
-  async disconnect(): Promise<void> {}
-}
-
-/** WRONG: echoes the requested ctx.network — fails the contract. */
-class EchoAdapter extends FixtureAdapter {
-  async connect(ctx: AdapterContext): Promise<AdapterConnectResult> {
-    return {
-      partyId: toPartyId('party::echo'),
-      session: { walletId: this.walletId, network: ctx.network, createdAt: 0 },
-      capabilities: ['connect'],
-    };
-  }
-}
-
-/** RIGHT: reports the wallet's actual network — passes the contract. */
-class TruthfulAdapter extends FixtureAdapter {
-  constructor(private readonly walletNetwork: string) {
-    super();
-  }
-  async connect(): Promise<AdapterConnectResult> {
-    return {
-      partyId: toPartyId('party::truth'),
-      session: { walletId: this.walletId, network: this.walletNetwork, createdAt: 0 },
-      capabilities: ['connect'],
-    };
-  }
-}
-
-describe('conformance: network-truthfulness contract', () => {
-  // The wallet is on mainnet; the dApp requested devnet.
-  const ctx = (): AdapterContext => ({ ...createMockContext(), network: 'devnet' });
-  const WALLET_NETWORK = 'canton:da-mainnet';
-
-  it('FAILS an adapter that echoes ctx.network', async () => {
-    const result = await checkNetworkTruthfulness(new EchoAdapter(), ctx(), WALLET_NETWORK);
-    expect(result.passed).toBe(false);
-    expect(result.error).toMatch(/echoed context\.network/);
-  });
-
-  it('PASSES an adapter that reports the wallet network', async () => {
-    const result = await checkNetworkTruthfulness(new TruthfulAdapter(WALLET_NETWORK), ctx(), WALLET_NETWORK);
-    expect(result.passed).toBe(true);
-    expect(result.details).toMatchObject({ expected: WALLET_NETWORK, got: WALLET_NETWORK });
-  });
-});

package/src/tests.ts

@@ -1,277 +0,0 @@
-/**
- * Adapter Conformance Tests
- * 
- * Standard contract tests that all adapters must pass.
- */
-
-import type {
-  WalletAdapter,
-  AdapterContext,
-  CapabilityKey,
-  Session,
-} from '@partylayer/core';
-import {
-  CapabilityNotSupportedError,
-} from '@partylayer/core';
-
-/**
- * Test result
- */
-export interface TestResult {
-  name: string;
-  passed: boolean;
-  error?: string;
-  details?: Record<string, unknown>;
-}
-
-/**
- * Conformance test suite
- */
-export interface ConformanceSuite {
-  adapter: WalletAdapter;
-  context: AdapterContext;
-  results: TestResult[];
-}
-
-/**
- * Create mock adapter context
- */
-export function createMockContext(): AdapterContext {
-  return {
-    appName: 'Conformance Test',
-    origin: 'https://test.example.com',
-    network: 'devnet',
-    logger: {
-      debug: () => {},
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-    },
-    telemetry: undefined,
-    registry: {
-      getWallet: async () => ({}),
-    },
-    crypto: {
-      encrypt: async (data: string) => data,
-      decrypt: async (data: string) => data,
-      generateKey: async () => 'test-key',
-    },
-    storage: {
-      get: async () => null,
-      set: async () => {},
-      remove: async () => {},
-      clear: async () => {},
-    },
-    timeout: async (ms: number) => {
-      await new Promise((resolve) => setTimeout(resolve, ms));
-      throw new Error('Timeout');
-    },
-  };
-}
-
-/**
- * Run conformance tests
- */
-export async function runConformanceTests(
-  adapter: WalletAdapter,
-  context: AdapterContext
-): Promise<TestResult[]> {
-  const results: TestResult[] = [];
-
-  // Test 1: Adapter has required properties
-  results.push({
-    name: 'Adapter has walletId',
-    passed: typeof adapter.walletId === 'string' && adapter.walletId.length > 0,
-    details: { walletId: adapter.walletId },
-  });
-
-  results.push({
-    name: 'Adapter has name',
-    passed: typeof adapter.name === 'string' && adapter.name.length > 0,
-    details: { name: adapter.name },
-  });
-
-  // Test 2: getCapabilities returns valid array
-  let capabilities: CapabilityKey[];
-  try {
-    capabilities = adapter.getCapabilities();
-    results.push({
-      name: 'getCapabilities returns array',
-      passed: Array.isArray(capabilities),
-      details: { capabilities },
-    });
-
-    // Check for required capabilities
-    const hasConnect = capabilities.includes('connect');
-    results.push({
-      name: 'Capabilities include "connect"',
-      passed: hasConnect,
-      details: { capabilities },
-    });
-  } catch (err) {
-    results.push({
-      name: 'getCapabilities throws error',
-      passed: false,
-      error: err instanceof Error ? err.message : String(err),
-    });
-    return results; // Can't continue without capabilities
-  }
-
-  // Test 3: detectInstalled returns valid result
-  try {
-    const detect = await adapter.detectInstalled();
-    results.push({
-      name: 'detectInstalled returns valid result',
-      passed:
-        typeof detect === 'object' &&
-        typeof detect.installed === 'boolean' &&
-        (detect.installed || typeof detect.reason === 'string'),
-      details: { detect },
-    });
-  } catch (err) {
-    results.push({
-      name: 'detectInstalled throws error',
-      passed: false,
-      error: err instanceof Error ? err.message : String(err),
-    });
-  }
-
-  // Test 4: If detectInstalled returns false, connect should throw WalletNotInstalledError
-  // (This test requires mocking detectInstalled - skip for now or use mock adapter)
-
-  // Test 5: Capability checks
-  if (capabilities.includes('signMessage')) {
-    if (typeof adapter.signMessage !== 'function') {
-      results.push({
-        name: 'signMessage capability declared but method missing',
-        passed: false,
-        error: 'signMessage capability declared but method not implemented',
-      });
-    }
-  } else {
-    // If signMessage not in capabilities, calling it should throw CapabilityNotSupportedError
-    if (typeof adapter.signMessage === 'function') {
-      try {
-        await adapter.signMessage(context, {} as unknown as Session, { message: 'test' });
-        results.push({
-          name: 'signMessage throws CapabilityNotSupportedError when not supported',
-          passed: false,
-          error: 'signMessage did not throw error',
-        });
-      } catch (err) {
-        const passed = err instanceof CapabilityNotSupportedError;
-        results.push({
-          name: 'signMessage throws CapabilityNotSupportedError when not supported',
-          passed,
-          error: passed ? undefined : err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-  }
-
-  // Similar tests for signTransaction and submitTransaction
-  if (capabilities.includes('signTransaction')) {
-    if (typeof adapter.signTransaction !== 'function') {
-      results.push({
-        name: 'signTransaction capability declared but method missing',
-        passed: false,
-        error: 'signTransaction capability declared but method not implemented',
-      });
-    }
-  }
-
-  if (capabilities.includes('submitTransaction')) {
-    if (typeof adapter.submitTransaction !== 'function') {
-      results.push({
-        name: 'submitTransaction capability declared but method missing',
-        passed: false,
-        error: 'submitTransaction capability declared but method not implemented',
-      });
-    }
-  }
-
-  // Test 5b: restore capability <-> method symmetry.
-  //
-  // We had a real bug where 3 of 5 adapters implemented restore() but did
-  // not declare the 'restore' capability in getCapabilities(). The SDK
-  // checks method presence at runtime so session persistence still worked,
-  // but `wallet.capabilities.includes('restore')` returned false, which
-  // misleads docs consumers and anyone programmatically inspecting caps.
-  //
-  // Enforce both directions:
-  //   - declared-but-missing: capability listed, no method → broken promise
-  //   - implemented-but-undeclared: method exists, capability missing →
-  //     silent drift that hides a feature from consumers
-  {
-    const hasRestoreMethod = typeof adapter.restore === 'function';
-    const declaresRestore = capabilities.includes('restore');
-    if (declaresRestore && !hasRestoreMethod) {
-      results.push({
-        name: 'restore capability declared but method missing',
-        passed: false,
-        error: `${adapter.name}: declares 'restore' capability but does not implement restore()`,
-      });
-    } else if (hasRestoreMethod && !declaresRestore) {
-      results.push({
-        name: 'restore method implemented but capability not declared',
-        passed: false,
-        error:
-          `${adapter.name}: implements restore() but getCapabilities() does not include 'restore'. ` +
-          `Add 'restore' to the returned array so consumers can discover the feature.`,
-      });
-    } else {
-      results.push({
-        name: 'restore capability / method symmetry',
-        passed: true,
-        details: { hasRestoreMethod, declaresRestore },
-      });
-    }
-  }
-
-  // Test 6: Error mapping
-  // Verify adapter uses mapUnknownErrorToPartyLayerError
-  // (This is a code inspection test - hard to test at runtime)
-
-  return results;
-}
-
-/**
- * Network-truthfulness contract.
- *
- * An adapter's `connect()` MUST surface the wallet's EFFECTIVE network in
- * `session.network` (so the SDK can detect a wallet/dApp network mismatch) —
- * not merely echo the requested `context.network`.
- *
- * Drive it with a context whose `.network` differs from the network the wallet
- * actually reports (`walletReportedNetwork`); a compliant adapter returns
- * `session.network === walletReportedNetwork`. An adapter that echoes
- * `context.network` fails the contract.
- *
- * Adapters that genuinely cannot read the wallet's network must NOT claim to
- * (leave `session.network = context.network`) and must be recorded as
- * "network-reported: no" in the support matrix — they are out of scope for this
- * contract rather than silently passing it.
- */
-export async function checkNetworkTruthfulness(
-  adapter: WalletAdapter,
-  context: AdapterContext,
-  walletReportedNetwork: string,
-): Promise<TestResult> {
-  const name = 'connect() session.network is the wallet effective network';
-  try {
-    const result = await adapter.connect(context);
-    const got = result.session.network;
-    const passed = got === walletReportedNetwork;
-    return {
-      name,
-      passed,
-      error: passed
-        ? undefined
-        : `expected session.network='${walletReportedNetwork}' (wallet-reported), got '${String(got)}'` +
-          (got === context.network ? ' — merely echoed context.network' : ''),
-      details: { expected: walletReportedNetwork, got, ctxNetwork: context.network },
-    };
-  } catch (err) {
-    return { name, passed: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}

package/tsconfig.esm.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "ESNext",
-    "outDir": "./dist",
-    "declaration": false,
-    "declarationMap": false,
-    "composite": false
-  }
-}