@layerzerolabs/common-canton 1.2.68 → 1.2.70

package/src/refresh/deployment-address.ts

@@ -1,52 +0,0 @@
-import { NonRetryableError } from '@layerzerolabs/common-error-utils';
-
-import { cantonActiveContractIdRef, type CantonDeferredRef } from '../deferredValue';
-import { getCreateArgumentField } from '../trusted-origin';
-
-export interface CantonDeployedTemplateSpec {
-    packageName: string;
-    ownerField: string;
-    // Immutable disambiguating fields only — mutable fields break recreate-survival.
-    identityKeys: string[];
-}
-
-// Canton returns `<packageId>:Module:Entity`; the package id has no colon.
-export const qualifiedTemplateName = (templateId: string): string => {
-    const firstColon = templateId.indexOf(':');
-    return firstColon === -1 ? templateId : templateId.slice(firstColon + 1);
-};
-
-/** Compare ledger vs filter template IDs, ignoring package-hash vs `#package-name` prefix. */
-export const templateIdMatches = (eventTemplateId: string, filterTemplateId: string): boolean =>
-    qualifiedTemplateName(eventTemplateId) === qualifiedTemplateName(filterTemplateId);
-
-interface DeployedCreatedEvent {
-    templateId: string;
-    createArgument?: unknown;
-}
-
-export const buildCantonDeployedContractAddressRef = (
-    createdEvent: DeployedCreatedEvent,
-    spec: CantonDeployedTemplateSpec,
-): CantonDeferredRef => {
-    const qualifiedName = qualifiedTemplateName(createdEvent.templateId);
-    const createArgument = (createdEvent.createArgument ?? {}) as Record<string, unknown>;
-    const ownerParty = getCreateArgumentField(createArgument, spec.ownerField);
-    if (typeof ownerParty !== 'string') {
-        throw new NonRetryableError(
-            `Template '${qualifiedName}' create argument is missing string owner field '${spec.ownerField}'`,
-        );
-    }
-
-    const contractStateFilter = spec.identityKeys.length
-        ? Object.fromEntries(spec.identityKeys.map((key) => [key, createArgument[key]]))
-        : undefined;
-
-    return cantonActiveContractIdRef({
-        partyToFilter: { party: ownerParty },
-        // LZ deploy templates: ownerField is a create-argument signatory.
-        expectedSignatories: [ownerParty],
-        templateId: `#${spec.packageName}:${qualifiedName}`,
-        ...(contractStateFilter ? { contractStateFilter } : {}),
-    });
-};

package/src/refresh/resolve.ts

@@ -1,101 +0,0 @@
-import { AMULET_INSTRUMENT_ID, type ChoiceContext } from '../client/amulet';
-import type { ICantonClient } from '../client/interface';
-import type { CantonDeferredValue } from '../deferredValue';
-import type { CantonCommands, CantonDisclosedContracts } from '../transaction';
-import { createContractAddressResolver } from './address-resolver';
-import { substituteRefsToCids } from './reverse-substitute';
-
-export interface ResolveCantonAddressParams {
-    unresolvedCommands: CantonCommands;
-    unresolvedDisclosedContracts: CantonDisclosedContracts;
-    senderParty?: string;
-    /** A contract is only disclosed when none of these parties is already a stakeholder on it. */
-    signingParties: string[];
-    client: ICantonClient;
-}
-
-export const resolveCantonTransaction = async ({
-    unresolvedCommands,
-    unresolvedDisclosedContracts,
-    senderParty,
-    signingParties,
-    client,
-}: ResolveCantonAddressParams): Promise<{
-    commands: CantonCommands;
-    disclosedContracts: CantonDisclosedContracts;
-}> => {
-    const nextDisclosed = [...unresolvedDisclosedContracts];
-    const disclosedContractIds = new Set(
-        unresolvedDisclosedContracts.map(({ contractId }) => contractId),
-    );
-    const appendDisclosures = (disclosures: CantonDisclosedContracts): void => {
-        for (const disclosure of disclosures) {
-            if (!disclosedContractIds.has(disclosure.contractId)) {
-                disclosedContractIds.add(disclosure.contractId);
-                nextDisclosed.push(disclosure);
-            }
-        }
-    };
-
-    const { resolveActiveContractId, resolveActiveContractIds, requireSenderParty } =
-        createContractAddressResolver({
-            client,
-            senderParty,
-            signingParties,
-            appendDisclosures,
-        });
-
-    let amuletBundlePromise:
-        | Promise<{
-              amuletContext: ChoiceContext;
-              externalPartyAmuletRulesCid: string;
-          }>
-        | undefined;
-
-    const getAmuletBundle = async () => {
-        if (!amuletBundlePromise) {
-            amuletBundlePromise = (async () => {
-                const dsoParty = await client.getDsoParty();
-                const {
-                    amuletContext,
-                    disclosedContracts: bundle,
-                    externalPartyAmuletRulesCid,
-                } = await client.getAmuletContextWithExternalRules({
-                    admin: dsoParty,
-                    id: AMULET_INSTRUMENT_ID,
-                });
-                appendDisclosures(bundle);
-                return { amuletContext, externalPartyAmuletRulesCid };
-            })();
-        }
-        return amuletBundlePromise;
-    };
-
-    const resolveRef = async (ref: CantonDeferredValue): Promise<unknown> => {
-        switch (ref.type) {
-            case 'senderParty':
-                return requireSenderParty(ref.type);
-            case 'activeContractId':
-                return resolveActiveContractId(ref);
-            case 'activeContractIds':
-                return resolveActiveContractIds(ref);
-            case 'amuletRulesCid':
-                return (await getAmuletBundle()).externalPartyAmuletRulesCid;
-            case 'amuletContext':
-                return (await getAmuletBundle()).amuletContext;
-        }
-    };
-
-    const resolvedCommands = await substituteRefsToCids(unresolvedCommands, resolveRef);
-    const resolvedDisclosedContracts: CantonDisclosedContracts = [];
-    for (let index = 0; index < nextDisclosed.length; index++) {
-        resolvedDisclosedContracts.push(
-            await substituteRefsToCids(nextDisclosed[index]!, resolveRef),
-        );
-    }
-
-    return {
-        commands: resolvedCommands,
-        disclosedContracts: resolvedDisclosedContracts,
-    };
-};

package/src/refresh/reverse-substitute.ts

@@ -1,63 +0,0 @@
-import { NonRetryableError } from '@layerzerolabs/common-error-utils';
-
-import { type CantonDeferredValue, parseCantonDeferredValueOrThrow } from '../deferredValue';
-
-// Opaque base64 — swapping a cid here would corrupt it.
-const BLOB_KEY = 'createdEventBlob';
-
-export const substituteCidsToRefs = <T>(value: T, cidToRef: Map<string, string>): T => {
-    if (typeof value === 'string') {
-        const ref = cidToRef.get(value);
-        return (ref ?? value) as T;
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => substituteCidsToRefs(item, cidToRef)) as T;
-    }
-    if (value !== null && typeof value === 'object') {
-        const out: Record<string, unknown> = {};
-        for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
-            out[key] = key === BLOB_KEY ? item : substituteCidsToRefs(item, cidToRef);
-        }
-        return out as T;
-    }
-    return value;
-};
-
-export type ResolveRef = (ref: CantonDeferredValue) => Promise<unknown>;
-
-/** A plural activeContractIds ref expands in place — must be inside an array; a scalar slot throws. */
-export const substituteRefsToCids = async <T>(value: T, resolve: ResolveRef): Promise<T> => {
-    if (Array.isArray(value)) {
-        const items = await Promise.all(
-            value.map(async (item) => {
-                const ref = parseCantonDeferredValueOrThrow(item);
-                return ref?.type === 'activeContractIds'
-                    ? ((await resolve(ref)) as unknown[])
-                    : [await substituteRefsToCids(item, resolve)];
-            }),
-        );
-        return items.flat() as T;
-    }
-
-    const ref = parseCantonDeferredValueOrThrow(value);
-    if (ref) {
-        if (ref.type === 'activeContractIds') {
-            throw new NonRetryableError(
-                `Refresh for ${ref.templateId} resolves to multiple contract ids, but the ref was not inside an array`,
-            );
-        }
-        return (await resolve(ref)) as T;
-    }
-
-    if (value !== null && typeof value === 'object') {
-        const entries = await Promise.all(
-            Object.entries(value as Record<string, unknown>).map(async ([key, item]) => [
-                key,
-                await substituteRefsToCids(item, resolve),
-            ]),
-        );
-        return Object.fromEntries(entries) as T;
-    }
-
-    return value;
-};

package/src/refresh/wrapped-lz-sdk.ts

@@ -1,69 +0,0 @@
-import { NonRetryableError } from '@layerzerolabs/common-error-utils';
-import { isPromise } from '@layerzerolabs/typescript-utils';
-
-import { cantonActiveContractIdRef, type CantonDeferredRef } from '../deferredValue';
-import type { ContractDataIdentifier } from '../transaction';
-import { substituteCidsToRefs } from './reverse-substitute';
-
-type AnyMethod = (...args: unknown[]) => unknown;
-
-type WithRefsInjected<R> = R extends { referencedContracts?: unknown }
-    ? Omit<R, 'referencedContracts'>
-    : R;
-
-type LzWrapped<T> = {
-    [K in keyof T]: T[K] extends (...a: infer A) => Promise<infer R>
-        ? (...a: A) => Promise<WithRefsInjected<R>>
-        : T[K];
-};
-
-const applyRefs = <R>(result: R): WithRefsInjected<R> => {
-    const refs = (result as { referencedContracts?: Array<ContractDataIdentifier> })
-        ?.referencedContracts;
-    if (!refs?.length) return result as WithRefsInjected<R>;
-
-    const contractIdToRef = new Map<string, CantonDeferredRef>(
-        refs.map((ref) => {
-            const expectedSignatories = ref.expectedSignatories;
-            if (!expectedSignatories[0]) {
-                throw new NonRetryableError(
-                    `ContractDataIdentifier for ${ref.cid} missing expectedSignatories`,
-                );
-            }
-            return [
-                ref.cid,
-                cantonActiveContractIdRef({
-                    partyToFilter: { party: ref.party },
-                    expectedSignatories,
-                    templateId: ref.templateId,
-                    ...(ref.contractStateFilter
-                        ? { contractStateFilter: ref.contractStateFilter }
-                        : {}),
-                }),
-            ];
-        }),
-    );
-
-    const { referencedContracts: _dropped, ...rest } = result as Record<string, unknown>;
-    const disclosed = (rest as { disclosedContracts?: Array<{ contractId: string }> })
-        .disclosedContracts;
-    if (Array.isArray(disclosed)) {
-        (rest as { disclosedContracts: unknown }).disclosedContracts = disclosed.filter(
-            (disclosure) => !contractIdToRef.has(disclosure.contractId),
-        );
-    }
-    return substituteCidsToRefs(rest, contractIdToRef) as WithRefsInjected<R>;
-};
-
-/** Rewrites the cids a contract SDK reports in `referencedContracts` to sign-time refs. */
-export const wrapLzSdk = <T extends object>(sdk: T): LzWrapped<T> =>
-    new Proxy(sdk, {
-        get(target, prop, receiver) {
-            const member = Reflect.get(target, prop, receiver);
-            if (typeof member !== 'function') return member;
-            return (...args: unknown[]): unknown => {
-                const result = (member as AnyMethod).apply(target, args);
-                return isPromise(result) ? result.then(applyRefs) : result;
-            };
-        },
-    }) as LzWrapped<T>;