@layerzerolabs/common-canton 1.2.69 → 1.2.70

package/src/transaction.ts

@@ -1,210 +0,0 @@
-import { z } from 'zod';
-
-import {
-    assignedTransactionSchema,
-    buildTransactionWithResultSchema,
-    minedTransactionSchema,
-    signedTransactionSchema,
-    transactionSchema,
-} from '@layerzerolabs/common-chain-model';
-import type { PartialBy } from '@layerzerolabs/typescript-utils';
-
-import type { CantonDeferredRef, CantonExpectedSignatories } from './deferredValue';
-import { cantonRefreshPlanSchema } from './refresh/plan';
-
-// === Component schemas ===
-
-export const cantonCommandSchema = z.union([
-    z.object({
-        createCommand: z.object({
-            templateId: z.string(),
-            createArguments: z.any(),
-        }),
-    }),
-    z.object({
-        exerciseCommand: z.object({
-            templateId: z.string(),
-            contractId: z.string(),
-            choice: z.string(),
-            choiceArgument: z.any(),
-        }),
-    }),
-    z.object({
-        createAndExerciseCommand: z.object({
-            templateId: z.string(),
-            createArguments: z.any(),
-            choice: z.string(),
-            choiceArgument: z.any(),
-        }),
-    }),
-    z.object({
-        exerciseByKeyCommand: z.object({
-            templateId: z.string(),
-            contractKey: z.any(),
-            choice: z.string(),
-            choiceArgument: z.any(),
-        }),
-    }),
-]);
-
-/**
- * Like cantonCommandSchema but with contractId typed as CantonDeferredRef | string.
- * Used for unresolvedCommands where exercise contractIds are deferred sentinels.
- * At runtime the validation is identical (z.string()); only the TypeScript type differs.
- */
-export const unresolvedCantonCommandSchema = cantonCommandSchema as unknown as z.ZodType<
-    | z.infer<typeof cantonCommandSchema>
-    | {
-          exerciseCommand: {
-              templateId: string;
-              contractId: CantonDeferredRef | string;
-              choice: string;
-              choiceArgument: unknown;
-          };
-      }
->;
-
-export const cantonDisclosedContractSchema = z.object({
-    templateId: z.string().optional(),
-    contractId: z.string(),
-    createdEventBlob: z.string(),
-    synchronizerId: z.string(),
-});
-
-// === Lifecycle schemas ===
-
-/**
- * Canton transaction schema for Daml Ledger API commands.
- */
-export const cantonTransactionSchema = transactionSchema.extend({
-    populatedTransaction: z.object({
-        unresolvedCommands: z.array(unresolvedCantonCommandSchema),
-        unresolvedDisclosedContracts: z.array(cantonDisclosedContractSchema),
-
-        /** Parties submitting the command (actAs) */
-        actAs: z.array(z.string()),
-        /** Maps each actAs party → the senderEntityName(s) controlling its signing
-         *  key(s), always as an array. `.optional()` only so deferred-sender create-time
-         *  payloads parse. At sign time: multi-party transactions must map every actAs
-         *  party or signing throws; single-party transactions may omit the map and sign()
-         *  falls back to the queue's senderEntityName. Multiple entries = a multisig party
-         *  (decentralized namespace) whose keys must all sign. */
-        partyToSenderEntity: z.record(z.string(), z.array(z.string())).optional(),
-        /** Deployment spec set at prepare time; the deployment activity resolves the live address ref from this + the createCommand. */
-        deploymentSpec: z
-            .object({
-                packageName: z.string(),
-                ownerField: z.string(),
-                identityKeys: z.array(z.string()),
-            })
-            .optional(),
-        /** Build-time replacements for volatile command inputs and disclosures. */
-        refreshPlan: cantonRefreshPlanSchema.optional(),
-    }),
-});
-
-export const cantonTransactionWithResultSchema =
-    buildTransactionWithResultSchema(cantonTransactionSchema);
-
-const cantonInflightTransactionSchema = z.object({
-    /** The prepared transaction blob */
-    preparedTransaction: z.string(),
-    /** Hash of the prepared transaction (what was signed) */
-    preparedTransactionHash: z.string(),
-    /** Hashing scheme version used */
-    hashingSchemeVersion: z.enum([
-        'HASHING_SCHEME_VERSION_UNSPECIFIED',
-        'HASHING_SCHEME_VERSION_V2',
-    ]),
-    /** Command ID for tracking */
-    commandId: z.string(),
-    // Ledger offset at which the submission landed — used as `beginExclusive`
-    // for waitForCommand to avoid polling from the start of the ledger.
-    //  Optional: only present after send(); absent for old/retry scenarios.
-    completionOffset: z.number().optional(),
-});
-
-/**
- * Assigned transaction includes the inflight transaction data.
- */
-export const cantonAssignedTransactionSchema = assignedTransactionSchema.extend({
-    ...cantonTransactionSchema.shape,
-    inflightTransaction: cantonInflightTransactionSchema.optional(),
-});
-
-/**
- * Signed transaction includes the DER-encoded ECDSA signature.
- */
-export const cantonSignedTransactionSchema = signedTransactionSchema.extend({
-    ...cantonAssignedTransactionSchema.shape,
-    // Resolved commands and contracts
-    commands: z.array(cantonCommandSchema),
-    disclosedContracts: z.array(cantonDisclosedContractSchema),
-    signedTransaction: z.object({
-        /** Per-party signatures in the format expected by Canton's submitSigned */
-        signatures: z.array(
-            z.object({
-                party: z.string(),
-                signatures: z.array(
-                    z.object({
-                        format: z.string(),
-                        signature: z.string(),
-                        signedBy: z.string(),
-                        signingAlgorithmSpec: z.string(),
-                    }),
-                ),
-            }),
-        ),
-    }),
-});
-
-/**
- * Mined transaction with confirmation result.
- */
-export const cantonMinedTransactionSchema = minedTransactionSchema.extend({
-    ...cantonSignedTransactionSchema.shape,
-    inflightTransaction: cantonInflightTransactionSchema,
-});
-
-/** Identifies a contract by data so its live cid can be re-resolved at sign time. */
-export interface ContractDataIdentifier {
-    cid: string;
-    templateId: string;
-    /** ACS query / visibility party (`partyToFilter`). */
-    party: string;
-    /**
-     * Authority parties that must all be ledger signatories at refresh time.
-     * Typically `[party]`; use a different list when querying as an observer
-     * (e.g. gateway) while authenticating the admin signatory.
-     *
-     * Non-empty; same type as the deferred-ref wire field.
-     */
-    expectedSignatories: CantonExpectedSignatories;
-    contractStateFilter?: Record<string, unknown>;
-}
-
-export type CantonTx = z.infer<typeof cantonTransactionSchema>;
-export type CantonPopulatedTransaction = CantonTx['populatedTransaction'];
-export type CantonCommands = z.infer<typeof cantonCommandSchema>[];
-export type CantonUnresolvedCommands = z.infer<typeof unresolvedCantonCommandSchema>[];
-export type CantonDisclosedContracts = z.infer<typeof cantonDisclosedContractSchema>[];
-export type CantonAssignedTx = z.infer<typeof cantonAssignedTransactionSchema>;
-export type CantonSignedTx = z.infer<typeof cantonSignedTransactionSchema>;
-export type CantonMinedTx = z.infer<typeof cantonMinedTransactionSchema>;
-
-// === Builder ===
-
-export type BuildCantonTransactionInput = PartialBy<CantonTx, 'chainName' | 'timestamps'>;
-
-export const buildCantonTransaction = async (
-    chainName: string,
-    tx: BuildCantonTransactionInput,
-): Promise<CantonTx> => {
-    return {
-        ...tx,
-        chainName,
-        timestamps: {
-            created: tx.timestamps?.created ?? Date.now(),
-        },
-    };
-};

package/src/trusted-origin.ts

@@ -1,59 +0,0 @@
-/**
- * Read a create-argument field, supporting dotted paths (`instrumentId.admin`).
- */
-export const getCreateArgumentField = (createArgument: unknown, fieldPath: string): unknown => {
-    let current: unknown = createArgument;
-    for (const part of fieldPath.split('.')) {
-        if (current == null || typeof current !== 'object') {
-            return undefined;
-        }
-        current = (current as Record<string, unknown>)[part];
-    }
-    return current;
-};
-
-/**
- * True when every party in `expectedSignatories` is among the created-event signatories
- * (expected ⊆ ledger signatories). Opposite of `findMatchingCreatedEvent`, which
- * requires every ledger signatory to be in the expected/actAs set.
- *
- * Drops observer-only foreign contracts that would otherwise poison ACS cardinality.
- */
-export const areExpectedSignatories = (
-    created: { signatories?: readonly string[] },
-    expectedSignatories: readonly string[],
-): boolean => {
-    if (expectedSignatories.length === 0) return false;
-    const signatories = created.signatories ?? [];
-    return expectedSignatories.every((party) => signatories.includes(party));
-};
-
-/**
- * True when `expectedParty` is among the created-event signatories.
- */
-export const isSignatoryOrigin = (
-    created: { signatories?: readonly string[] },
-    expectedParty: string,
-): boolean => areExpectedSignatories(created, [expectedParty]);
-
-/**
- * True when a created event originated under `expectedParty`: that party is among
- * the created-event signatories, and `createArgument[createArgumentField]` equals it.
- *
- * Use when the template has multiple signatories and the party must bind a
- * specific payload role (e.g. Request `handler` amid sender / oappAdmin).
- * Prefer `contractStateFilter` + `expectedSignatories` on deferred refs instead.
- *
- * @param createArgumentField - Payload identity field (`owner`, `handler`,
- *   `admin`, or a dotted path such as `instrumentId.admin`).
- */
-export const isTrustedOrigin = (
-    created: { createArgument?: unknown; signatories?: readonly string[] },
-    expectedParty: string,
-    createArgumentField: string,
-): boolean => {
-    if (getCreateArgumentField(created.createArgument, createArgumentField) !== expectedParty) {
-        return false;
-    }
-    return isSignatoryOrigin(created, expectedParty);
-};

package/test/auth/client-credentials-token-provider.test.ts

@@ -1,185 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { ClientCredentialsTokenProvider } from '../../src/auth/client-credentials-token-provider';
-
-const TOKEN_URL = 'https://idp.example.com/realms/canton/protocol/openid-connect/token';
-const CLIENT_ID = 'my-backend';
-const CLIENT_SECRET = 'super-secret';
-
-function mockTokenResponse(accessToken: string, expiresIn: number) {
-    return {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        json: async () => ({
-            access_token: accessToken,
-            token_type: 'Bearer',
-            expires_in: expiresIn,
-        }),
-        text: async () => '',
-    } as unknown as Response;
-}
-
-function mockErrorResponse(status: number, body: string) {
-    return {
-        ok: false,
-        status,
-        statusText: 'Bad Request',
-        json: async () => ({}),
-        text: async () => body,
-    } as unknown as Response;
-}
-
-describe('ClientCredentialsTokenProvider', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.stubGlobal('fetch', vi.fn());
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.restoreAllMocks();
-    });
-
-    it('fetches a token from the IdP', async () => {
-        vi.mocked(fetch).mockResolvedValueOnce(mockTokenResponse('tok-abc', 3600));
-
-        const provider = new ClientCredentialsTokenProvider({
-            tokenUrl: TOKEN_URL,
-            clientId: CLIENT_ID,
-            clientSecret: CLIENT_SECRET,
-        });
-
-        const token = await provider.getToken();
-
-        expect(token).toBe('tok-abc');
-        expect(fetch).toHaveBeenCalledOnce();
-        expect(fetch).toHaveBeenCalledWith(TOKEN_URL, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-            body: expect.stringContaining('grant_type=client_credentials'),
-        });
-    });
-
-    it('sends scope and audience when configured', async () => {
-        vi.mocked(fetch).mockResolvedValueOnce(mockTokenResponse('tok-scoped', 3600));
-
-        const provider = new ClientCredentialsTokenProvider({
-            tokenUrl: TOKEN_URL,
-            clientId: CLIENT_ID,
-            clientSecret: CLIENT_SECRET,
-            scope: 'daml_ledger_api',
-            audience: 'https://canton.network.global',
-        });
-
-        await provider.getToken();
-
-        const body = vi.mocked(fetch).mock.calls[0]![1]!.body as string;
-        const params = new URLSearchParams(body);
-        expect(params.get('scope')).toBe('daml_ledger_api');
-        expect(params.get('audience')).toBe('https://canton.network.global');
-    });
-
-    it('caches token and does not re-fetch within TTL', async () => {
-        vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
-        vi.mocked(fetch).mockResolvedValueOnce(mockTokenResponse('tok-cached', 3600));
-
-        const provider = new ClientCredentialsTokenProvider({
-            tokenUrl: TOKEN_URL,
-            clientId: CLIENT_ID,
-            clientSecret: CLIENT_SECRET,
-        });
-
-        const token1 = await provider.getToken();
-
-        // Advance 30 minutes — within TTL (3600 - 60 buffer = 3540s)
-        vi.advanceTimersByTime(30 * 60 * 1000);
-
-        const token2 = await provider.getToken();
-        expect(token2).toBe(token1);
-        expect(fetch).toHaveBeenCalledOnce();
-    });
-
-    it('re-fetches after token expires past buffer', async () => {
-        vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
-        vi.mocked(fetch)
-            .mockResolvedValueOnce(mockTokenResponse('tok-first', 300))
-            .mockResolvedValueOnce(mockTokenResponse('tok-second', 300));
-
-        const provider = new ClientCredentialsTokenProvider({
-            tokenUrl: TOKEN_URL,
-            clientId: CLIENT_ID,
-            clientSecret: CLIENT_SECRET,
-            bufferSeconds: 60,
-        });
-
-        const token1 = await provider.getToken();
-        expect(token1).toBe('tok-first');
-
-        // Advance past buffer (300 - 60 = 240s)
-        vi.advanceTimersByTime(241 * 1000);
-
-        const token2 = await provider.getToken();
-        expect(token2).toBe('tok-second');
-        expect(fetch).toHaveBeenCalledTimes(2);
-    });
-
-    it('coalesces concurrent getToken calls into a single fetch', async () => {
-        let resolveToken: (v: Response) => void;
-        const pendingFetch = new Promise<Response>((resolve) => {
-            resolveToken = resolve;
-        });
-        vi.mocked(fetch).mockReturnValueOnce(pendingFetch);
-
-        const provider = new ClientCredentialsTokenProvider({
-            tokenUrl: TOKEN_URL,
-            clientId: CLIENT_ID,
-            clientSecret: CLIENT_SECRET,
-        });
-
-        // Fire 5 concurrent calls
-        const promises = Array.from({ length: 5 }, () => provider.getToken());
-
-        // Resolve the single fetch
-        resolveToken!(mockTokenResponse('tok-coalesced', 3600));
-
-        const tokens = await Promise.all(promises);
-        expect(tokens).toEqual(Array(5).fill('tok-coalesced'));
-        expect(fetch).toHaveBeenCalledOnce();
-    });
-
-    it('throws on non-200 response', async () => {
-        vi.mocked(fetch).mockResolvedValueOnce(
-            mockErrorResponse(401, 'invalid_client: bad credentials'),
-        );
-
-        const provider = new ClientCredentialsTokenProvider({
-            tokenUrl: TOKEN_URL,
-            clientId: CLIENT_ID,
-            clientSecret: CLIENT_SECRET,
-        });
-
-        await expect(provider.getToken()).rejects.toThrow(
-            /Client credentials token request failed: 401.*bad credentials/,
-        );
-    });
-
-    it('retries fetch after a previous failure', async () => {
-        vi.mocked(fetch)
-            .mockResolvedValueOnce(mockErrorResponse(500, 'server error'))
-            .mockResolvedValueOnce(mockTokenResponse('tok-retry', 3600));
-
-        const provider = new ClientCredentialsTokenProvider({
-            tokenUrl: TOKEN_URL,
-            clientId: CLIENT_ID,
-            clientSecret: CLIENT_SECRET,
-        });
-
-        await expect(provider.getToken()).rejects.toThrow(/500/);
-
-        // Second attempt should succeed (pending promise was cleared)
-        const token = await provider.getToken();
-        expect(token).toBe('tok-retry');
-        expect(fetch).toHaveBeenCalledTimes(2);
-    });
-});

package/test/auth/local-token-provider.test.ts

@@ -1,129 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { LocalTokenProvider } from '../../src/auth/local-token-provider';
-
-function decodeJwtPayload(token: string): Record<string, unknown> {
-    const parts = token.split('.');
-    if (parts.length !== 3) throw new Error('Invalid JWT');
-    const payload = Buffer.from(parts[1]!, 'base64url').toString('utf-8');
-    return JSON.parse(payload);
-}
-
-describe('LocalTokenProvider', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-
-    it('generates a JWT with expected claims', async () => {
-        vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
-
-        const provider = new LocalTokenProvider({
-            userId: 'test-user',
-            actAs: ['party1::abc', 'party2::def'],
-        });
-
-        const token = await provider.getToken();
-        const payload = decodeJwtPayload(token);
-
-        expect(payload).toMatchObject({
-            sub: 'test-user',
-            aud: 'https://canton.network.global',
-            iat: Math.floor(new Date('2026-01-01T00:00:00Z').getTime() / 1000),
-            'https://daml.com/ledger-api': {
-                ledgerId: null,
-                participantId: null,
-                applicationId: null,
-                actAs: ['party1::abc', 'party2::def'],
-                readAs: ['party1::abc', 'party2::def'],
-                admin: true,
-            },
-        });
-
-        const iat = payload['iat'] as number;
-        const exp = payload['exp'] as number;
-        expect(exp - iat).toBe(3600);
-    });
-
-    it('uses custom config values', async () => {
-        const provider = new LocalTokenProvider({
-            userId: 'custom-user',
-            actAs: ['p1::123'],
-            secret: 'my-secret',
-            audience: 'https://custom.audience',
-            expiresIn: 600,
-            admin: false,
-        });
-
-        const token = await provider.getToken();
-        const payload = decodeJwtPayload(token);
-
-        expect(payload['sub']).toBe('custom-user');
-        expect(payload['aud']).toBe('https://custom.audience');
-        const ledgerApi = payload['https://daml.com/ledger-api'] as Record<string, unknown>;
-        expect(ledgerApi['admin']).toBe(false);
-
-        const iat = payload['iat'] as number;
-        const exp = payload['exp'] as number;
-        expect(exp - iat).toBe(600);
-    });
-
-    it('returns cached token on subsequent calls within TTL', async () => {
-        vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
-
-        const provider = new LocalTokenProvider({
-            userId: 'test-user',
-            actAs: ['party::abc'],
-            expiresIn: 3600,
-        });
-
-        const token1 = await provider.getToken();
-
-        // Advance 30 minutes — well within TTL (3600s - 60s buffer = 3540s)
-        vi.advanceTimersByTime(30 * 60 * 1000);
-
-        const token2 = await provider.getToken();
-        expect(token2).toBe(token1);
-    });
-
-    it('regenerates token after expiry buffer', async () => {
-        vi.setSystemTime(new Date('2026-01-01T00:00:00Z'));
-
-        const provider = new LocalTokenProvider({
-            userId: 'test-user',
-            actAs: ['party::abc'],
-            expiresIn: 120, // 2 minutes, minus 60s buffer = valid for 60s
-        });
-
-        const token1 = await provider.getToken();
-
-        // Advance past the buffer threshold (120s - 60s = 60s)
-        vi.advanceTimersByTime(61 * 1000);
-
-        const token2 = await provider.getToken();
-        expect(token2).not.toBe(token1);
-
-        // New token should have updated iat/exp
-        const payload = decodeJwtPayload(token2);
-        const expectedIat = Math.floor(new Date('2026-01-01T00:00:00Z').getTime() / 1000) + 61;
-        expect(payload['iat']).toBe(expectedIat);
-    });
-
-    it('produces a three-part JWT string', async () => {
-        const provider = new LocalTokenProvider({
-            userId: 'u',
-            actAs: ['p::1'],
-        });
-
-        const token = await provider.getToken();
-        const parts = token.split('.');
-        expect(parts).toHaveLength(3);
-
-        // Header should decode to HS256
-        const header = JSON.parse(Buffer.from(parts[0]!, 'base64url').toString('utf-8'));
-        expect(header).toEqual({ alg: 'HS256', typ: 'JWT' });
-    });
-});

package/test/client/amulet.test.ts

@@ -1,117 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import {
-    fetchAmuletContext,
-    fetchAmuletRules,
-    fetchDsoParty,
-    fetchOpenAndIssuingMiningRounds,
-    toDisclosedContract,
-} from '../../src/client/amulet';
-
-const TOKEN = 'test-token';
-const DSO_PARTY_PATH = '/api/validator/v0/scan-proxy/dso-party-id';
-const AMULET_RULES_PATH = '/api/validator/v0/scan-proxy/amulet-rules';
-const MINING_ROUNDS_PATH = '/api/validator/v0/scan-proxy/open-and-issuing-mining-rounds';
-const TRANSFER_FACTORY_PATH =
-    '/api/validator/v0/scan-proxy/registry/transfer-instruction/v1/transfer-factory';
-
-const scanEntry = {
-    contract: {
-        template_id: '#splice-amulet:Splice.AmuletRules:AmuletRules',
-        contract_id: 'cid-rules',
-        created_event_blob: 'blob',
-    },
-    domain_id: 'sync',
-};
-
-const okResponse = (body: unknown): Response =>
-    ({
-        ok: true,
-        status: 200,
-        json: async () => body,
-        text: async () => JSON.stringify(body),
-    }) as unknown as Response;
-
-const requestedUrl = (): string => String(vi.mocked(fetch).mock.calls[0]![0]);
-
-describe('amulet scan-proxy request URLs', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    describe('DSO party endpoint', () => {
-        it('targets the scan-proxy DSO party path on the wallet origin', async () => {
-            vi.mocked(fetch).mockResolvedValueOnce(okResponse({ dso_party_id: 'dso::123' }));
-
-            await fetchDsoParty('https://wallet.example.com', TOKEN);
-
-            expect(requestedUrl()).toBe(`https://wallet.example.com${DSO_PARTY_PATH}`);
-        });
-
-        it('collapses a trailing slash on the wallet URL instead of doubling it', async () => {
-            vi.mocked(fetch).mockResolvedValueOnce(okResponse({ dso_party_id: 'dso::123' }));
-
-            await fetchDsoParty('https://wallet.example.com/', TOKEN);
-
-            expect(requestedUrl()).toBe(`https://wallet.example.com${DSO_PARTY_PATH}`);
-            expect(new URL(requestedUrl()).host).toBe('wallet.example.com');
-        });
-    });
-
-    describe('amulet context endpoint', () => {
-        it('targets the transfer factory path regardless of a trailing slash', async () => {
-            vi.mocked(fetch).mockResolvedValueOnce(
-                okResponse({
-                    choiceContext: { disclosedContracts: [], choiceContextData: { values: {} } },
-                }),
-            );
-
-            await fetchAmuletContext('https://wallet.example.com/', TOKEN, {
-                admin: 'dso::123',
-                id: 'Amulet',
-            });
-
-            expect(requestedUrl()).toBe(`https://wallet.example.com${TRANSFER_FACTORY_PATH}`);
-        });
-    });
-
-    describe('amulet-rules endpoint', () => {
-        it('targets the scan-proxy amulet-rules path on the wallet origin', async () => {
-            vi.mocked(fetch).mockResolvedValueOnce(okResponse({ amulet_rules: scanEntry }));
-
-            const rules = await fetchAmuletRules('https://wallet.example.com/', TOKEN);
-
-            expect(requestedUrl()).toBe(`https://wallet.example.com${AMULET_RULES_PATH}`);
-            expect(rules.contract.contract_id).toBe('cid-rules');
-        });
-    });
-
-    describe('open-and-issuing-mining-rounds endpoint', () => {
-        it('defaults missing maps to empty objects', async () => {
-            vi.mocked(fetch).mockResolvedValueOnce(okResponse({}));
-
-            const rounds = await fetchOpenAndIssuingMiningRounds(
-                'https://wallet.example.com/',
-                TOKEN,
-            );
-
-            expect(requestedUrl()).toBe(`https://wallet.example.com${MINING_ROUNDS_PATH}`);
-            expect(rounds).toEqual({ open_mining_rounds: {}, issuing_mining_rounds: {} });
-        });
-    });
-});
-
-describe('toDisclosedContract', () => {
-    it('maps scan-proxy fields onto a disclosed contract', () => {
-        expect(toDisclosedContract(scanEntry)).toEqual({
-            contractId: 'cid-rules',
-            templateId: '#splice-amulet:Splice.AmuletRules:AmuletRules',
-            createdEventBlob: 'blob',
-            synchronizerId: 'sync',
-        });
-    });
-});