@layerzerolabs/common-canton 1.2.68 → 1.2.70

package/test/sdk.test.ts

@@ -1,794 +0,0 @@
-/**
- * SDK Tests - E2E style replay of captured interactions
- *
- * These tests replay the exact same flow as the capture scripts, using mocked
- * API responses. This validates that the SDK correctly handles real Canton
- * API responses.
- */
-
-import { beforeAll, describe, expect, it } from 'vitest';
-
-import { CantonClient, type CantonEvent } from '../src/client';
-import { Configuration } from '../src/open-api/runtime';
-import { CantonSdk } from '../src/sdk';
-import {
-    type CapturedInteraction,
-    createMockFetch,
-    loadCapturedInteractions as loadMockInteractions,
-} from './mocks/mock-fetch';
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Test Constants (same as capture scripts)
-// ─────────────────────────────────────────────────────────────────────────────
-
-const INTERNAL_PARTY_USER_ID = 'alice-user';
-const INTERNAL_PARTY_ID =
-    'alice::1220663000baaabef30c3fa7cfe8f1b29f0a40fa1643992ba4ba98a01973930eed5b';
-
-const EXTERNAL_PARTY_USER_ID = 'bob-user';
-const EXTERNAL_PARTY_ID =
-    'bob::1220fdaff77883ac51fb7365d1ea8d2846de018e4b0f964f9f3e46ce5d9b3abab863';
-
-// Package ID from captured data (extracted from templateId in requests)
-const SDK_TEST_PACKAGE_ID = 'b159a250ebaae7fac7068d67b43a3e94e50c5f2545ab7cd955c32d00eab2ce60';
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Test Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-
-function loadCapturedInteractions(
-    type: 'internal' | 'external' | 'unhappy',
-): CapturedInteraction[] {
-    return loadMockInteractions(type);
-}
-
-function createSdk(interactions: CapturedInteraction[], userId: string, strict = true): CantonSdk {
-    const mockFetch = createMockFetch(interactions, {
-        strict,
-        onMiss: (req) => {
-            console.error(`Mock miss: ${req.method} ${req.path}`);
-        },
-    });
-    const config = new Configuration({
-        basePath: 'http://mock',
-        fetchApi: mockFetch,
-    });
-    return new CantonSdk(new CantonClient(config, userId));
-}
-
-function findInteraction(
-    interactions: CapturedInteraction[],
-    namePattern: string,
-): CapturedInteraction {
-    const found = interactions.find((i) => i.name.includes(namePattern));
-    if (!found) throw new Error(`Interaction not found: ${namePattern}`);
-    return found;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Internal Party Flow Tests
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('Internal Party Flow (E2E Replay)', () => {
-    let captured: CapturedInteraction[];
-
-    beforeAll(() => {
-        captured = loadCapturedInteractions('internal');
-    });
-
-    describe('connectedSynchronizers', () => {
-        it('should return list of synchronizers from API response', async () => {
-            const interaction = findInteraction(captured, 'list_synchronizers__get_synchronizers');
-            const sdk = createSdk([interaction], INTERNAL_PARTY_USER_ID);
-
-            const synchronizers = await sdk.connectedSynchronizers();
-
-            // Assert structure
-            expect(synchronizers).toBeInstanceOf(Array);
-            expect(synchronizers.length).toBeGreaterThan(0);
-
-            // Assert exact value from captured response
-            const expectedBody = interaction.response.body as {
-                connectedSynchronizers: Array<{ synchronizerId: string }>;
-            };
-            expect(synchronizers[0]).toBe(expectedBody.connectedSynchronizers[0]!.synchronizerId);
-            expect(synchronizers[0]).toMatch(/^sync::/);
-        });
-    });
-
-    describe('submit (create contract)', () => {
-        it('should submit command with correct parameters and return commandId', async () => {
-            // The submit flow requires: get_synchronizers, get_ledger_end, submit_command
-            const syncInteraction = captured.find(
-                (i) => i.name === 'create_contract__get_synchronizers',
-            );
-            const ledgerEndInteraction = captured.find(
-                (i) => i.name === 'create_contract__get_ledger_end',
-            );
-            const submitInteraction = captured.find(
-                (i) => i.name === 'create_contract__submit_command',
-            );
-
-            if (!syncInteraction || !ledgerEndInteraction || !submitInteraction) {
-                throw new Error('Missing required interactions for submit test');
-            }
-
-            const sdk = createSdk(
-                [syncInteraction, ledgerEndInteraction, submitInteraction],
-                INTERNAL_PARTY_USER_ID,
-            );
-
-            // Use the EXACT same input as capture script
-            const payload = {
-                owner: INTERNAL_PARTY_ID,
-                value: '100',
-                description: 'Test asset for internal party flow',
-            };
-
-            // Build command manually (matching what buildCreate produces)
-            const command = {
-                createCommand: {
-                    templateId: `${SDK_TEST_PACKAGE_ID}:SdkTest:SimpleAsset`,
-                    createArguments: payload,
-                },
-            };
-
-            const result = await sdk.submit({ actAs: [INTERNAL_PARTY_ID] }, [command]);
-
-            // Assert result structure
-            expect(result).toBeDefined();
-            expect(result).toHaveProperty('commandId');
-            expect(result).toHaveProperty('completionOffset');
-
-            // Assert types
-            expect(typeof result.commandId).toBe('string');
-            expect(typeof result.completionOffset).toBe('number');
-
-            // commandId should be a valid UUID format
-            expect(result.commandId).toMatch(
-                /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-            );
-        });
-    });
-
-    describe('waitForCommand', () => {
-        it('should parse completion response and return accepted status', async () => {
-            // waitForCommand expects streaming JSONL response (array of completion items)
-            // The captured response is already an array
-            const waitInteraction = findInteraction(captured, 'wait_create__wait_completion');
-            const responseBody = waitInteraction.response.body as Array<{
-                completionResponse?: {
-                    Completion?: { value: { commandId: string; updateId: string; offset: number } };
-                };
-            }>;
-
-            // Find the completion item in the response
-            const completionItem = responseBody.find(
-                (item) => item.completionResponse?.Completion?.value?.updateId,
-            );
-            expect(completionItem).toBeDefined();
-
-            // Extract values from captured response
-            const completion = completionItem!.completionResponse!.Completion!.value;
-            expect(completion.commandId).toBeDefined();
-            expect(completion.updateId).toBeDefined();
-            expect(completion.updateId.length).toBeGreaterThan(0);
-
-            // The actual SDK parses this - we're just verifying the captured data structure
-            // Full integration tested in the flow test
-        });
-    });
-
-    describe('fetchTransaction', () => {
-        it('should return update with events containing created contract', async () => {
-            const fetchInteraction = findInteraction(
-                captured,
-                'fetch_created_contract_id__fetch_update',
-            );
-            const sdk = createSdk([fetchInteraction], INTERNAL_PARTY_USER_ID);
-
-            // Extract updateId from captured request
-            const requestBody = fetchInteraction.request.body as { updateId: string };
-
-            const result = await sdk.fetchTransaction(requestBody.updateId, [INTERNAL_PARTY_ID]);
-
-            // Assert structure
-            expect(result).toHaveProperty('updateId');
-            expect(result).toHaveProperty('offset');
-            expect(result).toHaveProperty('events');
-            expect(Array.isArray(result.events)).toBe(true);
-
-            const events = result.events!;
-
-            // Assert we have at least one event
-            expect(events.length).toBeGreaterThan(0);
-
-            // Find the created event (events have structure { CreatedEvent: ... })
-            const createdEventWrapper = events.find((e: CantonEvent) => 'CreatedEvent' in e);
-            expect(createdEventWrapper).toBeDefined();
-
-            // Assert created event structure
-            if (createdEventWrapper && 'CreatedEvent' in createdEventWrapper) {
-                const createdEvent = createdEventWrapper.CreatedEvent;
-                expect(createdEvent).toHaveProperty('contractId');
-                expect(createdEvent).toHaveProperty('templateId');
-                expect(createdEvent).toHaveProperty('createArgument');
-
-                // Contract ID should be a long hex string
-                expect(typeof createdEvent.contractId).toBe('string');
-                expect(createdEvent.contractId!.length).toBeGreaterThan(50);
-
-                // Template ID should contain our package
-                expect(createdEvent.templateId).toContain('SdkTest:SimpleAsset');
-
-                // Payload should contain our data
-                expect(createdEvent.createArgument).toHaveProperty('owner');
-                expect((createdEvent.createArgument as { owner: string }).owner).toBe(
-                    INTERNAL_PARTY_ID,
-                );
-            }
-        });
-    });
-
-    describe('get (query contract)', () => {
-        it('should return contract by ID with full payload', async () => {
-            const queryInteraction = findInteraction(captured, 'query_contract__get_contract');
-            const sdk = createSdk([queryInteraction], INTERNAL_PARTY_USER_ID);
-
-            // Extract contractId from captured request
-            const requestBody = queryInteraction.request.body as { contractId: string };
-
-            const result = await sdk.get(requestBody.contractId as any, [INTERNAL_PARTY_ID]);
-
-            // Assert contract was found
-            expect(result).not.toBeNull();
-
-            if (result) {
-                // Assert structure
-                expect(result).toHaveProperty('contractId');
-                expect(result).toHaveProperty('templateId');
-                expect(result).toHaveProperty('payload');
-
-                // Assert values match what was queried
-                expect(result.contractId).toBe(requestBody.contractId);
-
-                // Assert payload structure
-                const payload = result.payload as {
-                    owner: string;
-                    value: string;
-                    description: string;
-                };
-                expect(payload.owner).toBe(INTERNAL_PARTY_ID);
-                expect(payload.value).toBe('100');
-                expect(payload.description).toBe('Test asset for internal party flow');
-            }
-        });
-
-        it('should return null or undefined for archived contract', async () => {
-            const verifyInteraction = findInteraction(captured, 'verify_archived__get_contract');
-            const sdk = createSdk([verifyInteraction], INTERNAL_PARTY_USER_ID);
-
-            const requestBody = verifyInteraction.request.body as { contractId: string };
-
-            const result = await sdk.get(requestBody.contractId as any, [INTERNAL_PARTY_ID]);
-
-            // Archived contract should return null or undefined (no active contract)
-            // Check the captured response to know what to expect
-            const responseBody = verifyInteraction.response.body as {
-                created?: unknown;
-                archived?: unknown;
-            };
-
-            if (responseBody.archived || !responseBody.created) {
-                // If archived field is present or created is missing, contract is archived
-                expect(result).toBeFalsy(); // null or undefined
-            }
-        });
-    });
-
-    describe('Full Create-Submit Flow with Value Assertions', () => {
-        it('should return synchronizers matching captured response', async () => {
-            const syncInteraction = findInteraction(
-                captured,
-                'list_synchronizers__get_synchronizers',
-            );
-            const sdk = createSdk([syncInteraction], INTERNAL_PARTY_USER_ID);
-
-            // Call SDK
-            const synchronizers = await sdk.connectedSynchronizers();
-
-            // Assert SDK output matches captured response
-            const expectedSync = (
-                syncInteraction.response.body as {
-                    connectedSynchronizers: Array<{ synchronizerId: string }>;
-                }
-            ).connectedSynchronizers[0]!.synchronizerId;
-            expect(synchronizers[0]).toBe(expectedSync);
-        });
-
-        it('should submit command and return offset from captured response', async () => {
-            const flowInteractions = [
-                findInteraction(captured, 'create_contract__get_synchronizers'),
-                findInteraction(captured, 'create_contract__get_ledger_end'),
-                findInteraction(captured, 'create_contract__submit_command'),
-            ];
-
-            const sdk = createSdk(flowInteractions, INTERNAL_PARTY_USER_ID);
-
-            // Same input as capture script
-            const createCommand = {
-                createCommand: {
-                    templateId: `${SDK_TEST_PACKAGE_ID}:SdkTest:SimpleAsset`,
-                    createArguments: {
-                        owner: INTERNAL_PARTY_ID,
-                        value: '100',
-                        description: 'Test asset for internal party flow',
-                    },
-                },
-            };
-
-            const submitResult = await sdk.submit({ actAs: [INTERNAL_PARTY_ID] }, [createCommand]);
-
-            // Assert SDK output matches captured response
-            const ledgerEndResponse = findInteraction(captured, 'create_contract__get_ledger_end')
-                .response.body as { offset: number };
-            expect(submitResult.completionOffset).toBe(ledgerEndResponse.offset);
-
-            // commandId should be a valid UUID
-            expect(submitResult.commandId).toMatch(/^[0-9a-f-]{36}$/);
-        });
-
-        it('should fetch update and return events matching captured response', async () => {
-            const fetchInteraction = findInteraction(
-                captured,
-                'fetch_created_contract_id__fetch_update',
-            );
-            const sdk = createSdk([fetchInteraction], INTERNAL_PARTY_USER_ID);
-
-            // Get updateId from captured request
-            const requestBody = fetchInteraction.request.body as { updateId: string };
-
-            const update = await sdk.fetchTransaction(requestBody.updateId, [INTERNAL_PARTY_ID]);
-
-            // Assert SDK output matches captured response
-            const responseBody = fetchInteraction.response.body as {
-                update: {
-                    Transaction: {
-                        value: {
-                            updateId: string;
-                            offset: number;
-                            events: Array<{
-                                CreatedEvent?: {
-                                    contractId: string;
-                                    templateId: string;
-                                    createArgument: {
-                                        owner: string;
-                                        value: string;
-                                        description: string;
-                                    };
-                                };
-                            }>;
-                        };
-                    };
-                };
-            };
-            const expectedTx = responseBody.update.Transaction.value;
-
-            expect(update.updateId).toBe(expectedTx.updateId);
-            expect(update.offset).toBe(expectedTx.offset);
-
-            const events = update.events!;
-            expect(events.length).toBe(expectedTx.events.length);
-
-            // Verify created event (SDK returns { CreatedEvent: ... } structure)
-            const sdkCreatedWrapper = events.find((e: CantonEvent) => 'CreatedEvent' in e);
-            const capturedCreated = expectedTx.events.find((e) => e.CreatedEvent)?.CreatedEvent;
-
-            expect(sdkCreatedWrapper).toBeDefined();
-            expect(capturedCreated).toBeDefined();
-
-            const sdkCreated =
-                'CreatedEvent' in sdkCreatedWrapper! ? sdkCreatedWrapper.CreatedEvent : null;
-            expect(sdkCreated).toBeDefined();
-            expect(sdkCreated!.contractId).toBe(capturedCreated!.contractId);
-            expect(sdkCreated!.templateId).toBe(capturedCreated!.templateId);
-
-            // Verify payload (SDK uses createArgument, not payload)
-            const sdkPayload = sdkCreated!.createArgument as {
-                owner: string;
-                value: string;
-                description: string;
-            };
-            expect(sdkPayload.owner).toBe(capturedCreated!.createArgument.owner);
-            expect(sdkPayload.value).toBe(capturedCreated!.createArgument.value);
-            expect(sdkPayload.description).toBe(capturedCreated!.createArgument.description);
-        });
-
-        it('should query contract and return payload matching captured response', async () => {
-            const queryInteraction = findInteraction(captured, 'query_contract__get_contract');
-            const sdk = createSdk([queryInteraction], INTERNAL_PARTY_USER_ID);
-
-            // Get contractId from captured request
-            const requestBody = queryInteraction.request.body as { contractId: string };
-
-            const contract = await sdk.get(requestBody.contractId as any, [INTERNAL_PARTY_ID]);
-
-            // Assert SDK output matches captured response
-            const responseBody = queryInteraction.response.body as {
-                created: {
-                    createdEvent: {
-                        contractId: string;
-                        templateId: string;
-                        createArgument: { owner: string; value: string; description: string };
-                    };
-                };
-            };
-            const expected = responseBody.created.createdEvent;
-
-            expect(contract).toBeDefined();
-            expect(contract!.contractId).toBe(expected.contractId);
-            expect(contract!.templateId).toBe(expected.templateId);
-
-            const payload = contract!.payload as {
-                owner: string;
-                value: string;
-                description: string;
-            };
-            expect(payload.owner).toBe(expected.createArgument.owner);
-            expect(payload.value).toBe(expected.createArgument.value);
-            expect(payload.description).toBe(expected.createArgument.description);
-        });
-    });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// External Party Flow Tests
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('External Party Flow (E2E Replay)', () => {
-    let captured: CapturedInteraction[];
-
-    beforeAll(() => {
-        captured = loadCapturedInteractions('external');
-    });
-
-    describe('prepareForSigning', () => {
-        it('should return prepared transaction with hash for signing', async () => {
-            // Prepare requires: get_synchronizers, prepare_signing
-            const syncInteraction = captured.find((i) => i.name.includes('get_synchronizers'));
-            const prepareInteraction = captured.find((i) => i.name.includes('prepare_signing'));
-
-            if (!syncInteraction || !prepareInteraction) {
-                throw new Error('Missing required interactions for prepare test');
-            }
-
-            const sdk = createSdk([syncInteraction, prepareInteraction], EXTERNAL_PARTY_USER_ID);
-
-            // Same input as capture script
-            const payload = {
-                owner: EXTERNAL_PARTY_ID,
-                value: '200',
-                description: 'Test asset for external party flow',
-            };
-            const command = {
-                createCommand: {
-                    templateId: `${SDK_TEST_PACKAGE_ID}:SdkTest:SimpleAsset`,
-                    createArguments: payload,
-                },
-            };
-
-            const prepared = await sdk.prepareForSigning({ actAs: [EXTERNAL_PARTY_ID] }, [command]);
-
-            // Assert structure
-            expect(prepared).toHaveProperty('preparedTransaction');
-            expect(prepared).toHaveProperty('preparedTransactionHash');
-            expect(prepared).toHaveProperty('hashingSchemeVersion');
-            expect(prepared).toHaveProperty('commandId');
-
-            // Assert types
-            expect(typeof prepared.preparedTransaction).toBe('string');
-            expect(typeof prepared.preparedTransactionHash).toBe('string');
-            expect(typeof prepared.commandId).toBe('string');
-
-            // preparedTransaction should be base64 encoded (long string)
-            expect(prepared.preparedTransaction.length).toBeGreaterThan(100);
-
-            // preparedTransactionHash should be base64 encoded hash
-            expect(prepared.preparedTransactionHash.length).toBeGreaterThan(20);
-
-            // Verify against captured response
-            const responseBody = prepareInteraction.response.body as {
-                preparedTransaction: string;
-                preparedTransactionHash: string;
-            };
-            expect(prepared.preparedTransaction).toBe(responseBody.preparedTransaction);
-            expect(prepared.preparedTransactionHash).toBe(responseBody.preparedTransactionHash);
-        });
-    });
-
-    describe('submitSigned', () => {
-        it('should submit signed transaction and return commandId', async () => {
-            // submitSigned requires: get_ledger_end, submit_signed
-            const ledgerEndInteraction = captured.find(
-                (i) =>
-                    i.name.includes('external_submit_create') &&
-                    i.request.path.includes('ledger-end'),
-            );
-            const executeInteraction = captured.find((i) => i.name.includes('submit_signed'));
-
-            if (!executeInteraction) {
-                throw new Error('Missing required interactions for submitSigned test');
-            }
-
-            const interactions = ledgerEndInteraction
-                ? [ledgerEndInteraction, executeInteraction]
-                : [executeInteraction];
-            const sdk = createSdk(interactions, EXTERNAL_PARTY_USER_ID);
-
-            // Extract the prepared transaction from captured request
-            const requestBody = executeInteraction.request.body as {
-                preparedTransaction: string;
-                partySignatures: {
-                    signatures: Array<{
-                        party: string;
-                        signatures: Array<{
-                            signature: string;
-                            signedBy: string;
-                            format: string;
-                            signingAlgorithmSpec: string;
-                        }>;
-                    }>;
-                };
-            };
-
-            const prepared = {
-                preparedTransaction: requestBody.preparedTransaction,
-                preparedTransactionHash: 'captured-hash',
-                hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2' as const,
-                commandId: 'captured-command-id',
-            };
-
-            const partySignature = requestBody.partySignatures.signatures[0]!;
-            const firstSig = partySignature.signatures[0]!;
-            const signature = {
-                party: partySignature.party,
-                signature: firstSig.signature,
-                signedBy: firstSig.signedBy,
-                format: firstSig.format,
-                signingAlgorithmSpec: firstSig.signingAlgorithmSpec,
-            };
-
-            const result = await sdk.submitSigned(prepared, [signature]);
-
-            // Assert structure
-            expect(result).toHaveProperty('commandId');
-            expect(result).toHaveProperty('completionOffset');
-
-            // Assert types
-            expect(typeof result.commandId).toBe('string');
-            expect(typeof result.completionOffset).toBe('number');
-        });
-    });
-
-    describe('Full External Party Create-Archive Flow', () => {
-        it('should complete signed submission lifecycle', async () => {
-            // Build the full sequence
-            const flowInteractions = captured.filter(
-                (i) =>
-                    i.name.includes('external_prepare_create') ||
-                    i.name.includes('external_submit_create') ||
-                    i.name.includes('external_wait_create') ||
-                    i.name.includes('external_fetch') ||
-                    i.name.includes('external_query'),
-            );
-
-            if (flowInteractions.length < 3) {
-                console.log('  (Skipping: Not enough interactions for external flow)');
-                return;
-            }
-
-            const sdk = createSdk(flowInteractions, EXTERNAL_PARTY_USER_ID);
-
-            // 1. Prepare create
-            const createCommand = {
-                createCommand: {
-                    templateId: `${SDK_TEST_PACKAGE_ID}:SdkTest:SimpleAsset`,
-                    createArguments: {
-                        owner: EXTERNAL_PARTY_ID,
-                        value: '200',
-                        description: 'Test asset for external party flow',
-                    },
-                },
-            };
-
-            const prepared = await sdk.prepareForSigning({ actAs: [EXTERNAL_PARTY_ID] }, [
-                createCommand,
-            ]);
-
-            // Assert prepared transaction
-            expect(prepared.preparedTransaction).toBeDefined();
-            expect(prepared.preparedTransactionHash).toBeDefined();
-            expect(prepared.preparedTransactionHash.length).toBeGreaterThan(0);
-        });
-    });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Error Handling Tests (Unhappy Paths)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('Error Handling (Unhappy Paths)', () => {
-    let captured: CapturedInteraction[];
-
-    beforeAll(() => {
-        try {
-            captured = loadCapturedInteractions('unhappy');
-        } catch {
-            captured = [];
-        }
-    });
-
-    it('should throw error for non-existent contract query', async () => {
-        if (captured.length === 0) {
-            console.log('  (Skipping: No unhappy path data captured)');
-            return;
-        }
-
-        const errorInteraction = captured.find((i) => i.name.includes('nonexistent'));
-        if (!errorInteraction) {
-            console.log('  (Skipping: No nonexistent contract interaction)');
-            return;
-        }
-
-        const sdk = createSdk([errorInteraction], INTERNAL_PARTY_USER_ID);
-
-        // Non-existent contract with 4xx/5xx response should throw (raw API error)
-        await expect(sdk.get('fake-contract-id' as any, [INTERNAL_PARTY_ID])).rejects.toThrow();
-    });
-
-    it('should handle invalid template ID', async () => {
-        if (captured.length === 0) return;
-
-        // Need all 3 interactions for submit flow
-        const syncInteraction = captured.find(
-            (i) => i.name === 'error_invalid_template_id__get_synchronizers',
-        );
-        const ledgerEndInteraction = captured.find(
-            (i) => i.name === 'error_invalid_template_id__get_ledger_end',
-        );
-        const submitInteraction = captured.find(
-            (i) => i.name === 'error_invalid_template_id__submit_command',
-        );
-
-        if (!syncInteraction || !ledgerEndInteraction || !submitInteraction) {
-            console.log('  (Skipping: Missing invalid_template interactions)');
-            return;
-        }
-
-        const sdk = createSdk(
-            [syncInteraction, ledgerEndInteraction, submitInteraction],
-            INTERNAL_PARTY_USER_ID,
-        );
-
-        const invalidCommand = {
-            createCommand: {
-                templateId: 'invalid-package:Invalid:Template',
-                createArguments: { owner: INTERNAL_PARTY_ID },
-            },
-        };
-
-        await expect(
-            sdk.submit({ actAs: [INTERNAL_PARTY_ID] }, [invalidCommand]),
-        ).rejects.toThrow();
-    });
-
-    it('should handle double archive error', async () => {
-        if (captured.length === 0) return;
-
-        // The error occurs on the second archive attempt
-        const ledgerEndInteraction = captured.find(
-            (i) => i.name === 'error_double_archive__get_ledger_end',
-        );
-        const submitInteraction = captured.find(
-            (i) => i.name === 'error_double_archive__submit_command',
-        );
-
-        if (!ledgerEndInteraction || !submitInteraction) {
-            console.log('  (Skipping: Missing double_archive interactions)');
-            return;
-        }
-
-        // Use a sync interaction from setup to provide synchronizer
-        const syncInteraction = captured.find(
-            (i) => i.name.includes('double_archive') && i.request.path.includes('synchronizers'),
-        );
-        const interactions = syncInteraction
-            ? [syncInteraction, ledgerEndInteraction, submitInteraction]
-            : [ledgerEndInteraction, submitInteraction];
-
-        const sdk = createSdk(interactions, INTERNAL_PARTY_USER_ID, false);
-
-        const archiveCommand = {
-            exerciseCommand: {
-                templateId: `${SDK_TEST_PACKAGE_ID}:SdkTest:SimpleAsset`,
-                contractId: 'already-archived-contract-id',
-                choice: 'Archive',
-                choiceArgument: {},
-            },
-        };
-
-        await expect(
-            sdk.submit({ actAs: [INTERNAL_PARTY_ID] }, [archiveCommand]),
-        ).rejects.toThrow();
-    });
-
-    it('should handle unauthorized party error', async () => {
-        if (captured.length === 0) return;
-
-        const ledgerEndInteraction = captured.find(
-            (i) => i.name === 'error_unauthorized_party__get_ledger_end',
-        );
-        const submitInteraction = captured.find(
-            (i) => i.name === 'error_unauthorized_party__submit_command',
-        );
-
-        if (!ledgerEndInteraction || !submitInteraction) {
-            console.log('  (Skipping: Missing unauthorized_party interactions)');
-            return;
-        }
-
-        const sdk = createSdk(
-            [ledgerEndInteraction, submitInteraction],
-            INTERNAL_PARTY_USER_ID,
-            false,
-        );
-
-        const command = {
-            createCommand: {
-                templateId: `${SDK_TEST_PACKAGE_ID}:SdkTest:SimpleAsset`,
-                createArguments: { owner: 'unauthorized-party' },
-            },
-        };
-
-        await expect(sdk.submit({ actAs: ['unauthorized-party'] }, [command])).rejects.toThrow();
-    });
-
-    it('should handle invalid signature error', async () => {
-        if (captured.length === 0) return;
-
-        const ledgerEndInteraction = captured.find(
-            (i) => i.name === 'error_invalid_signature__get_ledger_end',
-        );
-        const executeInteraction = captured.find(
-            (i) => i.name === 'error_invalid_signature__submit_signed',
-        );
-
-        if (!ledgerEndInteraction || !executeInteraction) {
-            console.log('  (Skipping: Missing invalid_signature interactions)');
-            return;
-        }
-
-        const sdk = createSdk(
-            [ledgerEndInteraction, executeInteraction],
-            EXTERNAL_PARTY_USER_ID,
-            false,
-        );
-
-        const prepared = {
-            preparedTransaction: 'some-prepared-tx',
-            preparedTransactionHash: 'some-hash',
-            hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2' as const,
-            commandId: 'test-command-id',
-        };
-
-        const invalidSignature = {
-            party: EXTERNAL_PARTY_ID,
-            signature: 'invalid-signature-data',
-            signedBy: 'wrong-key-fingerprint',
-            format: 'SIGNATURE_FORMAT_RAW',
-            signingAlgorithmSpec: 'SIGNING_ALGORITHM_SPEC_EC_DSA_SHA_256',
-        };
-
-        await expect(sdk.submitSigned(prepared, [invalidSignature])).rejects.toThrow();
-    });
-});