@layerzerolabs/common-canton 1.2.38 → 1.2.39

package/test/refresh/observer-config-signing-dos.test.ts

@@ -0,0 +1,336 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ICantonClient } from '../../src/client/interface';
+import {
+    CANTON_DEFERRED_SENDER,
+    cantonActiveContractIdRef,
+    encodeCantonDeferredValue,
+    parseCantonDeferredValue,
+} from '../../src/deferredValue';
+import type { JsActiveContract } from '../../src/open-api/models';
+import {
+    createContractAddressResolver,
+    matchesContractStateFilter,
+    queryLiveContractsForRef,
+} from '../../src/refresh/address-resolver';
+import { buildCantonDeployedContractAddressRef } from '../../src/refresh/deployment-address';
+import {
+    areExpectedSignatories,
+    isSignatoryOrigin,
+    isTrustedOrigin,
+} from '../../src/trusted-origin';
+import type { ContractDataIdentifier } from '../../src/transaction';
+
+const HANDLER = 'lz-handler::namespace';
+const ATTACKER = 'attacker::namespace';
+const GATEWAY = 'lz-gateway::namespace';
+const TEMPLATE_ID = '#layerzero-request-factory:RequestFactoryConfig:RequestFactoryConfig';
+
+const configContract = ({
+    contractId,
+    handler,
+    signatories,
+    observers = [HANDLER],
+    createArgument,
+}: {
+    contractId: string;
+    handler: string;
+    signatories: string[];
+    observers?: string[];
+    createArgument?: Record<string, unknown>;
+}): JsActiveContract =>
+    ({
+        createdEvent: {
+            offset: 1,
+            nodeId: 0,
+            contractId,
+            templateId: 'pkg:RequestFactoryConfig:RequestFactoryConfig',
+            createArgument: createArgument ?? {
+                handler,
+                minFee: '0.0000010000',
+                minPayoutValue: '0.0000001000',
+                observers,
+                ledgerTimeValidityPeriod: { microseconds: '3600000000' },
+            },
+            signatories,
+            observers,
+            createdEventBlob: '',
+            createdAt: '',
+            packageName: 'layerzero-request-factory',
+            representativePackageId: 'pkg',
+            acsDelta: true,
+        },
+    }) as JsActiveContract;
+
+const mockClient = (contracts: JsActiveContract[]): ICantonClient =>
+    ({
+        getLedgerEndOffset: vi.fn(async () => 42),
+        queryActiveContracts: vi.fn(async () => contracts),
+        createDisclosure: vi.fn(async () => null),
+    }) as unknown as ICantonClient;
+
+describe('areExpectedSignatories', () => {
+    it('requires every listed party to be a signatory', () => {
+        expect(areExpectedSignatories({ signatories: [HANDLER, ATTACKER] }, [HANDLER])).toBe(true);
+        expect(
+            areExpectedSignatories({ signatories: [HANDLER, ATTACKER] }, [HANDLER, ATTACKER]),
+        ).toBe(true);
+        expect(areExpectedSignatories({ signatories: [HANDLER] }, [HANDLER, ATTACKER])).toBe(false);
+    });
+});
+
+describe('isSignatoryOrigin', () => {
+    it('accepts when party is a signatory', () => {
+        expect(isSignatoryOrigin({ signatories: [HANDLER] }, HANDLER)).toBe(true);
+    });
+
+    it('rejects observer-only visibility', () => {
+        expect(isSignatoryOrigin({ signatories: [ATTACKER] }, HANDLER)).toBe(false);
+    });
+});
+
+describe('isTrustedOrigin', () => {
+    it('requires payload field match in addition to signatory (multi-signatory templates)', () => {
+        expect(
+            isTrustedOrigin(
+                {
+                    createArgument: { handler: HANDLER, sender: ATTACKER },
+                    signatories: [HANDLER, ATTACKER],
+                },
+                HANDLER,
+                'handler',
+            ),
+        ).toBe(true);
+        expect(
+            isTrustedOrigin(
+                {
+                    createArgument: { handler: ATTACKER, sender: HANDLER },
+                    signatories: [HANDLER, ATTACKER],
+                },
+                HANDLER,
+                'handler',
+            ),
+        ).toBe(false);
+    });
+});
+
+describe('matchesContractStateFilter dotted paths', () => {
+    it('matches nested create-argument fields', () => {
+        const contract = configContract({
+            contractId: 'nested',
+            handler: HANDLER,
+            signatories: [HANDLER],
+            createArgument: {
+                instrumentId: { admin: HANDLER, id: 'oft' },
+            },
+        });
+        expect(matchesContractStateFilter(contract, { 'instrumentId.admin': HANDLER })).toBe(true);
+        expect(matchesContractStateFilter(contract, { 'instrumentId.admin': ATTACKER })).toBe(
+            false,
+        );
+    });
+
+    it('does not match a missing nested path (fail closed)', () => {
+        const contract = configContract({
+            contractId: 'no-nested',
+            handler: HANDLER,
+            signatories: [HANDLER],
+            createArgument: { handler: HANDLER },
+        });
+        expect(matchesContractStateFilter(contract, { 'instrumentId.admin': HANDLER })).toBe(false);
+        expect(matchesContractStateFilter(contract, { missing: undefined })).toBe(false);
+    });
+});
+
+describe('sign-time refresh observer-config DoS', () => {
+    const genuine = configContract({
+        contractId: 'genuine-rfc',
+        handler: HANDLER,
+        signatories: [HANDLER],
+        observers: [],
+    });
+    const poison = configContract({
+        contractId: 'poison-rfc',
+        handler: ATTACKER,
+        signatories: [ATTACKER],
+        observers: [HANDLER],
+    });
+
+    const ref = {
+        type: 'activeContractId' as const,
+        partyToFilter: { party: HANDLER },
+        expectedSignatories: [HANDLER] as [string, ...string[]],
+        templateId: TEMPLATE_ID,
+    };
+
+    it('ignores attacker-signed RequestFactoryConfig visible only as observer', async () => {
+        const client = mockClient([poison, genuine]);
+        const matches = await queryLiveContractsForRef(client, HANDLER, ref);
+        expect(matches.map((c) => c.createdEvent.contractId)).toEqual(['genuine-rfc']);
+    });
+
+    it('resolves the genuine cid when poison is also ACS-visible', async () => {
+        const client = mockClient([poison, genuine]);
+        const { resolveActiveContractId } = createContractAddressResolver({
+            client,
+            signingParties: [HANDLER],
+            appendDisclosures: () => undefined,
+        });
+        await expect(resolveActiveContractId(ref)).resolves.toBe('genuine-rfc');
+    });
+
+    it('throws cardinality only when multiple authenticated configs exist', async () => {
+        const duplicate = configContract({
+            contractId: 'genuine-rfc-2',
+            handler: HANDLER,
+            signatories: [HANDLER],
+            observers: [],
+        });
+        const client = mockClient([genuine, duplicate, poison]);
+        const { resolveActiveContractId } = createContractAddressResolver({
+            client,
+            signingParties: [HANDLER],
+            appendDisclosures: () => undefined,
+        });
+        await expect(resolveActiveContractId(ref)).rejects.toThrow(/matched 2 contracts/);
+    });
+
+    it('returns no matches when only poison is visible (solo missing genuine)', async () => {
+        const client = mockClient([poison]);
+        expect(await queryLiveContractsForRef(client, HANDLER, ref)).toEqual([]);
+    });
+
+    it('can query as observer gateway while authenticating admin signatory', async () => {
+        const oft = configContract({
+            contractId: 'oft-self',
+            handler: HANDLER,
+            signatories: [HANDLER],
+            observers: [GATEWAY],
+            createArgument: {
+                oappGateway: GATEWAY,
+                instrumentId: { admin: HANDLER, id: 'oft' },
+            },
+        });
+        const client = mockClient([oft, poison]);
+        const matches = await queryLiveContractsForRef(client, GATEWAY, {
+            type: 'activeContractId',
+            partyToFilter: { party: GATEWAY },
+            expectedSignatories: [HANDLER],
+            templateId: TEMPLATE_ID,
+            contractStateFilter: { 'instrumentId.admin': HANDLER },
+        });
+        expect(matches.map((c) => c.createdEvent.contractId)).toEqual(['oft-self']);
+    });
+
+    it('round-trips ContractDataIdentifier → deferred refs with expectedSignatories', () => {
+        const identifier: ContractDataIdentifier = {
+            cid: 'stale-rfc',
+            templateId: TEMPLATE_ID,
+            party: HANDLER,
+            expectedSignatories: [HANDLER],
+        };
+        const encoded = cantonActiveContractIdRef({
+            partyToFilter: { party: identifier.party },
+            expectedSignatories: identifier.expectedSignatories,
+            templateId: identifier.templateId,
+        });
+        const parsed = parseCantonDeferredValue(encoded);
+        expect(parsed).toMatchObject({
+            type: 'activeContractId',
+            partyToFilter: { party: HANDLER },
+            expectedSignatories: [HANDLER],
+            templateId: TEMPLATE_ID,
+        });
+        expect(parseCantonDeferredValue(encodeCantonDeferredValue(parsed!))).toEqual(parsed);
+    });
+
+    it('builds deployment address refs with expectedSignatories from ownerField', () => {
+        const encoded = buildCantonDeployedContractAddressRef(
+            {
+                templateId: 'pkg:RequestFactoryConfig:RequestFactoryConfig',
+                createArgument: { handler: HANDLER, minFee: '1.0' },
+            },
+            {
+                packageName: 'layerzero-request-factory',
+                ownerField: 'handler',
+                identityKeys: [],
+            },
+        );
+        expect(parseCantonDeferredValue(encoded)).toMatchObject({
+            type: 'activeContractId',
+            partyToFilter: { party: HANDLER },
+            expectedSignatories: [HANDLER],
+        });
+    });
+
+    it('parses pre-existing deploy artifact refs missing expectedSignatories', () => {
+        expect(
+            parseCantonDeferredValue(
+                '<<CANTON_DEFERRED:{"type":"activeContractId","partyToFilter":{"party":"alice"},"templateId":"#pkg:T"}>>',
+            ),
+        ).toMatchObject({
+            type: 'activeContractId',
+            partyToFilter: { party: 'alice' },
+            templateId: '#pkg:T',
+        });
+    });
+
+    it('does not default missing expectedSignatories to the owner for Amulet holdings', async () => {
+        const dso = 'dso::namespace';
+        const owner = 'alice::namespace';
+        const amulet = configContract({
+            contractId: 'amulet-legacy',
+            handler: owner,
+            signatories: [dso],
+            observers: [owner],
+            createArgument: { owner, instrumentId: { admin: dso, id: 'Amulet' } },
+        });
+        const client = mockClient([amulet]);
+        const matches = await queryLiveContractsForRef(client, owner, {
+            type: 'activeContractIds',
+            partyToFilter: { party: owner },
+            templateId: '#splice-amulet:Splice.Amulet:Amulet',
+            contractStateFilter: { owner: CANTON_DEFERRED_SENDER },
+        });
+        expect(matches.map((c) => c.createdEvent.contractId)).toEqual(['amulet-legacy']);
+    });
+
+    it('defaults missing expectedSignatories to the query party (still drops observer poison)', async () => {
+        const client = mockClient([poison, genuine]);
+        const legacyRef = {
+            type: 'activeContractId' as const,
+            partyToFilter: { party: HANDLER },
+            templateId: TEMPLATE_ID,
+        };
+        const matches = await queryLiveContractsForRef(client, HANDLER, legacyRef);
+        expect(matches.map((c) => c.createdEvent.contractId)).toEqual(['genuine-rfc']);
+    });
+
+    it('authenticates CIP-56 Amulet holdings by DSO signatory + owner payload', async () => {
+        const dso = 'dso::namespace';
+        const owner = 'alice::namespace';
+        const amulet = configContract({
+            contractId: 'amulet-1',
+            handler: owner,
+            signatories: [dso],
+            observers: [owner],
+            createArgument: { owner, instrumentId: { admin: dso, id: 'Amulet' } },
+        });
+        const foreign = configContract({
+            contractId: 'amulet-foreign',
+            handler: ATTACKER,
+            signatories: [dso],
+            observers: [owner],
+            createArgument: { owner: ATTACKER, instrumentId: { admin: dso, id: 'Amulet' } },
+        });
+        const client = mockClient([amulet, foreign]);
+        const matches = await queryLiveContractsForRef(client, owner, {
+            type: 'activeContractIds',
+            partyToFilter: { party: owner },
+            expectedSignatories: [dso],
+            templateId: '#splice-amulet:Splice.Amulet:Amulet',
+            contractStateFilter: { owner: CANTON_DEFERRED_SENDER },
+        });
+        expect(matches.map((c) => c.createdEvent.contractId)).toEqual(['amulet-1']);
+    });
+});

package/test/refresh/reverse-substitute.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { NonRetryableError } from '@layerzerolabs/common-error-utils';
+
+import { substituteRefsToCids } from '../../src/refresh/reverse-substitute';
+
+describe('substituteRefsToCids', () => {
+    it('throws NonRetryableError on a CANTON_DEFERRED sentinel that fails schema validation', async () => {
+        await expect(
+            substituteRefsToCids(
+                '<<CANTON_DEFERRED:{"type":"activeContractId","templateId":"#pkg:T"}>>',
+                vi.fn(),
+            ),
+        ).rejects.toBeInstanceOf(NonRetryableError);
+    });
+
+    it('passes through non-ref strings', async () => {
+        await expect(substituteRefsToCids('00abc', vi.fn())).resolves.toBe('00abc');
+    });
+});

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

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { NonRetryableError } from '@layerzerolabs/common-error-utils';
+
+import { parseCantonDeferredValue } from '../../src/deferredValue';
+import { wrapLzSdk } from '../../src/refresh/wrapped-lz-sdk';
+import type { ContractDataIdentifier } from '../../src/transaction';
+
+describe('wrapLzSdk', () => {
+    it('encodes referencedContracts with expectedSignatories', async () => {
+        const identifier: ContractDataIdentifier = {
+            cid: 'cid-1',
+            templateId: '#pkg:T',
+            party: 'alice::1220ab',
+            expectedSignatories: ['alice::1220ab'],
+        };
+        const sdk = {
+            prepare: async () => ({
+                commands: [{ exerciseCommand: { contractId: 'cid-1' } }],
+                referencedContracts: [identifier],
+            }),
+        };
+
+        const prepared = await wrapLzSdk(sdk).prepare();
+        expect(parseCantonDeferredValue(prepared.commands[0]!.exerciseCommand.contractId)).toEqual({
+            type: 'activeContractId',
+            partyToFilter: { party: 'alice::1220ab' },
+            expectedSignatories: ['alice::1220ab'],
+            templateId: '#pkg:T',
+        });
+        expect(prepared).not.toHaveProperty('referencedContracts');
+    });
+
+    it('throws NonRetryableError when expectedSignatories is empty', async () => {
+        const sdk = {
+            prepare: async () => ({
+                referencedContracts: [
+                    {
+                        cid: 'cid-1',
+                        templateId: '#pkg:T',
+                        party: 'alice::1220ab',
+                        expectedSignatories: [],
+                    },
+                ],
+            }),
+        };
+
+        await expect(wrapLzSdk(sdk).prepare()).rejects.toBeInstanceOf(NonRetryableError);
+    });
+});

package/dist/4SOUDUP7.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/events.ts"],"names":["findMatchingCreatedEvent","createdEvents","expectedTemplateId","expectedSignatories","expectedSet","Set","find","event","templateId","signatories","length","every","s","has","fetchCreatedEvents","client","updateId","parties","cantonTx","fetchTransactionByUpdateId","events","filter","map","CreatedEvent","findMatchingCreatedEventFromTx","tx","parsed","cantonTransactionWithResultSchema","safeParse","success","data","result","type","populatedTransaction","actAs","unresolvedCommands","minedTxHash","createCommand","cmd","cantonDeploymentSucceeded","txWithResult","waitForArchival","contractId","archived","fetchEventsByContractId","fetchTransactionByOffset","offset","NonEmittableError","getExercisedEvent","transaction","ExercisedEvent","exercised","undefined"],"mappings":"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","file":"4SOUDUP7.js","sourcesContent":["import { NonEmittableError } from '@layerzerolabs/common-error-utils';\n\nimport type { CantonTransaction, ICantonClient } from './client';\nimport type { CreatedEvent, ExercisedEvent } from './open-api/models';\nimport { cantonTransactionWithResultSchema } from './transaction';\n\n/**\n * Finds a CreatedEvent matching the expected templateId whose signatories\n * are a subset of the provided actAs parties.\n */\nexport const findMatchingCreatedEvent = (\n    createdEvents: CreatedEvent[],\n    expectedTemplateId: string,\n    expectedSignatories: string[],\n): CreatedEvent | undefined => {\n    const expectedSet = new Set(expectedSignatories);\n    return createdEvents.find((event) => {\n        if (event.templateId !== expectedTemplateId) return false;\n        const signatories = event.signatories ?? [];\n        return signatories.length > 0 && signatories.every((s) => expectedSet.has(s));\n    });\n};\n\n/**\n * Fetches a transaction by updateId and returns all CreatedEvents.\n */\nexport const fetchCreatedEvents = async (\n    client: ICantonClient,\n    updateId: string,\n    parties: string[],\n): Promise<CreatedEvent[]> => {\n    const cantonTx = await client.fetchTransactionByUpdateId(updateId, parties);\n    return (\n        cantonTx.events\n            ?.filter((event): event is { CreatedEvent: CreatedEvent } => 'CreatedEvent' in event)\n            .map((event) => event.CreatedEvent) ?? []\n    );\n};\n\n/**\n * Parses a Canton transaction-with-result, fetches the created events from the ledger,\n * and returns the first CreatedEvent matching the submitted command's templateId and actAs\n * signatories. Returns null if the transaction is falsy, not successful, or has no match.\n */\nexport const findMatchingCreatedEventFromTx = async (\n    client: ICantonClient,\n    tx: unknown,\n): Promise<CreatedEvent | null> => {\n    const parsed = cantonTransactionWithResultSchema.safeParse(tx);\n    if (!parsed.success) return null;\n\n    if (parsed.data.result.type !== 'success') return null;\n\n    const {\n        populatedTransaction: { actAs, unresolvedCommands },\n    } = parsed.data;\n    const updateId = parsed.data.result.minedTxHash;\n\n    if (!updateId || !actAs.length) return null;\n\n    const createCommand = unresolvedCommands.find((cmd) => 'createCommand' in cmd);\n    if (!createCommand || !('createCommand' in createCommand)) return null;\n\n    const createdEvents = await fetchCreatedEvents(client, updateId, actAs);\n    return (\n        findMatchingCreatedEvent(createdEvents, createCommand.createCommand.templateId, actAs) ??\n        null\n    );\n};\n\n/**\n * Checks that a Canton deploy transaction resulted in a CreatedEvent\n * matching the submitted command's templateId and actAs signatories.\n */\nexport const cantonDeploymentSucceeded = async (\n    client: ICantonClient,\n    txWithResult: unknown,\n): Promise<boolean> => {\n    return (await findMatchingCreatedEventFromTx(client, txWithResult)) != null;\n};\n\n/**\n * Waits for a contract to be archived and returns the transaction that archived it.\n * Throws NonEmittableError if the contract is not yet archived.\n */\nexport const waitForArchival = async (\n    client: ICantonClient,\n    contractId: string,\n    parties: string[],\n): Promise<CantonTransaction> => {\n    const { archived } = await client.fetchEventsByContractId(contractId, parties);\n    if (archived) {\n        return client.fetchTransactionByOffset(archived.offset, parties);\n    }\n    throw new NonEmittableError(`Contract ${contractId} is not archived yet`);\n};\n\n/** Returns the first exercised event on `contractId` in a transaction tree, if any. */\nexport const getExercisedEvent = (\n    transaction: CantonTransaction,\n    contractId: string,\n): ExercisedEvent | undefined => {\n    for (const event of transaction.events ?? []) {\n        if (!('ExercisedEvent' in event)) continue;\n        const { ExercisedEvent: exercised } = event;\n        if (exercised.contractId === contractId) {\n            return exercised;\n        }\n    }\n    return undefined;\n};\n"]}

package/dist/57KDDFEU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/reverse-substitute.ts"],"names":["BLOB_KEY","substituteCidsToRefs","value","cidToRef","ref","get","Array","isArray","map","item","out","key","Object","entries","substituteRefsToCids","resolve","items","Promise","all","parseCantonDeferredValue","type","flat","NonRetryableError","templateId","fromEntries"],"mappings":";;;;AAKA,IAAMA,QAAAA,GAAW,kBAAA;AAEV,IAAMC,oBAAAA,mBAAuB,MAAA,CAAA,CAAIC,KAAAA,EAAUC,QAAAA,KAAAA;AAC9C,EAAA,IAAI,OAAOD,UAAU,QAAA,EAAU;AAC3B,IAAA,MAAME,GAAAA,GAAMD,QAAAA,CAASE,GAAAA,CAAIH,KAAAA,CAAAA;AACzB,IAAA,OAAQE,GAAAA,IAAOF,KAAAA;AACnB,EAAA;AACA,EAAA,IAAII,KAAAA,CAAMC,OAAAA,CAAQL,KAAAA,CAAAA,EAAQ;AACtB,IAAA,OAAOA,MAAMM,GAAAA,CAAI,CAACC,SAASR,oBAAAA,CAAqBQ,IAAAA,EAAMN,QAAAA,CAAAA,CAAAA;AAC1D,EAAA;AACA,EAAA,IAAID,KAAAA,KAAU,IAAA,IAAQ,OAAOA,KAAAA,KAAU,QAAA,EAAU;AAC7C,IAAA,MAAMQ,MAA+B,EAAC;AACtC,IAAA,KAAA,MAAW,CAACC,GAAAA,EAAKF,IAAAA,KAASG,MAAAA,CAAOC,OAAAA,CAAQX,KAAAA,CAAAA,EAAmC;AACxEQ,MAAAA,GAAAA,CAAIC,GAAAA,CAAAA,GAAOA,GAAAA,KAAQX,WAAWS,IAAAA,GAAOR,oBAAAA,CAAqBQ,MAAMN,QAAAA,CAAAA;AACpE,IAAA;AACA,IAAA,OAAOO,GAAAA;AACX,EAAA;AACA,EAAA,OAAOR,KAAAA;AACX,CAAA,EAhBoC,sBAAA;AAqB7B,IAAMY,oBAAAA,mBAAuB,MAAA,CAAA,OAAUZ,KAAAA,EAAUa,OAAAA,KAAAA;AACpD,EAAA,IAAIT,KAAAA,CAAMC,OAAAA,CAAQL,KAAAA,CAAAA,EAAQ;AACtB,IAAA,MAAMc,QAAQ,MAAMC,OAAAA,CAAQC,IACxBhB,KAAAA,CAAMM,GAAAA,CAAI,OAAOC,IAAAA,KAAAA;AACb,MAAA,MAAML,IAAAA,GAAMe,yBAAyBV,IAAAA,CAAAA;AACrC,MAAA,OAAOL,MAAKgB,IAAAA,KAAS,mBAAA,GACb,MAAML,OAAAA,CAAQX,IAAAA,CAAAA,GAChB;QAAC,MAAMU,oBAAAA,CAAqBL,MAAMM,OAAAA;;AAC5C,IAAA,CAAA,CAAA,CAAA;AAEJ,IAAA,OAAOC,MAAMK,IAAAA,EAAI;AACrB,EAAA;AAEA,EAAA,MAAMjB,GAAAA,GAAMe,yBAAyBjB,KAAAA,CAAAA;AACrC,EAAA,IAAIE,GAAAA,EAAK;AACL,IAAA,IAAIA,GAAAA,CAAIgB,SAAS,mBAAA,EAAqB;AAClC,MAAA,MAAM,IAAIE,iBAAAA,CACN,CAAA,YAAA,EAAelB,GAAAA,CAAImB,UAAU,CAAA,uEAAA,CAAyE,CAAA;AAE9G,IAAA;AACA,IAAA,OAAQ,MAAMR,QAAQX,GAAAA,CAAAA;AAC1B,EAAA;AAEA,EAAA,IAAIF,KAAAA,KAAU,IAAA,IAAQ,OAAOA,KAAAA,KAAU,QAAA,EAAU;AAC7C,IAAA,MAAMW,OAAAA,GAAU,MAAMI,OAAAA,CAAQC,GAAAA,CAC1BN,MAAAA,CAAOC,OAAAA,CAAQX,KAAAA,CAAAA,CAAkCM,GAAAA,CAAI,OAAO,CAACG,GAAAA,EAAKF,IAAAA,CAAAA,KAAU;AACxEE,MAAAA,GAAAA;MACA,MAAMG,oBAAAA,CAAqBL,MAAMM,OAAAA;KACpC,CAAA,CAAA;AAEL,IAAA,OAAOH,MAAAA,CAAOY,YAAYX,OAAAA,CAAAA;AAC9B,EAAA;AAEA,EAAA,OAAOX,KAAAA;AACX,CAAA,EAlCoC,sBAAA","file":"57KDDFEU.js","sourcesContent":["import { NonRetryableError } from '@layerzerolabs/common-error-utils';\n\nimport { type CantonDeferredValue, parseCantonDeferredValue } from '../deferredValue';\n\n// Opaque base64 — swapping a cid here would corrupt it.\nconst BLOB_KEY = 'createdEventBlob';\n\nexport const substituteCidsToRefs = <T>(value: T, cidToRef: Map<string, string>): T => {\n    if (typeof value === 'string') {\n        const ref = cidToRef.get(value);\n        return (ref ?? value) as T;\n    }\n    if (Array.isArray(value)) {\n        return value.map((item) => substituteCidsToRefs(item, cidToRef)) as T;\n    }\n    if (value !== null && typeof value === 'object') {\n        const out: Record<string, unknown> = {};\n        for (const [key, item] of Object.entries(value as Record<string, unknown>)) {\n            out[key] = key === BLOB_KEY ? item : substituteCidsToRefs(item, cidToRef);\n        }\n        return out as T;\n    }\n    return value;\n};\n\nexport type ResolveRef = (ref: CantonDeferredValue) => Promise<unknown>;\n\n/** A plural activeContractIds ref expands in place — must be inside an array; a scalar slot throws. */\nexport const substituteRefsToCids = async <T>(value: T, resolve: ResolveRef): Promise<T> => {\n    if (Array.isArray(value)) {\n        const items = await Promise.all(\n            value.map(async (item) => {\n                const ref = parseCantonDeferredValue(item);\n                return ref?.type === 'activeContractIds'\n                    ? ((await resolve(ref)) as unknown[])\n                    : [await substituteRefsToCids(item, resolve)];\n            }),\n        );\n        return items.flat() as T;\n    }\n\n    const ref = parseCantonDeferredValue(value);\n    if (ref) {\n        if (ref.type === 'activeContractIds') {\n            throw new NonRetryableError(\n                `Refresh for ${ref.templateId} resolves to multiple contract ids, but the ref was not inside an array`,\n            );\n        }\n        return (await resolve(ref)) as T;\n    }\n\n    if (value !== null && typeof value === 'object') {\n        const entries = await Promise.all(\n            Object.entries(value as Record<string, unknown>).map(async ([key, item]) => [\n                key,\n                await substituteRefsToCids(item, resolve),\n            ]),\n        );\n        return Object.fromEntries(entries) as T;\n    }\n\n    return value;\n};\n"]}

package/dist/I6Z5XG3N.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/deployment-address.ts"],"names":["qualifiedTemplateName","templateId","firstColon","indexOf","slice","buildCantonDeployedContractAddressRef","createdEvent","spec","qualifiedName","createArgument","ownerParty","ownerField","NonRetryableError","contractStateFilter","identityKeys","length","Object","fromEntries","map","key","undefined","cantonActiveContractIdRef","partyToFilter","party","packageName"],"mappings":";;;;AAYO,IAAMA,qBAAAA,2BAAyBC,UAAAA,KAAAA;AAClC,EAAA,MAAMC,UAAAA,GAAaD,UAAAA,CAAWE,OAAAA,CAAQ,GAAA,CAAA;AACtC,EAAA,OAAOD,eAAe,EAAA,GAAKD,UAAAA,GAAaA,UAAAA,CAAWG,KAAAA,CAAMF,aAAa,CAAA,CAAA;AAC1E,CAAA,EAHqC,uBAAA;AAU9B,IAAMG,qCAAAA,mBAAwC,MAAA,CAAA,CACjDC,YAAAA,EACAC,IAAAA,KAAAA;AAEA,EAAA,MAAMC,aAAAA,GAAgBR,qBAAAA,CAAsBM,YAAAA,CAAaL,UAAU,CAAA;AACnE,EAAA,MAAMQ,cAAAA,GAAkBH,YAAAA,CAAaG,cAAAA,IAAkB,EAAC;AACxD,EAAA,MAAMC,UAAAA,GAAaD,cAAAA,CAAeF,IAAAA,CAAKI,UAAU,CAAA;AACjD,EAAA,IAAI,OAAOD,eAAe,QAAA,EAAU;AAChC,IAAA,MAAM,IAAIE,iBAAAA,CACN,CAAA,UAAA,EAAaJ,aAAAA,CAAAA,iDAAAA,EAAiED,IAAAA,CAAKI,UAAU,CAAA,CAAA,CAAG,CAAA;AAExG,EAAA;AAEA,EAAA,MAAME,mBAAAA,GAAsBN,IAAAA,CAAKO,YAAAA,CAAaC,MAAAA,GACxCC,MAAAA,CAAOC,YAAYV,IAAAA,CAAKO,YAAAA,CAAaI,GAAAA,CAAI,CAACC,GAAAA,KAAQ;AAACA,IAAAA,GAAAA;AAAKV,IAAAA,cAAAA,CAAeU,GAAAA;AAAK,GAAA,CAAA,CAAA,GAC5EC,MAAAA;AAEN,EAAA,OAAOC,yBAAAA,CAA0B;IAC7BC,aAAAA,EAAe;MAAEC,KAAAA,EAAOb;AAAW,KAAA;AACnCT,IAAAA,UAAAA,EAAY,CAAA,CAAA,EAAIM,IAAAA,CAAKiB,WAAW,CAAA,CAAA,EAAIhB,aAAAA,CAAAA,CAAAA;AACpC,IAAA,GAAIK,mBAAAA,GAAsB;AAAEA,MAAAA;AAAoB,KAAA,GAAI;GACxD,CAAA;AACJ,CAAA,EAtBqD,uCAAA","file":"I6Z5XG3N.js","sourcesContent":["import { NonRetryableError } from '@layerzerolabs/common-error-utils';\n\nimport { cantonActiveContractIdRef, type CantonDeferredRef } from '../deferredValue';\n\nexport interface CantonDeployedTemplateSpec {\n    packageName: string;\n    ownerField: string;\n    // Immutable disambiguating fields only — mutable fields break recreate-survival.\n    identityKeys: string[];\n}\n\n// Canton returns `<packageId>:Module:Entity`; the package id has no colon.\nexport const qualifiedTemplateName = (templateId: string): string => {\n    const firstColon = templateId.indexOf(':');\n    return firstColon === -1 ? templateId : templateId.slice(firstColon + 1);\n};\n\ninterface DeployedCreatedEvent {\n    templateId: string;\n    createArgument?: unknown;\n}\n\nexport const buildCantonDeployedContractAddressRef = (\n    createdEvent: DeployedCreatedEvent,\n    spec: CantonDeployedTemplateSpec,\n): CantonDeferredRef => {\n    const qualifiedName = qualifiedTemplateName(createdEvent.templateId);\n    const createArgument = (createdEvent.createArgument ?? {}) as Record<string, unknown>;\n    const ownerParty = createArgument[spec.ownerField];\n    if (typeof ownerParty !== 'string') {\n        throw new NonRetryableError(\n            `Template '${qualifiedName}' create argument is missing string owner field '${spec.ownerField}'`,\n        );\n    }\n\n    const contractStateFilter = spec.identityKeys.length\n        ? Object.fromEntries(spec.identityKeys.map((key) => [key, createArgument[key]]))\n        : undefined;\n\n    return cantonActiveContractIdRef({\n        partyToFilter: { party: ownerParty },\n        templateId: `#${spec.packageName}:${qualifiedName}`,\n        ...(contractStateFilter ? { contractStateFilter } : {}),\n    });\n};\n"]}

package/dist/JJKMXRP7.js.map

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

package/dist/RJSKBZMO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/wrapped-lz-sdk.ts"],"names":["applyRefs","result","refs","referencedContracts","length","contractIdToRef","Map","map","ref","cid","cantonActiveContractIdRef","partyToFilter","party","templateId","contractStateFilter","_dropped","rest","disclosed","disclosedContracts","Array","isArray","filter","disclosure","has","contractId","substituteCidsToRefs","wrapLzSdk","sdk","Proxy","get","target","prop","receiver","member","Reflect","args","apply","isPromise","then"],"mappings":";;;;;AAkBA,IAAMA,SAAAA,2BAAgBC,MAAAA,KAAAA;AAClB,EAAA,MAAMC,OAAQD,MAAAA,EACRE,mBAAAA;AACN,EAAA,IAAI,CAACD,IAAAA,EAAME,MAAAA,EAAQ,OAAOH,MAAAA;AAE1B,EAAA,MAAMI,kBAAkB,IAAIC,GAAAA,CACxBJ,IAAAA,CAAKK,GAAAA,CAAI,CAACC,GAAAA,KAAQ;IACdA,GAAAA,CAAIC,GAAAA;IACJC,yBAAAA,CAA0B;MACtBC,aAAAA,EAAe;AAAEC,QAAAA,KAAAA,EAAOJ,GAAAA,CAAII;AAAM,OAAA;AAClCC,MAAAA,UAAAA,EAAYL,GAAAA,CAAIK,UAAAA;AAChB,MAAA,GAAIL,IAAIM,mBAAAA,GACF;AAAEA,QAAAA,mBAAAA,EAAqBN,GAAAA,CAAIM;AAAoB,OAAA,GAC/C;KACV;GACH,CAAA,CAAA;AAGL,EAAA,MAAM,EAAEX,mBAAAA,EAAqBY,QAAAA,EAAU,GAAGC,MAAAA,GAASf,MAAAA;AACnD,EAAA,MAAMgB,YAAaD,IAAAA,CACdE,kBAAAA;AACL,EAAA,IAAIC,KAAAA,CAAMC,OAAAA,CAAQH,SAAAA,CAAAA,EAAY;AACzBD,IAAAA,IAAAA,CAAyCE,kBAAAA,GAAqBD,SAAAA,CAAUI,MAAAA,CACrE,CAACC,UAAAA,KAAe,CAACjB,eAAAA,CAAgBkB,GAAAA,CAAID,UAAAA,CAAWE,UAAU,CAAA,CAAA;AAElE,EAAA;AACA,EAAA,OAAOC,oBAAAA,CAAqBT,MAAMX,eAAAA,CAAAA;AACtC,CAAA,EA3BkB,WAAA,CAAA;AA8BX,IAAMqB,SAAAA,mBAAY,MAAA,CAAA,CAAmBC,GAAAA,KACxC,IAAIC,MAAMD,GAAAA,EAAK;EACXE,GAAAA,CAAIC,MAAAA,EAAQC,MAAMC,QAAAA,EAAQ;AACtB,IAAA,MAAMC,MAAAA,GAASC,OAAAA,CAAQL,GAAAA,CAAIC,MAAAA,EAAQC,MAAMC,QAAAA,CAAAA;AACzC,IAAA,IAAI,OAAOC,MAAAA,KAAW,UAAA,EAAY,OAAOA,MAAAA;AACzC,IAAA,OAAO,IAAIE,IAAAA,KAAAA;AACP,MAAA,MAAMlC,MAAAA,GAAUgC,MAAAA,CAAqBG,KAAAA,CAAMN,MAAAA,EAAQK,IAAAA,CAAAA;AACnD,MAAA,OAAOE,UAAUpC,MAAAA,CAAAA,GAAUA,MAAAA,CAAOqC,IAAAA,CAAKtC,SAAAA,CAAAA,GAAaC,MAAAA;AACxD,IAAA,CAAA;AACJ,EAAA;AACJ,CAAA,CAAA,EAVqB,WAAA","file":"RJSKBZMO.js","sourcesContent":["import { isPromise } from '@layerzerolabs/typescript-utils';\n\nimport { cantonActiveContractIdRef, type CantonDeferredRef } from '../deferredValue';\nimport type { ContractDataIdentifier } from '../transaction';\nimport { substituteCidsToRefs } from './reverse-substitute';\n\ntype AnyMethod = (...args: unknown[]) => unknown;\n\ntype WithRefsInjected<R> = R extends { referencedContracts?: unknown }\n    ? Omit<R, 'referencedContracts'>\n    : R;\n\ntype LzWrapped<T> = {\n    [K in keyof T]: T[K] extends (...a: infer A) => Promise<infer R>\n        ? (...a: A) => Promise<WithRefsInjected<R>>\n        : T[K];\n};\n\nconst applyRefs = <R>(result: R): WithRefsInjected<R> => {\n    const refs = (result as { referencedContracts?: Array<ContractDataIdentifier> })\n        ?.referencedContracts;\n    if (!refs?.length) return result as WithRefsInjected<R>;\n\n    const contractIdToRef = new Map<string, CantonDeferredRef>(\n        refs.map((ref) => [\n            ref.cid,\n            cantonActiveContractIdRef({\n                partyToFilter: { party: ref.party },\n                templateId: ref.templateId,\n                ...(ref.contractStateFilter\n                    ? { contractStateFilter: ref.contractStateFilter }\n                    : {}),\n            }),\n        ]),\n    );\n\n    const { referencedContracts: _dropped, ...rest } = result as Record<string, unknown>;\n    const disclosed = (rest as { disclosedContracts?: Array<{ contractId: string }> })\n        .disclosedContracts;\n    if (Array.isArray(disclosed)) {\n        (rest as { disclosedContracts: unknown }).disclosedContracts = disclosed.filter(\n            (disclosure) => !contractIdToRef.has(disclosure.contractId),\n        );\n    }\n    return substituteCidsToRefs(rest, contractIdToRef) as WithRefsInjected<R>;\n};\n\n/** Rewrites the cids a contract SDK reports in `referencedContracts` to sign-time refs. */\nexport const wrapLzSdk = <T extends object>(sdk: T): LzWrapped<T> =>\n    new Proxy(sdk, {\n        get(target, prop, receiver) {\n            const member = Reflect.get(target, prop, receiver);\n            if (typeof member !== 'function') return member;\n            return (...args: unknown[]): unknown => {\n                const result = (member as AnyMethod).apply(target, args);\n                return isPromise(result) ? result.then(applyRefs) : result;\n            };\n        },\n    }) as LzWrapped<T>;\n"]}

package/dist/TM5LJKTE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/address.ts"],"names":["CANTON_PARTY_ID_REGEX","CANTON_CONTRACT_ID_HEX_LENGTH","CANTON_PARTY_ADDRESS_PREFIX","CANTON_CID_ADDRESS_PREFIX","cantonPartyAddress","hint","fingerprint","CANTON_DEFERRED_VALUE_SUFFIX","cantonCidAddress","contractId","cantonDeferredAddress","sentinel","toCantonAddress","raw","startsWith","CANTON_DEFERRED_VALUE_PREFIX","endsWith","partyMatch","exec","bare","trim0x","length","Error","isCantonAddress","value"],"mappings":";;;;AAKA,IAAMA,qBAAAA,GAAwB,wBAAA;AAC9B,IAAMC,6BAAAA,GAAgC,GAAA;AAE/B,IAAMC,2BAAAA,GAA8B;AACpC,IAAMC,yBAAAA,GAA4B;AAMlC,IAAMC,kBAAAA,mBAAqB,MAAA,CAAA,CAACC,IAAAA,EAAcC,WAAAA,KAC7C,CAAA,EAAGJ,2BAAAA,CAAAA,EAA8BG,IAAAA,CAAAA,EAAAA,EAASC,WAAAA,CAAAA,EAAcC,4BAAAA,CAAAA,CAAAA,EAD1B,oBAAA;AAI3B,IAAMC,gBAAAA,2BAAoBC,UAAAA,KAC7B,CAAA,EAAGN,yBAAAA,CAAAA,EAA4BM,UAAAA,CAAAA,EAAaF,4BAAAA,CAAAA,CAAAA,EADhB,kBAAA;AAIzB,IAAMG,qBAAAA,mBAAwB,MAAA,CAAA,CAACC,QAAAA,KAAoCA,QAAAA,EAArC,uBAAA;AAG9B,IAAMC,eAAAA,2BAAmBC,GAAAA,KAAAA;AAC5B,EAAA,IACIA,IAAIC,UAAAA,CAAWC,4BAAAA,KACfF,GAAAA,CAAIG,QAAAA,CAAST,4BAAAA,CAAAA,EACf;AACE,IAAA,OAAOG,sBAAsBG,GAAAA,CAAAA;AACjC,EAAA;AACA,EAAA,MAAMI,UAAAA,GAAajB,qBAAAA,CAAsBkB,IAAAA,CAAKL,GAAAA,CAAAA;AAC9C,EAAA,IAAII,UAAAA,EAAY;AACZ,IAAA,MAAM,GAAGZ,IAAAA,EAAMC,WAAAA,CAAAA,GAAeW,UAAAA;AAC9B,IAAA,OAAOb,kBAAAA,CAAmBC,MAAOC,WAAAA,CAAAA;AACrC,EAAA;AACA,EAAA,MAAMa,IAAAA,GAAOC,OAAOP,GAAAA,CAAAA;AACpB,EAAA,IAAIM,KAAKE,MAAAA,KAAWpB,6BAAAA,IAAiCkB,IAAAA,CAAKL,UAAAA,CAAW,IAAA,CAAA,EAAO;AACxE,IAAA,OAAON,iBAAiBW,IAAAA,CAAAA;AAC5B,EAAA;AACA,EAAA,MAAM,IAAIG,KAAAA,CAAM,CAAA,6BAAA,EAAgCT,GAAAA,CAAAA,CAAK,CAAA;AACzD,CAAA,EAjB+B,iBAAA;AAoBxB,IAAMU,eAAAA,mBAAkB,MAAA,CAAA,CAACC,KAAAA,KAC5BA,KAAAA,CAAMV,WAAWZ,2BAAAA,CAAAA,IACjBsB,KAAAA,CAAMV,UAAAA,CAAWX,yBAAAA,CAAAA,IACjBqB,KAAAA,CAAMV,UAAAA,CAAWC,4BAAAA,CAAAA,EAHU,iBAAA","file":"TM5LJKTE.js","sourcesContent":["import { trim0x } from '@layerzerolabs/common-encoding-utils';\nimport type { Branded } from '@layerzerolabs/typescript-utils';\n\nimport { CANTON_DEFERRED_VALUE_PREFIX, CANTON_DEFERRED_VALUE_SUFFIX } from './deferredValue';\n\nconst CANTON_PARTY_ID_REGEX = /^(.+)::([0-9a-fA-F]+)$/;\nconst CANTON_CONTRACT_ID_HEX_LENGTH = 138; // 69 bytes\n\nexport const CANTON_PARTY_ADDRESS_PREFIX = '<<CANTON_PARTY::';\nexport const CANTON_CID_ADDRESS_PREFIX = '<<CANTON_CID::';\n\n/** A Canton native address — a branded string with one of three sentinel-prefix forms. */\nexport type CantonAddress = Branded<string, 'CantonAddress'>;\n\n/** Construct a party `CantonAddress` from hint and fingerprint. */\nexport const cantonPartyAddress = (hint: string, fingerprint: string): CantonAddress =>\n    `${CANTON_PARTY_ADDRESS_PREFIX}${hint}::${fingerprint}${CANTON_DEFERRED_VALUE_SUFFIX}` as CantonAddress;\n\n/** Construct a contract-ID `CantonAddress` from the raw 69-byte hex contract id. */\nexport const cantonCidAddress = (contractId: string): CantonAddress =>\n    `${CANTON_CID_ADDRESS_PREFIX}${contractId}${CANTON_DEFERRED_VALUE_SUFFIX}` as CantonAddress;\n\n/** Wrap a deferred-ref sentinel (`<<CANTON_DEFERRED:{json}>>`) as a `CantonAddress`. */\nexport const cantonDeferredAddress = (sentinel: string): CantonAddress => sentinel as CantonAddress;\n\n/** Wrap a raw Canton ledger value (party id, contract id, or deferred sentinel) as `CantonAddress`. */\nexport const toCantonAddress = (raw: string): CantonAddress => {\n    if (\n        raw.startsWith(CANTON_DEFERRED_VALUE_PREFIX) &&\n        raw.endsWith(CANTON_DEFERRED_VALUE_SUFFIX)\n    ) {\n        return cantonDeferredAddress(raw);\n    }\n    const partyMatch = CANTON_PARTY_ID_REGEX.exec(raw);\n    if (partyMatch) {\n        const [, hint, fingerprint] = partyMatch;\n        return cantonPartyAddress(hint!, fingerprint!);\n    }\n    const bare = trim0x(raw);\n    if (bare.length === CANTON_CONTRACT_ID_HEX_LENGTH && bare.startsWith('00')) {\n        return cantonCidAddress(bare);\n    }\n    throw new Error(`Not a Canton-native address: ${raw}`);\n};\n\n/** Returns true if `value` is a valid `CantonAddress` sentinel string. */\nexport const isCantonAddress = (value: string): value is CantonAddress =>\n    value.startsWith(CANTON_PARTY_ADDRESS_PREFIX) ||\n    value.startsWith(CANTON_CID_ADDRESS_PREFIX) ||\n    value.startsWith(CANTON_DEFERRED_VALUE_PREFIX);\n"]}

package/dist/VAFLUPQJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/address-resolver.ts"],"names":["isConcreteActiveContractRef","ref","type","partyToFilter","matchesContractStateFilter","contract","contractStateFilter","createArgument","createdEvent","Object","entries","every","key","value","JSON","stringify","isRefAlive","client","contracts","queryLiveContractsForRef","party","length","offset","getLedgerEndOffset","queryActiveContracts","templateIds","templateId","filter","queryLiveContractIdsForRef","senderParty","map","c","contractId","createContractAddressResolver","deps","signingParties","appendDisclosures","requireSender","NonRetryableError","resolveQueryParty","queryCache","Map","queryAsParty","cacheKey","cached","get","query","set","needsDisclosure","stakeholders","Set","signatories","observers","some","has","discloseContracts","toDisclose","disclosures","Promise","all","disclosure","createDisclosure","resolveActiveContractId","resolveActiveContractIds","requireSenderParty"],"mappings":"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","file":"VAFLUPQJ.js","sourcesContent":["import type { ContractId } from '@daml/types';\n\nimport { NonRetryableError } from '@layerzerolabs/common-error-utils';\n\nimport type { ICantonClient } from '../client/interface';\nimport type { CantonDeferredValue } from '../deferredValue';\nimport type { JsActiveContract } from '../open-api/models';\nimport type { CantonDisclosedContracts } from '../transaction';\n\nexport type ActiveContractRef = Extract<\n    CantonDeferredValue,\n    { type: 'activeContractId' | 'activeContractIds' }\n>;\n\n/** Active-contract ref whose handler party is concrete (not the `'sender'` sentinel). */\nexport type ConcreteActiveContractRef = ActiveContractRef & {\n    partyToFilter: { party: string };\n};\n\nexport const isConcreteActiveContractRef = (\n    ref: CantonDeferredValue,\n): ref is ConcreteActiveContractRef =>\n    (ref.type === 'activeContractId' || ref.type === 'activeContractIds') &&\n    ref.partyToFilter !== 'sender';\n\nexport interface ContractAddressResolverDeps {\n    client: ICantonClient;\n    senderParty?: string;\n    /** A contract is only disclosed when none of these parties is already a stakeholder on it. */\n    signingParties: string[];\n    appendDisclosures: (disclosures: CantonDisclosedContracts) => void;\n}\n\nexport const matchesContractStateFilter = (\n    contract: JsActiveContract,\n    contractStateFilter: ActiveContractRef['contractStateFilter'],\n): boolean => {\n    if (!contractStateFilter) return true;\n    const createArgument = contract.createdEvent.createArgument as Record<string, unknown>;\n    return Object.entries(contractStateFilter).every(\n        ([key, value]) => JSON.stringify(createArgument[key]) === JSON.stringify(value),\n    );\n};\n\nexport const isRefAlive = async (\n    client: ICantonClient,\n    ref: CantonDeferredValue,\n): Promise<boolean> => {\n    if (!isConcreteActiveContractRef(ref)) return false;\n    const contracts = await queryLiveContractsForRef(client, ref.partyToFilter.party, ref);\n    return ref.type === 'activeContractId' ? contracts.length === 1 : contracts.length > 0;\n};\n\n/** partyToFilter: 'sender' is resolved per-caller — this function takes an already-resolved party string. */\nexport const queryLiveContractsForRef = async (\n    client: ICantonClient,\n    party: string,\n    ref: ActiveContractRef,\n): Promise<JsActiveContract[]> => {\n    const offset = await client.getLedgerEndOffset();\n    return (\n        await client.queryActiveContracts(party, offset, { templateIds: [ref.templateId] })\n    ).filter((contract) => matchesContractStateFilter(contract, ref.contractStateFilter));\n};\n\n/**\n * Returns the contractIds of all live contracts matching ref.\n * Resolves 'sender' to senderParty when provided; returns [] if unresolvable.\n */\nexport const queryLiveContractIdsForRef = async (\n    client: ICantonClient,\n    ref: CantonDeferredValue,\n    senderParty?: string,\n): Promise<string[]> => {\n    if (ref.type !== 'activeContractId' && ref.type !== 'activeContractIds') return [];\n    const party = ref.partyToFilter === 'sender' ? senderParty : ref.partyToFilter.party;\n    if (!party) return [];\n    const contracts = await queryLiveContractsForRef(client, party, ref);\n    return contracts.map((c) => c.createdEvent.contractId);\n};\n\nexport const createContractAddressResolver = (deps: ContractAddressResolverDeps) => {\n    const { client, senderParty, signingParties, appendDisclosures } = deps;\n\n    const requireSender = (templateId: string): string => {\n        if (!senderParty) {\n            throw new NonRetryableError(\n                `Refresh entry for ${templateId} needs a resolved sender party, but none was provided`,\n            );\n        }\n        return senderParty;\n    };\n\n    const resolveQueryParty = ({ partyToFilter, templateId }: ActiveContractRef): string =>\n        partyToFilter === 'sender' ? requireSender(templateId) : partyToFilter.party;\n\n    const queryCache = new Map<string, Promise<JsActiveContract[]>>();\n    const queryAsParty = async (ref: ActiveContractRef): Promise<JsActiveContract[]> => {\n        const party = resolveQueryParty(ref);\n        const cacheKey = JSON.stringify({ ...ref, party });\n        const cached = queryCache.get(cacheKey);\n        if (cached) return cached;\n\n        const query = (async () => {\n            const contracts = await queryLiveContractsForRef(client, party, ref);\n            if (contracts.length === 0) {\n                throw new NonRetryableError(\n                    `Party ${party} has no matching active contracts of ${ref.templateId}`,\n                );\n            }\n            return contracts;\n        })();\n        queryCache.set(cacheKey, query);\n        return query;\n    };\n\n    // A signing party that is already a stakeholder can see the contract on its\n    // own stream, so only disclose to parties that aren't signatories/observers.\n    const needsDisclosure = (contract: JsActiveContract): boolean => {\n        const stakeholders = new Set([\n            ...(contract.createdEvent.signatories ?? []),\n            ...(contract.createdEvent.observers ?? []),\n        ]);\n        return !signingParties.some((party) => stakeholders.has(party));\n    };\n\n    const discloseContracts = async (\n        ref: ActiveContractRef,\n        contracts: JsActiveContract[],\n    ): Promise<void> => {\n        const toDisclose = contracts.filter(needsDisclosure);\n        if (toDisclose.length === 0) return;\n\n        const party = resolveQueryParty(ref);\n        const disclosures = await Promise.all(\n            toDisclose.map(async (contract) => {\n                const contractId = contract.createdEvent.contractId;\n                const disclosure = await client.createDisclosure(\n                    contractId as ContractId<unknown>,\n                    [party],\n                );\n                if (!disclosure) {\n                    throw new NonRetryableError(\n                        `Could not disclose ${contractId} (template ${ref.templateId}) — no longer active`,\n                    );\n                }\n                return disclosure;\n            }),\n        );\n        appendDisclosures(disclosures);\n    };\n\n    const resolveActiveContractId = async (ref: ActiveContractRef): Promise<string> => {\n        const contracts = await queryAsParty(ref);\n        if (contracts.length !== 1) {\n            throw new NonRetryableError(\n                `Refresh for ${ref.templateId} matched ${contracts.length} contracts, but a scalar ref expects exactly one`,\n            );\n        }\n        await discloseContracts(ref, contracts);\n        return contracts[0]!.createdEvent.contractId;\n    };\n\n    const resolveActiveContractIds = async (ref: ActiveContractRef): Promise<string[]> => {\n        const contracts = await queryAsParty(ref);\n        await discloseContracts(ref, contracts);\n        return contracts.map((contract) => contract.createdEvent.contractId);\n    };\n\n    return { resolveActiveContractId, resolveActiveContractIds, requireSenderParty: requireSender };\n};\n"]}

package/dist/Z35TKEFU.js

@@ -1,68 +0,0 @@
-import { __name } from './VUOMXK5T.js';
-import { z } from 'zod';
-
-var cantonRefreshPartyFilterSchema = z.union([
-  z.literal("sender"),
-  z.object({
-    party: z.string()
-  })
-]);
-var cantonDeferredValueSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("senderParty")
-  }),
-  z.object({
-    type: z.literal("activeContractId"),
-    partyToFilter: cantonRefreshPartyFilterSchema,
-    templateId: z.string(),
-    contractStateFilter: z.partialRecord(z.string(), z.any()).optional()
-  }),
-  z.object({
-    type: z.literal("activeContractIds"),
-    partyToFilter: cantonRefreshPartyFilterSchema,
-    templateId: z.string(),
-    contractStateFilter: z.partialRecord(z.string(), z.any()).optional()
-  }),
-  z.object({
-    type: z.literal("amuletRulesCid")
-  }),
-  z.object({
-    type: z.literal("amuletContext")
-  })
-]);
-var CANTON_DEFERRED_VALUE_PREFIX = "<<CANTON_DEFERRED:";
-var CANTON_DEFERRED_VALUE_SUFFIX = ">>";
-var encodeCantonDeferredValue = /* @__PURE__ */ __name((value) => `${CANTON_DEFERRED_VALUE_PREFIX}${JSON.stringify(value)}${CANTON_DEFERRED_VALUE_SUFFIX}`, "encodeCantonDeferredValue");
-var parseCantonDeferredValue = /* @__PURE__ */ __name((value) => {
-  if (typeof value !== "string" || !value.startsWith(CANTON_DEFERRED_VALUE_PREFIX) || !value.endsWith(CANTON_DEFERRED_VALUE_SUFFIX)) {
-    return void 0;
-  }
-  try {
-    const parsedJson = JSON.parse(value.slice(CANTON_DEFERRED_VALUE_PREFIX.length, -CANTON_DEFERRED_VALUE_SUFFIX.length));
-    return cantonDeferredValueSchema.parse(parsedJson);
-  } catch {
-    return void 0;
-  }
-}, "parseCantonDeferredValue");
-var cantonSenderPartyRef = /* @__PURE__ */ __name(() => encodeCantonDeferredValue({
-  type: "senderParty"
-}), "cantonSenderPartyRef");
-var cantonActiveContractIdRef = /* @__PURE__ */ __name((value) => encodeCantonDeferredValue({
-  type: "activeContractId",
-  ...value
-}), "cantonActiveContractIdRef");
-var cantonActiveContractIdsRef = /* @__PURE__ */ __name((value) => encodeCantonDeferredValue({
-  type: "activeContractIds",
-  ...value
-}), "cantonActiveContractIdsRef");
-var cantonAmuletRulesCidRef = /* @__PURE__ */ __name(() => encodeCantonDeferredValue({
-  type: "amuletRulesCid"
-}), "cantonAmuletRulesCidRef");
-var cantonAmuletContextRef = /* @__PURE__ */ __name(() => encodeCantonDeferredValue({
-  type: "amuletContext"
-}), "cantonAmuletContextRef");
-var isCantonPlaceholder = /* @__PURE__ */ __name((value) => parseCantonDeferredValue(value) !== void 0, "isCantonPlaceholder");
-
-export { CANTON_DEFERRED_VALUE_PREFIX, CANTON_DEFERRED_VALUE_SUFFIX, cantonActiveContractIdRef, cantonActiveContractIdsRef, cantonAmuletContextRef, cantonAmuletRulesCidRef, cantonDeferredValueSchema, cantonRefreshPartyFilterSchema, cantonSenderPartyRef, encodeCantonDeferredValue, isCantonPlaceholder, parseCantonDeferredValue };
-//# sourceMappingURL=Z35TKEFU.js.map
-//# sourceMappingURL=Z35TKEFU.js.map

package/dist/Z35TKEFU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/deferredValue.ts"],"names":["cantonRefreshPartyFilterSchema","z","union","literal","object","party","string","cantonDeferredValueSchema","discriminatedUnion","type","partyToFilter","templateId","contractStateFilter","partialRecord","any","optional","CANTON_DEFERRED_VALUE_PREFIX","CANTON_DEFERRED_VALUE_SUFFIX","encodeCantonDeferredValue","value","JSON","stringify","parseCantonDeferredValue","startsWith","endsWith","undefined","parsedJson","parse","slice","length","cantonSenderPartyRef","cantonActiveContractIdRef","cantonActiveContractIdsRef","cantonAmuletRulesCidRef","cantonAmuletContextRef","isCantonPlaceholder"],"mappings":"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","file":"Z35TKEFU.js","sourcesContent":["import { z } from 'zod';\n\nexport const cantonRefreshPartyFilterSchema = z.union([\n    z.literal('sender'),\n    z.object({ party: z.string() }),\n]);\n\nexport const cantonDeferredValueSchema = z.discriminatedUnion('type', [\n    z.object({ type: z.literal('senderParty') }),\n    z.object({\n        type: z.literal('activeContractId'),\n        partyToFilter: cantonRefreshPartyFilterSchema,\n        templateId: z.string(),\n        contractStateFilter: z.partialRecord(z.string(), z.any()).optional(),\n    }),\n    z.object({\n        type: z.literal('activeContractIds'),\n        partyToFilter: cantonRefreshPartyFilterSchema,\n        templateId: z.string(),\n        contractStateFilter: z.partialRecord(z.string(), z.any()).optional(),\n    }),\n    z.object({ type: z.literal('amuletRulesCid') }),\n    z.object({ type: z.literal('amuletContext') }),\n]);\n\nexport type CantonRefreshPartyFilter = z.infer<typeof cantonRefreshPartyFilterSchema>;\nexport type CantonDeferredValue = z.infer<typeof cantonDeferredValueSchema>;\ntype CantonActiveContractIdRef = Omit<\n    Extract<CantonDeferredValue, { type: 'activeContractId' }>,\n    'type'\n>;\ntype CantonActiveContractIdsRef = Omit<\n    Extract<CantonDeferredValue, { type: 'activeContractIds' }>,\n    'type'\n>;\n\n/**\n * Branded encoded form of a {@link CantonDeferredValue}: a sign-time reference\n * string that a resolver turns into a live contract id / party. Branding keeps it\n * distinct from a plain `string` so the ref-substitution stays type-checked.\n */\nexport type CantonDeferredRef = string & { readonly __cantonDeferredRef: unique symbol };\n\nexport const CANTON_DEFERRED_VALUE_PREFIX = '<<CANTON_DEFERRED:';\nexport const CANTON_DEFERRED_VALUE_SUFFIX = '>>';\n\nexport const encodeCantonDeferredValue = (value: CantonDeferredValue): CantonDeferredRef =>\n    `${CANTON_DEFERRED_VALUE_PREFIX}${JSON.stringify(value)}${CANTON_DEFERRED_VALUE_SUFFIX}` as CantonDeferredRef;\n\nexport const parseCantonDeferredValue = (value: unknown): CantonDeferredValue | undefined => {\n    if (\n        typeof value !== 'string' ||\n        !value.startsWith(CANTON_DEFERRED_VALUE_PREFIX) ||\n        !value.endsWith(CANTON_DEFERRED_VALUE_SUFFIX)\n    ) {\n        return undefined;\n    }\n\n    try {\n        const parsedJson = JSON.parse(\n            value.slice(CANTON_DEFERRED_VALUE_PREFIX.length, -CANTON_DEFERRED_VALUE_SUFFIX.length),\n        );\n        return cantonDeferredValueSchema.parse(parsedJson);\n    } catch {\n        return undefined;\n    }\n};\n\nexport const cantonSenderPartyRef = (): CantonDeferredRef =>\n    encodeCantonDeferredValue({ type: 'senderParty' });\n\nexport const cantonActiveContractIdRef = (value: CantonActiveContractIdRef): CantonDeferredRef =>\n    encodeCantonDeferredValue({ type: 'activeContractId', ...value });\n\nexport const cantonActiveContractIdsRef = (value: CantonActiveContractIdsRef): CantonDeferredRef =>\n    encodeCantonDeferredValue({ type: 'activeContractIds', ...value });\n\nexport const cantonAmuletRulesCidRef = (): CantonDeferredRef =>\n    encodeCantonDeferredValue({ type: 'amuletRulesCid' });\n\nexport const cantonAmuletContextRef = (): CantonDeferredRef =>\n    encodeCantonDeferredValue({ type: 'amuletContext' });\n\n/** Returns true if `value` is a Canton deferred-value sentinel. */\nexport const isCantonPlaceholder = (value: string): boolean =>\n    parseCantonDeferredValue(value) !== undefined;\n"]}