@layerzerolabs/common-canton 0.2.78

package/test/mocks/mock-fetch.ts

@@ -0,0 +1,282 @@
+/**
+ * Mock fetch implementation that replays captured API interactions.
+ *
+ * Usage:
+ *   import { createMockFetch, loadCapturedInteractions } from './mock-fetch';
+ *
+ *   const interactions = loadCapturedInteractions('internal');
+ *   const mockFetch = createMockFetch(interactions);
+ *
+ *   const config = new Configuration({
+ *     basePath: 'http://mock',
+ *     fetchApi: mockFetch,
+ *   });
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface CapturedInteraction {
+    name: string;
+    scenario?: string;
+    timestamp: string;
+    request: {
+        method: string;
+        url: string;
+        path: string;
+        headers: Record<string, string>;
+        body: unknown;
+    };
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: unknown;
+    };
+}
+
+export type InteractionMatcher = (
+    request: { method: string; path: string; body: unknown },
+    interaction: CapturedInteraction,
+) => boolean;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Load Captured Interactions
+// ─────────────────────────────────────────────────────────────────────────────
+
+const CAPTURE_FILES = {
+    internal: 'captured-internal-requests.json',
+    external: 'captured-external-requests.json',
+    unhappy: 'captured-unhappy-paths.json',
+    disclosure: 'captured-disclosure.json',
+};
+
+export function loadCapturedInteractions(
+    type: keyof typeof CAPTURE_FILES | 'all',
+): CapturedInteraction[] {
+    const mocksDir = path.dirname(new URL(import.meta.url).pathname);
+
+    if (type === 'all') {
+        const all: CapturedInteraction[] = [];
+        for (const file of Object.values(CAPTURE_FILES)) {
+            const filePath = path.join(mocksDir, file);
+            if (fs.existsSync(filePath)) {
+                const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                all.push(...data);
+            }
+        }
+        return all;
+    }
+
+    const filePath = path.join(mocksDir, CAPTURE_FILES[type]);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Captured interactions file not found: ${filePath}`);
+    }
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Default Matcher
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Default matcher: matches by method and path.
+ * For more specific matching, provide a custom matcher.
+ */
+export const defaultMatcher: InteractionMatcher = (request, interaction) => {
+    return (
+        request.method === interaction.request.method && request.path === interaction.request.path
+    );
+};
+
+/**
+ * Strict matcher: matches by method, path, and request body structure.
+ */
+export const strictMatcher: InteractionMatcher = (request, interaction) => {
+    if (request.method !== interaction.request.method) return false;
+    if (request.path !== interaction.request.path) return false;
+
+    // For POST requests, compare body structure (ignoring dynamic values)
+    if (request.method === 'POST' && request.body && interaction.request.body) {
+        const reqKeys = Object.keys(request.body as object).sort();
+        const intKeys = Object.keys(interaction.request.body as object).sort();
+        if (JSON.stringify(reqKeys) !== JSON.stringify(intKeys)) return false;
+    }
+
+    return true;
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Mock Fetch Factory
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface MockFetchOptions {
+    /** Custom matcher function */
+    matcher?: InteractionMatcher;
+    /** If true, throw on unmatched requests instead of returning 404 */
+    strict?: boolean;
+    /** Called for each matched request */
+    onMatch?: (interaction: CapturedInteraction) => void;
+    /** Called for unmatched requests */
+    onMiss?: (request: { method: string; path: string; body: unknown }) => void;
+}
+
+export function createMockFetch(
+    interactions: CapturedInteraction[],
+    options: MockFetchOptions = {},
+): typeof fetch {
+    const { matcher = defaultMatcher, strict = false, onMatch, onMiss } = options;
+
+    // Track which interactions have been used (for sequential matching)
+    const usedIndices = new Set<number>();
+
+    return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+        const url = typeof input === 'string' ? input : input.toString();
+        const method = init?.method ?? 'GET';
+        const urlPath = new URL(url, 'http://mock').pathname;
+
+        // Parse request body
+        let requestBody: unknown = null;
+        if (init?.body) {
+            try {
+                requestBody = JSON.parse(init.body as string);
+            } catch {
+                requestBody = init.body;
+            }
+        }
+
+        const request = { method, path: urlPath, body: requestBody };
+
+        // Find matching interaction (prefer unused ones for sequential flows)
+        let matchIndex = -1;
+        for (let i = 0; i < interactions.length; i++) {
+            const interaction = interactions[i];
+            if (interaction && !usedIndices.has(i) && matcher(request, interaction)) {
+                matchIndex = i;
+                break;
+            }
+        }
+
+        // If no unused match, try any match (for repeated requests)
+        if (matchIndex === -1) {
+            matchIndex = interactions.findIndex((int) => matcher(request, int));
+        }
+
+        if (matchIndex === -1) {
+            onMiss?.(request);
+
+            if (strict) {
+                throw new Error(
+                    `MockFetch: No matching interaction for ${method} ${urlPath}\n` +
+                        `Body: ${JSON.stringify(requestBody, null, 2)}`,
+                );
+            }
+
+            // Return 404 for unmatched requests
+            return new Response(JSON.stringify({ error: 'Not found in mock data' }), {
+                status: 404,
+                statusText: 'Not Found',
+                headers: { 'content-type': 'application/json' },
+            });
+        }
+
+        const interaction = interactions[matchIndex]!;
+        usedIndices.add(matchIndex);
+        onMatch?.(interaction);
+
+        // Build response
+        const responseHeaders = new Headers();
+        for (const [key, value] of Object.entries(interaction.response.headers)) {
+            responseHeaders.set(key, value);
+        }
+
+        const responseBody =
+            typeof interaction.response.body === 'string'
+                ? interaction.response.body
+                : JSON.stringify(interaction.response.body);
+
+        return new Response(responseBody, {
+            status: interaction.response.status,
+            statusText: interaction.response.statusText,
+            headers: responseHeaders,
+        });
+    };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Sequence-Based Mock (for testing specific flows)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Creates a mock that returns interactions in sequence, ignoring request matching.
+ * Useful for testing a specific flow where you know the exact order of requests.
+ */
+export function createSequentialMock(interactions: CapturedInteraction[]): typeof fetch {
+    let index = 0;
+
+    return async (_input: RequestInfo | URL, _init?: RequestInit): Promise<Response> => {
+        if (index >= interactions.length) {
+            throw new Error(`MockFetch: Ran out of captured interactions at index ${index}`);
+        }
+
+        const interaction = interactions[index++]!;
+
+        const responseHeaders = new Headers();
+        for (const [key, value] of Object.entries(interaction.response.headers)) {
+            responseHeaders.set(key, value);
+        }
+
+        const responseBody =
+            typeof interaction.response.body === 'string'
+                ? interaction.response.body
+                : JSON.stringify(interaction.response.body);
+
+        return new Response(responseBody, {
+            status: interaction.response.status,
+            statusText: interaction.response.statusText,
+            headers: responseHeaders,
+        });
+    };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Filter Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Filter interactions by operation name prefix.
+ */
+export function filterByOperation(
+    interactions: CapturedInteraction[],
+    prefix: string,
+): CapturedInteraction[] {
+    return interactions.filter((i) => i.name.startsWith(prefix));
+}
+
+/**
+ * Filter interactions by scenario name.
+ */
+export function filterByScenario(
+    interactions: CapturedInteraction[],
+    scenario: string,
+): CapturedInteraction[] {
+    return interactions.filter((i) => i.scenario === scenario);
+}
+
+/**
+ * Filter only successful responses (2xx status).
+ */
+export function filterSuccessful(interactions: CapturedInteraction[]): CapturedInteraction[] {
+    return interactions.filter((i) => i.response.status >= 200 && i.response.status < 300);
+}
+
+/**
+ * Filter only error responses (4xx, 5xx status).
+ */
+export function filterErrors(interactions: CapturedInteraction[]): CapturedInteraction[] {
+    return interactions.filter((i) => i.response.status >= 400);
+}

package/test/mocks/scripts/capture-disclosure.ts

@@ -0,0 +1,249 @@
+#!/usr/bin/env tsx
+/// <reference types="node" />
+/**
+ * Captures disclosure flow using SecretBox contract.
+ *
+ * Scenario:
+ * 1. Alice creates a SecretBox with Bob as the "opener"
+ * 2. Bob is NOT an observer - he can't see the contract normally
+ * 3. Alice creates disclosure and shares it with Bob
+ * 4. Bob uses disclosure to exercise OpenBox choice (flexible controller)
+ *
+ * Usage:
+ *   tsx test/mocks/scripts/capture-disclosure.ts
+ *
+ * Output:
+ *   test/mocks/captured-disclosure.json
+ */
+
+import type { ContractId } from '@daml/types';
+import * as path from 'path';
+
+import { MnemonicSignerAdapter } from '../../../../signer-adapter/src/mnemonicSignerAdapter.js';
+import { SignatureFormat, SignatureType } from '../../../../signer-adapter/src/model.js';
+import { CantonClient } from '../../../src/client/index.js';
+// Import test contracts
+import { packageId as testPackageId } from '../../../src/daml/sdk-test-0.0.1/lib/index.js';
+import { SecretBox } from '../../../src/daml/sdk-test-0.0.1/lib/SdkTest/module.js';
+import { Configuration } from '../../../src/open-api/runtime.js';
+import { CantonSdk } from '../../../src/sdk/index.js';
+import type { ExternalSignature } from '../../../src/types.js';
+import {
+    CANTON_URL,
+    type CapturedInteraction,
+    createCapturingFetch,
+    createOperationContext,
+    EXTERNAL_PARTY_DERIVATION_PATH,
+    EXTERNAL_PARTY_ID,
+    EXTERNAL_PARTY_JWT_TOKEN,
+    EXTERNAL_PARTY_KEY_FINGERPRINT,
+    EXTERNAL_PARTY_MNEMONIC,
+    EXTERNAL_PARTY_USER_ID,
+    INTERNAL_PARTY_ID,
+    INTERNAL_PARTY_JWT_TOKEN,
+    INTERNAL_PARTY_USER_ID,
+    printEndpointSummary,
+    saveInteractions,
+} from './capture-utils.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Signing Helper (for Bob - external party)
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function signTransaction(hash: string, party: string): Promise<ExternalSignature> {
+    const signer = new MnemonicSignerAdapter({
+        mnemonicConfig: {
+            getMnemonic: async () => ({
+                mnemonic: EXTERNAL_PARTY_MNEMONIC,
+                path: EXTERNAL_PARTY_DERIVATION_PATH,
+            }),
+        },
+    });
+    const hashBytes = Uint8Array.from(Buffer.from(hash, 'base64'));
+    const { createHash } = await import('crypto');
+    const messageHash = createHash('sha256').update(hashBytes).digest();
+
+    const derSignature = await signer.sign({
+        data: messageHash,
+        signatureType: SignatureType.ECDSA,
+        format: SignatureFormat.DER,
+    });
+
+    return {
+        party,
+        signature: Buffer.from(derSignature).toString('base64'),
+        signedBy: EXTERNAL_PARTY_KEY_FINGERPRINT,
+        format: 'SIGNATURE_FORMAT_DER',
+        signingAlgorithmSpec: 'SIGNING_ALGORITHM_SPEC_EC_DSA_SHA_256',
+    };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Disclosure Flow
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function captureDisclosureFlow(
+    aliceSdk: CantonSdk,
+    bobSdk: CantonSdk,
+    setOperation: (name: string) => void,
+): Promise<void> {
+    // 1. Alice creates a SecretBox with Bob as opener
+    //    Bob is NOT an observer - he can't see this contract!
+    setOperation('alice_create_secret_box');
+    console.log('1. Alice creates SecretBox with Bob as opener...');
+
+    const createCmd = aliceSdk.buildCreate(
+        SecretBox as any,
+        {
+            owner: INTERNAL_PARTY_ID,
+            opener: EXTERNAL_PARTY_ID, // Bob can open it...
+            secret: 'test-secret-not-a-real-secret-just-testing',
+            isOpen: false,
+        },
+        testPackageId,
+    );
+
+    const createResult = await aliceSdk.submit({ actAs: [INTERNAL_PARTY_ID] }, [createCmd]);
+    const createWait = await aliceSdk.waitForCommand(createResult.commandId, {
+        parties: [INTERNAL_PARTY_ID],
+        beginExclusive: createResult.completionOffset,
+        timeoutMs: 60_000,
+    });
+    if (createWait.status !== 'accepted') throw new Error(`Create failed: ${createWait.status}`);
+
+    const createUpdate = await aliceSdk.fetchTransaction(createWait.updateId, [INTERNAL_PARTY_ID]);
+    const createdEventWrapper = (createUpdate.events ?? []).find((e) => 'CreatedEvent' in e);
+    if (!createdEventWrapper || !('CreatedEvent' in createdEventWrapper))
+        throw new Error('No contract created');
+
+    const secretBoxId = createdEventWrapper.CreatedEvent.contractId;
+    console.log(`   Created: ${secretBoxId.slice(0, 20)}...`);
+    console.log(`   Bob is opener but NOT observer - he needs disclosure!`);
+
+    // 2. Alice creates disclosure of the SecretBox for Bob
+    setOperation('alice_create_disclosure');
+    console.log('2. Alice creates disclosure...');
+
+    const disclosure = await aliceSdk.createDisclosure(
+        secretBoxId as ContractId<typeof SecretBox>,
+        [INTERNAL_PARTY_ID],
+    );
+    if (!disclosure) throw new Error('Failed to create disclosure');
+
+    console.log(`   Disclosure created`);
+    console.log(`   Template: ${disclosure.templateId}`);
+    console.log(`   Blob: ${disclosure.createdEventBlob.slice(0, 40)}...`);
+
+    // 3. Bob exercises OpenBox WITH disclosure
+    //    Without disclosure, Bob can't see the contract and would get an error
+    setOperation('bob_prepare_open_box');
+    console.log('3. Bob exercises OpenBox with disclosure (signed)...');
+
+    const exerciseCmd = bobSdk.buildExercise(
+        SecretBox.OpenBox,
+        secretBoxId as ContractId<typeof SecretBox>,
+        {},
+        testPackageId,
+    );
+
+    // Prepare with disclosure - Bob can now see Alice's SecretBox
+    const prepared = await bobSdk.prepareForSigning(
+        { actAs: [EXTERNAL_PARTY_ID] },
+        [exerciseCmd],
+        { disclosedContracts: [disclosure] }, // <-- Disclosure required!
+    );
+
+    setOperation('bob_submit_open_box');
+    const signature = await signTransaction(prepared.preparedTransactionHash, EXTERNAL_PARTY_ID);
+    const exerciseResult = await bobSdk.submitSigned(prepared, [signature]);
+
+    setOperation('bob_wait_open_box');
+    const exerciseWait = await bobSdk.waitForCommand(exerciseResult.commandId, {
+        parties: [EXTERNAL_PARTY_ID],
+        beginExclusive: exerciseResult.completionOffset,
+        timeoutMs: 60_000,
+    });
+
+    if (exerciseWait.status !== 'accepted') {
+        throw new Error(`OpenBox failed: ${JSON.stringify(exerciseWait)}`);
+    }
+
+    setOperation('bob_fetch_result');
+    const exerciseUpdate = await bobSdk.fetchTransaction(exerciseWait.updateId, [
+        EXTERNAL_PARTY_ID,
+    ]);
+    const openedBoxWrapper = (exerciseUpdate.events ?? []).find((e) => 'CreatedEvent' in e);
+    const openedBox =
+        openedBoxWrapper && 'CreatedEvent' in openedBoxWrapper
+            ? openedBoxWrapper.CreatedEvent
+            : null;
+    console.log(`   Box opened! New contract: ${openedBox?.contractId?.slice(0, 20)}...`);
+
+    // 4. Verify the box is now open
+    setOperation('alice_verify_opened');
+    console.log('4. Alice verifies the box is open...');
+
+    const verifyContract = await aliceSdk.get(
+        openedBox!.contractId as ContractId<typeof SecretBox>,
+        [INTERNAL_PARTY_ID],
+    );
+    const isOpen = (verifyContract?.payload as any)?.isOpen;
+    console.log(`   isOpen: ${isOpen}`);
+
+    if (isOpen) {
+        console.log("   ✓ Disclosure flow complete! Bob opened Alice's box.");
+    } else {
+        throw new Error('Box should be open!');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Main
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function main() {
+    console.log('Capturing disclosure flow: SecretBox\n');
+    console.log('Scenario: Alice creates box, Bob is opener but NOT observer.');
+    console.log('Bob needs disclosure to see and exercise the contract.\n');
+
+    const captured: CapturedInteraction[] = [];
+    const { setOperation, getOperation } = createOperationContext();
+
+    // Alice (internal party) - owner of the SecretBox
+    const aliceConfig = new Configuration({
+        basePath: CANTON_URL,
+        fetchApi: createCapturingFetch({ captured, getOperation }),
+        headers: { Authorization: `Bearer ${INTERNAL_PARTY_JWT_TOKEN}` },
+    });
+    const aliceClient = new CantonClient(aliceConfig, INTERNAL_PARTY_USER_ID);
+    const aliceSdk = new CantonSdk(aliceClient);
+
+    // Bob (external party) - opener, needs disclosure
+    const bobConfig = new Configuration({
+        basePath: CANTON_URL,
+        fetchApi: createCapturingFetch({ captured, getOperation }),
+        headers: { Authorization: `Bearer ${EXTERNAL_PARTY_JWT_TOKEN}` },
+    });
+    const bobClient = new CantonClient(bobConfig, EXTERNAL_PARTY_USER_ID);
+    const bobSdk = new CantonSdk(bobClient);
+
+    await captureDisclosureFlow(aliceSdk, bobSdk, setOperation);
+
+    const outputFile = path.join(import.meta.dirname, '..', 'captured-disclosure.json');
+    saveInteractions(outputFile, captured);
+    printEndpointSummary(captured);
+}
+
+main().catch(async (err) => {
+    console.error('Error:', err.message);
+    if (err.response && typeof err.response.text === 'function') {
+        try {
+            const body = await err.response.text();
+            console.error('Response body:', body);
+        } catch {
+            /* ignore */
+        }
+    }
+    console.error(err.stack);
+    process.exit(1);
+});