@layerzerolabs/common-canton 1.2.68 → 1.2.69

package/src/refresh/index.ts

@@ -1,5 +1,7 @@
 export * from './address-resolver';
 export * from './deployment-address';
+export * from './plan';
 export * from './resolve';
+export * from './resolve-plan';
 export * from './reverse-substitute';
 export * from './wrapped-lz-sdk';

package/src/refresh/plan.ts

@@ -0,0 +1,176 @@
+import { z } from 'zod';
+
+import { cantonExpectedSignatoriesSchema, cantonRefreshPartyFilterSchema } from '../deferredValue';
+
+export const cantonRefreshPathSegmentSchema = z.union([
+    z.object({ field: z.string().min(1) }),
+    z.object({ index: z.number().int().nonnegative() }),
+    z.object({ damlMapKey: z.string().min(1) }),
+]);
+
+export const cantonRefreshPathSchema = z.array(cantonRefreshPathSegmentSchema);
+const cantonNestedRefreshPathSchema = cantonRefreshPathSchema.min(1);
+
+const exerciseEntrypointTargetSchema = z.object({
+    commandIndex: z.number().int().nonnegative(),
+    command: z.literal('exercise'),
+    field: z.literal('contractId'),
+});
+
+const exerciseChoiceArgumentTargetSchema = z.object({
+    commandIndex: z.number().int().nonnegative(),
+    command: z.literal('exercise'),
+    choice: z.string().min(1),
+    arguments: z
+        .array(
+            z.object({
+                path: cantonRefreshPathSchema,
+            }),
+        )
+        .min(1),
+});
+
+const cantonCreateArgumentTargetSchema = z.object({
+    commandIndex: z.number().int().nonnegative(),
+    command: z.literal('create'),
+    template: z.string().min(1),
+    arguments: z
+        .array(
+            z.object({
+                path: cantonRefreshPathSchema,
+            }),
+        )
+        .min(1),
+});
+
+export const cantonRefreshTargetSchema = z.union([
+    exerciseEntrypointTargetSchema,
+    exerciseChoiceArgumentTargetSchema,
+    cantonCreateArgumentTargetSchema,
+]);
+
+export const cantonArgumentRefreshTargetSchema = z.union([
+    exerciseChoiceArgumentTargetSchema,
+    cantonCreateArgumentTargetSchema,
+]);
+
+const cantonNestedArgumentRefreshTargetSchema = z.union([
+    exerciseChoiceArgumentTargetSchema.extend({
+        arguments: z
+            .array(
+                z.object({
+                    path: cantonNestedRefreshPathSchema,
+                    offsetMs: z.number().int().optional(),
+                }),
+            )
+            .min(1),
+    }),
+    cantonCreateArgumentTargetSchema.extend({
+        arguments: z
+            .array(
+                z.object({
+                    path: cantonNestedRefreshPathSchema,
+                    offsetMs: z.number().int().optional(),
+                }),
+            )
+            .min(1),
+    }),
+]);
+
+const cantonContractSelectorSchema = z.object({
+    queryAs: cantonRefreshPartyFilterSchema,
+    templateId: z.string().min(1),
+    expectedSignatories: cantonExpectedSignatoriesSchema,
+    stateFilter: z.record(z.string(), z.unknown()).optional(),
+});
+
+const cantonExactlyOneSelectionSchema = z.object({ kind: z.literal('exactlyOne') });
+const cantonAllSelectionSchema = z.object({ kind: z.literal('all') });
+const cantonGteSelectionSchema = z.object({
+    kind: z.literal('gte'),
+    field: z.string().min(1),
+    value: z.string().min(1),
+});
+
+export const cantonActiveContractSelectionSchema = z.discriminatedUnion('kind', [
+    cantonExactlyOneSelectionSchema,
+    cantonAllSelectionSchema,
+    cantonGteSelectionSchema,
+]);
+
+const cantonActiveContractResolverFields = {
+    type: z.literal('activeContract'),
+    selector: cantonContractSelectorSchema,
+};
+
+const cantonActiveContractRefreshSchema = z.union([
+    z.object({
+        resolver: z.object({
+            ...cantonActiveContractResolverFields,
+            selection: cantonExactlyOneSelectionSchema,
+        }),
+        targets: z.array(cantonRefreshTargetSchema).min(1),
+    }),
+    z.object({
+        resolver: z.object({
+            ...cantonActiveContractResolverFields,
+            selection: z.union([cantonAllSelectionSchema, cantonGteSelectionSchema]),
+        }),
+        targets: z.array(cantonArgumentRefreshTargetSchema).min(1),
+    }),
+]);
+
+const cantonAmuletContextRefreshSchema = z.object({
+    resolver: z.object({
+        type: z.literal('amuletContext'),
+        dsoParty: z.string().min(1),
+    }),
+    targets: z.array(cantonArgumentRefreshTargetSchema).min(1),
+});
+
+const cantonTimestampRefreshSchema = z.object({
+    resolver: z.object({
+        type: z.literal('timestamp'),
+    }),
+    targets: z.array(cantonNestedArgumentRefreshTargetSchema).min(1),
+});
+
+export const cantonRefreshSchema = z.union([
+    cantonActiveContractRefreshSchema,
+    cantonAmuletContextRefreshSchema,
+    cantonTimestampRefreshSchema,
+]);
+
+const cantonDisclosureRefreshSchema = z.object({
+    excludeBaselineCids: z
+        .array(z.string().min(1))
+        .min(1)
+        .refine((cids) => new Set(cids).size === cids.length, {
+            message: 'Baseline disclosure CIDs must be unique',
+        }),
+});
+
+export const cantonRefreshPlanSchema = z.object({
+    commands: z.array(cantonRefreshSchema).min(1),
+    disclosures: cantonDisclosureRefreshSchema.optional(),
+});
+
+export type CantonRefreshPathSegment = z.infer<typeof cantonRefreshPathSegmentSchema>;
+export type CantonRefreshPath = z.infer<typeof cantonRefreshPathSchema>;
+export type ExerciseEntrypointTargetField = Pick<
+    z.infer<typeof exerciseEntrypointTargetSchema>,
+    'field'
+>;
+export type ExerciseChoiceArgumentTargetField = Pick<
+    z.infer<typeof exerciseChoiceArgumentTargetSchema>,
+    'choice' | 'arguments'
+>;
+export type CantonRefreshTarget = z.infer<typeof cantonRefreshTargetSchema>;
+export type CantonArgumentRefreshTarget = z.infer<typeof cantonArgumentRefreshTargetSchema>;
+export type CantonContractSelector = z.infer<typeof cantonContractSelectorSchema>;
+export type CantonActiveContractSelection = z.infer<typeof cantonActiveContractSelectionSchema>;
+export type CantonActiveContractRefresh = z.infer<typeof cantonActiveContractRefreshSchema>;
+export type CantonAmuletContextRefresh = z.infer<typeof cantonAmuletContextRefreshSchema>;
+export type CantonTimestampRefresh = z.infer<typeof cantonTimestampRefreshSchema>;
+export type CantonRefresh = z.infer<typeof cantonRefreshSchema>;
+export type CantonRefreshPlan = z.infer<typeof cantonRefreshPlanSchema>;

package/src/refresh/resolve-plan.ts

@@ -0,0 +1,502 @@
+import { NonRetryableError } from '@layerzerolabs/common-error-utils';
+
+import type { ICantonClient } from '../client/interface';
+import {
+    type CantonRefreshPartyFilter,
+    isCantonDeferredSender,
+    isCantonDeferredSentinel,
+} from '../deferredValue';
+import type { JsActiveContract } from '../open-api/models';
+import type {
+    CantonCommands,
+    CantonDisclosedContracts,
+    CantonUnresolvedCommands,
+} from '../transaction';
+import { getCreateArgumentField } from '../trusted-origin';
+import { type ActiveContractRef, createContractAddressResolver } from './address-resolver';
+import type {
+    CantonActiveContractRefresh,
+    CantonActiveContractSelection,
+    CantonAmuletContextRefresh,
+    CantonArgumentRefreshTarget,
+    CantonContractSelector,
+    CantonRefresh,
+    CantonRefreshPath,
+    CantonRefreshPlan,
+    CantonRefreshTarget,
+    CantonTimestampRefresh,
+} from './plan';
+
+const DAML_DECIMAL_SCALE = 10n ** 10n;
+const MAX_SELECTED_CONTRACTS = 100;
+const CANTON_TIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/;
+
+const nonRetryable = (message: string): never => {
+    throw new NonRetryableError(message);
+};
+
+const resolveParty = (
+    partyRef: CantonRefreshPartyFilter,
+    senderParty: string | undefined,
+    label: string,
+): string => {
+    if (!isCantonDeferredSender(partyRef)) return partyRef.party;
+    if (!senderParty) {
+        return nonRetryable(`${label} requires a resolved sender party`);
+    }
+    return senderParty;
+};
+
+const parseDamlDecimal = (value: unknown, label: string): bigint => {
+    if (typeof value !== 'string') {
+        return nonRetryable(`${label} must be a DAML Decimal string`);
+    }
+    const match = /^([+-]?)(\d+)(?:\.(\d{0,10}))?$/.exec(value);
+    if (!match) {
+        return nonRetryable(`${label} is not a valid DAML Decimal: ${value}`);
+    }
+    const sign = match[1] === '-' ? -1n : 1n;
+    const whole = BigInt(match[2]!);
+    const fraction = BigInt((match[3] ?? '').padEnd(10, '0'));
+    return sign * (whole * DAML_DECIMAL_SCALE + fraction);
+};
+
+const getContractNumericField = (contract: JsActiveContract, field: string): bigint => {
+    const raw = getCreateArgumentField(contract.createdEvent.createArgument, field);
+    const value =
+        raw !== null && typeof raw === 'object' && 'initialAmount' in raw
+            ? (raw as { initialAmount?: unknown }).initialAmount
+            : raw;
+    return parseDamlDecimal(
+        value,
+        `Contract ${contract.createdEvent.contractId} numeric field ${field}`,
+    );
+};
+
+export const selectContractsByGte = (
+    contracts: JsActiveContract[],
+    field: string,
+    requestedValue: string,
+): JsActiveContract[] => {
+    const requested = parseDamlDecimal(requestedValue, 'Requested contract value');
+    if (requested <= 0n) {
+        return nonRetryable('Requested contract value must be positive');
+    }
+
+    const candidates = contracts
+        .map((contract) => ({
+            contract,
+            amount: getContractNumericField(contract, field),
+        }))
+        .filter(({ amount }) => amount > 0n)
+        .sort((left, right) =>
+            left.amount === right.amount
+                ? left.contract.createdEvent.contractId.localeCompare(
+                      right.contract.createdEvent.contractId,
+                  )
+                : left.amount > right.amount
+                  ? -1
+                  : 1,
+        );
+
+    const selected: JsActiveContract[] = [];
+    let total = 0n;
+    for (const candidate of candidates) {
+        selected.push(candidate.contract);
+        total += candidate.amount;
+        if (total >= requested) break;
+    }
+
+    if (total < requested) {
+        return nonRetryable(
+            `Insufficient contract value in field ${field}: requested ${requestedValue}, found ${total.toString()} base units`,
+        );
+    }
+    if (selected.length > MAX_SELECTED_CONTRACTS) {
+        return nonRetryable(
+            `Selection needs ${selected.length} contracts, exceeding the ${MAX_SELECTED_CONTRACTS} input limit`,
+        );
+    }
+    return selected;
+};
+
+const makeActiveContractRef = (selector: CantonContractSelector): ActiveContractRef => ({
+    type: 'activeContractIds',
+    partyToFilter: selector.queryAs,
+    expectedSignatories: selector.expectedSignatories,
+    templateId: selector.templateId,
+    contractStateFilter: selector.stateFilter,
+});
+
+const selectActiveContracts = (
+    contracts: JsActiveContract[],
+    selection: CantonActiveContractSelection,
+): JsActiveContract[] => {
+    switch (selection.kind) {
+        case 'exactlyOne':
+            if (contracts.length !== 1) {
+                return nonRetryable(
+                    `Active contract selection matched ${contracts.length} contracts, expected exactly one`,
+                );
+            }
+            return contracts;
+        case 'all':
+            return contracts;
+        case 'gte':
+            return selectContractsByGte(contracts, selection.field, selection.value);
+    }
+};
+
+export const resolveCantonActiveContracts = async (args: {
+    client: ICantonClient;
+    selector: CantonContractSelector;
+    selection: CantonActiveContractSelection;
+    senderParty?: string;
+}): Promise<{ contractIds: string[] }> => {
+    const queryParty = resolveParty(
+        args.selector.queryAs,
+        args.senderParty,
+        'Active contract selection',
+    );
+    const ref = makeActiveContractRef(args.selector);
+    const resolver = createContractAddressResolver({
+        client: args.client,
+        senderParty: args.senderParty,
+        signingParties: [queryParty],
+        appendDisclosures: () => undefined,
+    });
+    const selected = selectActiveContracts(
+        await resolver.resolveActiveContracts(ref),
+        args.selection,
+    );
+    return {
+        contractIds: selected.map(({ createdEvent }) => createdEvent.contractId),
+    };
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const isCantonTime = (value: unknown): value is string =>
+    typeof value === 'string' &&
+    CANTON_TIME_PATTERN.test(value) &&
+    Number.isFinite(Date.parse(value));
+
+const isActiveContractRefresh = (refresh: CantonRefresh): refresh is CantonActiveContractRefresh =>
+    refresh.resolver.type === 'activeContract';
+
+const isAmuletContextRefresh = (refresh: CantonRefresh): refresh is CantonAmuletContextRefresh =>
+    refresh.resolver.type === 'amuletContext';
+
+const isTimestampRefresh = (refresh: CantonRefresh): refresh is CantonTimestampRefresh =>
+    refresh.resolver.type === 'timestamp';
+
+const replaceAtPath = (root: unknown, path: CantonRefreshPath, value: unknown): unknown => {
+    if (path.length === 0) return value;
+
+    let current = root;
+    for (const [position, segment] of path.entries()) {
+        const isLast = position === path.length - 1;
+        if ('field' in segment) {
+            if (!isRecord(current) || !(segment.field in current)) {
+                return nonRetryable(`Refresh target field "${segment.field}" does not exist`);
+            }
+            if (isLast) {
+                current[segment.field] = value;
+                return root;
+            }
+            current = current[segment.field];
+            continue;
+        }
+        if ('index' in segment) {
+            if (!Array.isArray(current) || segment.index >= current.length) {
+                return nonRetryable(`Refresh target array index ${segment.index} does not exist`);
+            }
+            if (isLast) {
+                current[segment.index] = value;
+                return root;
+            }
+            current = current[segment.index];
+            continue;
+        }
+
+        if (!Array.isArray(current)) {
+            return nonRetryable(`Refresh target DAML map "${segment.damlMapKey}" is not an array`);
+        }
+        const matches = current.filter(
+            (entry): entry is [string, unknown] =>
+                Array.isArray(entry) && entry.length === 2 && entry[0] === segment.damlMapKey,
+        );
+        if (matches.length !== 1) {
+            return nonRetryable(
+                `Refresh target DAML map key "${segment.damlMapKey}" matched ${matches.length} entries`,
+            );
+        }
+        if (isLast) {
+            matches[0]![1] = value;
+            return root;
+        }
+        current = matches[0]![1];
+    }
+    return root;
+};
+
+const readAtPath = (root: unknown, path: CantonRefreshPath): unknown => {
+    let current = root;
+    for (const segment of path) {
+        if ('field' in segment) {
+            if (!isRecord(current) || !(segment.field in current)) {
+                return nonRetryable(`Refresh target field "${segment.field}" does not exist`);
+            }
+            current = current[segment.field];
+            continue;
+        }
+        if ('index' in segment) {
+            if (!Array.isArray(current) || segment.index >= current.length) {
+                return nonRetryable(`Refresh target array index ${segment.index} does not exist`);
+            }
+            current = current[segment.index];
+            continue;
+        }
+
+        if (!Array.isArray(current)) {
+            return nonRetryable(`Refresh target DAML map "${segment.damlMapKey}" is not an array`);
+        }
+        const matches = current.filter(
+            (entry): entry is [string, unknown] =>
+                Array.isArray(entry) && entry.length === 2 && entry[0] === segment.damlMapKey,
+        );
+        if (matches.length !== 1) {
+            return nonRetryable(
+                `Refresh target DAML map key "${segment.damlMapKey}" matched ${matches.length} entries`,
+            );
+        }
+        current = matches[0]![1];
+    }
+    return current;
+};
+
+const readTarget = (
+    commands: CantonUnresolvedCommands,
+    target: CantonArgumentRefreshTarget,
+    path: CantonRefreshPath,
+): unknown => {
+    const command = commands[target.commandIndex];
+    if (!command) {
+        return nonRetryable(`Refresh command index ${target.commandIndex} does not exist`);
+    }
+
+    if (target.command === 'exercise') {
+        if (!('exerciseCommand' in command)) {
+            return nonRetryable(`Refresh command index ${target.commandIndex} is not an exercise`);
+        }
+        if (command.exerciseCommand.choice !== target.choice) {
+            return nonRetryable(
+                `Refresh command index ${target.commandIndex} expected choice ${target.choice}, found ${command.exerciseCommand.choice}`,
+            );
+        }
+        return readAtPath(command.exerciseCommand.choiceArgument, path);
+    }
+
+    if (!('createCommand' in command)) {
+        return nonRetryable(`Refresh command index ${target.commandIndex} is not a create`);
+    }
+    if (command.createCommand.templateId !== target.template) {
+        return nonRetryable(
+            `Refresh command index ${target.commandIndex} expected template ${target.template}, found ${command.createCommand.templateId}`,
+        );
+    }
+    return readAtPath(command.createCommand.createArguments, path);
+};
+
+const applyPatch = (
+    commands: CantonUnresolvedCommands,
+    target: CantonArgumentRefreshTarget,
+    path: CantonRefreshPath,
+    value: unknown,
+): void => {
+    const command = commands[target.commandIndex];
+    if (!command) {
+        return nonRetryable(`Refresh command index ${target.commandIndex} does not exist`);
+    }
+
+    if (target.command === 'exercise') {
+        if (!('exerciseCommand' in command)) {
+            return nonRetryable(`Refresh command index ${target.commandIndex} is not an exercise`);
+        }
+        if (command.exerciseCommand.choice !== target.choice) {
+            return nonRetryable(
+                `Refresh command index ${target.commandIndex} expected choice ${target.choice}, found ${command.exerciseCommand.choice}`,
+            );
+        }
+        command.exerciseCommand.choiceArgument = replaceAtPath(
+            command.exerciseCommand.choiceArgument,
+            path,
+            value,
+        );
+        return;
+    }
+
+    if (!('createCommand' in command)) {
+        return nonRetryable(`Refresh command index ${target.commandIndex} is not a create`);
+    }
+    if (command.createCommand.templateId !== target.template) {
+        return nonRetryable(
+            `Refresh command index ${target.commandIndex} expected template ${target.template}, found ${command.createCommand.templateId}`,
+        );
+    }
+    command.createCommand.createArguments = replaceAtPath(
+        command.createCommand.createArguments,
+        path,
+        value,
+    );
+};
+
+const applyTarget = (
+    commands: CantonUnresolvedCommands,
+    target: CantonRefreshTarget,
+    value: unknown,
+): void => {
+    if ('field' in target) {
+        const command = commands[target.commandIndex];
+        if (!command) {
+            return nonRetryable(`Refresh command index ${target.commandIndex} does not exist`);
+        }
+        if (!('exerciseCommand' in command)) {
+            return nonRetryable(`Refresh command index ${target.commandIndex} is not an exercise`);
+        }
+        if (typeof value !== 'string') {
+            return nonRetryable('Exercise contract ID refresh must resolve to a string');
+        }
+        command.exerciseCommand.contractId = value;
+        return;
+    }
+
+    for (const argument of target.arguments) {
+        applyPatch(commands, target, argument.path, value);
+    }
+};
+
+const containsDeferredSentinel = (value: unknown, key?: string): boolean => {
+    if (key === 'createdEventBlob') return false;
+    if (isCantonDeferredSentinel(value)) return true;
+    if (Array.isArray(value)) return value.some((item) => containsDeferredSentinel(item));
+    if (!isRecord(value)) return false;
+    return Object.entries(value).some(([childKey, child]) =>
+        containsDeferredSentinel(child, childKey),
+    );
+};
+
+const disclosuresEqual = (
+    left: CantonDisclosedContracts[number],
+    right: CantonDisclosedContracts[number],
+): boolean =>
+    left.contractId === right.contractId &&
+    left.templateId === right.templateId &&
+    left.createdEventBlob === right.createdEventBlob &&
+    left.synchronizerId === right.synchronizerId;
+
+export const resolveCantonRefreshPlan = async (args: {
+    unresolvedCommands: CantonUnresolvedCommands;
+    unresolvedDisclosedContracts: CantonDisclosedContracts;
+    refreshPlan: CantonRefreshPlan;
+    senderParty?: string;
+    signingParties: string[];
+    client: ICantonClient;
+}): Promise<{ commands: CantonCommands; disclosedContracts: CantonDisclosedContracts }> => {
+    if (
+        containsDeferredSentinel(args.unresolvedCommands) ||
+        containsDeferredSentinel(args.unresolvedDisclosedContracts)
+    ) {
+        return nonRetryable('Canton refreshPlan cannot be combined with deferred sentinels');
+    }
+
+    const commands = structuredClone(args.unresolvedCommands);
+    const baselineDisclosureCids = new Set(
+        args.unresolvedDisclosedContracts.map(({ contractId }) => contractId),
+    );
+    const excludedBaselineCids = new Set(args.refreshPlan.disclosures?.excludeBaselineCids ?? []);
+    for (const contractId of excludedBaselineCids) {
+        if (!baselineDisclosureCids.has(contractId)) {
+            return nonRetryable(
+                `Cannot exclude baseline disclosure ${contractId}: it is not present in unresolvedDisclosedContracts`,
+            );
+        }
+    }
+    const disclosureMap = new Map<string, CantonDisclosedContracts[number]>();
+    const appendDisclosures = (disclosures: CantonDisclosedContracts): void => {
+        for (const disclosure of disclosures) {
+            const existing = disclosureMap.get(disclosure.contractId);
+            if (existing && !disclosuresEqual(existing, disclosure)) {
+                return nonRetryable(
+                    `Conflicting disclosures for contract ${disclosure.contractId}`,
+                );
+            }
+            disclosureMap.set(disclosure.contractId, disclosure);
+        }
+    };
+    appendDisclosures(
+        args.unresolvedDisclosedContracts.filter(
+            ({ contractId }) => !excludedBaselineCids.has(contractId),
+        ),
+    );
+
+    const resolver = createContractAddressResolver({
+        client: args.client,
+        senderParty: args.senderParty,
+        signingParties: args.signingParties,
+        appendDisclosures,
+    });
+
+    for (const refresh of args.refreshPlan.commands) {
+        if (isActiveContractRefresh(refresh)) {
+            const ref = makeActiveContractRef(refresh.resolver.selector);
+            const selected = selectActiveContracts(
+                await resolver.resolveActiveContracts(ref),
+                refresh.resolver.selection,
+            );
+            await resolver.discloseActiveContracts(ref, selected);
+            const contractIds = selected.map(({ createdEvent }) => createdEvent.contractId);
+            const resolved =
+                refresh.resolver.selection.kind === 'exactlyOne' ? contractIds[0]! : contractIds;
+            for (const target of refresh.targets) applyTarget(commands, target, resolved);
+            continue;
+        }
+
+        if (isAmuletContextRefresh(refresh)) {
+            const bundle = await args.client.getAmuletContextWithExternalRules({
+                admin: refresh.resolver.dsoParty,
+                id: 'Amulet',
+            });
+            appendDisclosures(bundle.disclosedContracts);
+            for (const target of refresh.targets) {
+                applyTarget(commands, target, bundle.amuletContext);
+            }
+        }
+    }
+
+    // Timestamp refreshes run after all external reads so their shared instant is
+    // as close as possible to prepareForSigning, regardless of declaration order.
+    const now = new Date();
+    for (const refresh of args.refreshPlan.commands) {
+        if (!isTimestampRefresh(refresh)) continue;
+
+        for (const target of refresh.targets) {
+            for (const { path, offsetMs = 0 } of target.arguments) {
+                const iso = new Date(now.getTime() + offsetMs).toISOString();
+                const current = readTarget(commands, target, path);
+                const value = isCantonTime(current)
+                    ? iso
+                    : isRecord(current) && current.tag === 'AV_Time' && isCantonTime(current.value)
+                      ? { ...current, value: iso }
+                      : nonRetryable('Timestamp refresh target must contain a Canton Time value');
+                applyPatch(commands, target, path, value);
+            }
+        }
+    }
+
+    return {
+        commands: commands as CantonCommands,
+        disclosedContracts: [...disclosureMap.values()],
+    };
+};