@layerzerolabs/common-canton 0.2.106 → 0.2.108

package/dist/transaction.d.ts

@@ -33,6 +33,16 @@ export declare const cantonDisclosedContractSchema: z.ZodObject<{
     createdEventBlob: z.ZodString;
     synchronizerId: z.ZodString;
 }, z.core.$strip>;
+/** Whose Active Contract Set a refresh entry is queried against:
+ *  - `'sender'`: the deferred register sender, resolved at sign time. Correct for
+ *    contracts the sender is a stakeholder of (e.g. its own amulet holdings).
+ *  - `{ party }`: an explicit stakeholder party known at build time. Needed for
+ *    contracts the sender cannot see — e.g. a signatory-controlled
+ *    RequestFactoryConfig, which only its handler (the signatory) is guaranteed
+ *    to have in its ACS. */
+export declare const refreshPartyFilterSchema: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+    party: z.ZodString;
+}, z.core.$strip>]>;
 /**
  * Declarative description of ledger contracts the building factory deferred to sign
  * time, resolved by a generic ledger-query refresh executor. (The amulet fee context is
@@ -41,13 +51,17 @@ export declare const cantonDisclosedContractSchema: z.ZodObject<{
  */
 export declare const cantonRefreshSpecSchema: z.ZodObject<{
     commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        partyToFilter: z.ZodLiteral<"sender">;
+        partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+            party: z.ZodString;
+        }, z.core.$strip>]>;
         templateId: z.ZodString;
         placeholder: z.ZodString;
         multiple: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
     disclosedContracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        partyToFilter: z.ZodLiteral<"sender">;
+        partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+            party: z.ZodString;
+        }, z.core.$strip>]>;
         templateId: z.ZodString;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
@@ -108,13 +122,17 @@ export declare const cantonTransactionSchema: z.ZodObject<{
         partyToSenderEntity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         refreshSpec: z.ZodOptional<z.ZodObject<{
             commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
                 placeholder: z.ZodString;
                 multiple: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
             disclosedContracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
@@ -185,13 +203,17 @@ export declare const cantonAssignedTransactionSchema: z.ZodObject<{
         partyToSenderEntity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         refreshSpec: z.ZodOptional<z.ZodObject<{
             commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
                 placeholder: z.ZodString;
                 multiple: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
             disclosedContracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
@@ -273,13 +295,17 @@ export declare const cantonSignedTransactionSchema: z.ZodObject<{
         partyToSenderEntity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         refreshSpec: z.ZodOptional<z.ZodObject<{
             commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
                 placeholder: z.ZodString;
                 multiple: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
             disclosedContracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
@@ -289,7 +315,9 @@ export declare const cantonSignedTransactionSchema: z.ZodObject<{
  * Mined transaction with confirmation result.
  */
 export declare const cantonMinedTransactionSchema: z.ZodObject<{
-    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    result: z.ZodDiscriminatedUnion<[z.
+    /** Template id to query. */
+    ZodObject<{
         type: z.ZodLiteral<"success">;
         minedTxHash: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -371,13 +399,17 @@ export declare const cantonMinedTransactionSchema: z.ZodObject<{
         partyToSenderEntity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         refreshSpec: z.ZodOptional<z.ZodObject<{
             commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
                 placeholder: z.ZodString;
                 multiple: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
             disclosedContracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                partyToFilter: z.ZodLiteral<"sender">;
+                partyToFilter: z.ZodUnion<readonly [z.ZodLiteral<"sender">, z.ZodObject<{
+                    party: z.ZodString;
+                }, z.core.$strip>]>;
                 templateId: z.ZodString;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"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"}

package/dist/transaction.js

@@ -1,4 +1,4 @@
-export { buildCantonTransaction, cantonAssignedTransactionSchema, cantonCommandSchema, cantonDisclosedContractSchema, cantonMinedTransactionSchema, cantonRefreshSpecSchema, cantonSignedTransactionSchema, cantonTransactionSchema } from './3YCNHEVD.js';
+export { buildCantonTransaction, cantonAssignedTransactionSchema, cantonCommandSchema, cantonDisclosedContractSchema, cantonMinedTransactionSchema, cantonRefreshSpecSchema, cantonSignedTransactionSchema, cantonTransactionSchema, refreshPartyFilterSchema } from './ZYJRG5VO.js';
 import './VUOMXK5T.js';
 //# sourceMappingURL=transaction.js.map
 //# sourceMappingURL=transaction.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/common-canton",
-  "version": "0.2.106",
+  "version": "0.2.108",
   "private": false,
   "description": "Canton VM client and utilities",
   "license": "MIT",
@@ -21,9 +21,9 @@
     "@protobuf-ts/grpc-transport": "^2.9.4",
     "es-toolkit": "^1.39.10",
     "zod": "4.3.5",
-    "@layerzerolabs/common-chain-model": "0.2.106",
-    "@layerzerolabs/typescript-utils": "0.2.106",
-    "@layerzerolabs/common-error-utils": "0.2.106"
+    "@layerzerolabs/common-chain-model": "0.2.108",
+    "@layerzerolabs/common-error-utils": "0.2.108",
+    "@layerzerolabs/typescript-utils": "0.2.108"
   },
   "devDependencies": {
     "@types/node": "^22.18.6",
@@ -31,13 +31,13 @@
     "eslint": "9.39.1",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
-    "vitest": "^3.2.3",
-    "@layerzerolabs/eslint-configuration": "^0.2.106",
-    "@layerzerolabs/tsup-configuration": "0.2.106",
-    "@layerzerolabs/typescript-configuration": "0.2.106",
-    "@layerzerolabs/ver-signer-adapter": "0.2.106",
-    "@layerzerolabs/vitest-configuration": "0.2.106",
-    "@layerzerolabs/vm-tooling-canton": "0.2.106"
+    "vitest": "^3.2.4",
+    "@layerzerolabs/eslint-configuration": "^0.2.108",
+    "@layerzerolabs/tsup-configuration": "0.2.108",
+    "@layerzerolabs/typescript-configuration": "0.2.108",
+    "@layerzerolabs/vitest-configuration": "0.2.108",
+    "@layerzerolabs/ver-signer-adapter": "0.2.108",
+    "@layerzerolabs/vm-tooling-canton": "0.2.108"
   },
   "publishConfig": {
     "access": "restricted",

package/src/events.ts

@@ -1,7 +1,7 @@
 import { buildTransactionWithResultSchema } from '@layerzerolabs/common-chain-model';
 import { NonRetryableError } from '@layerzerolabs/common-error-utils';
 
-import type { ICantonClient } from './client';
+import type { CantonTransaction, ICantonClient } from './client';
 import type { CreatedEvent } from './open-api/models';
 import { cantonTransactionSchema } from './transaction';
 
@@ -132,85 +132,103 @@ export const cantonRegisterSucceeded = async (
 };
 
 /**
- * Wait for a Request contract to be archived AND determine accept vs reject
- * by inspecting which IRequest choice ran on it.
- *
- * IRequest_Accept and IRequest_Reject are nonconsuming choices that both end
- * with `archive reqCid` in their implementations. We can't tell accept from
- * reject from the archive alone — must look at the ExercisedEvent in the
- * archive transaction tree.
- *
- * On accept, returns the IRequest_Accept choice argument (the accept call
- * context, including `acceptContext`) so callers can extract the validator's
- * internal address from it.
- *
- * Throws NonRetryableError on rejection, on archival via a non-Accept/Reject
- * path (unexpected), or on timeout.
+ * Poll until `contractId` is archived, then return the transaction tree that
+ * archived it. Generic: knows nothing about which choice did the archiving.
+ * Throws NonRetryableError on timeout.
  */
-export const waitForRequestArchival = async (
+export const waitForArchival = async (
     client: ICantonClient,
-    requestContractId: string,
+    contractId: string,
     parties: string[],
-): Promise<unknown> => {
+): Promise<CantonTransaction> => {
     for (let attempt = 1; attempt <= REQUEST_ARCHIVAL_MAX_ATTEMPTS; attempt++) {
-        const { archived } = await client.fetchEventsByContractId(requestContractId, parties);
+        const { archived } = await client.fetchEventsByContractId(contractId, parties);
         if (archived) {
-            const transaction = await client.fetchTransactionByOffset(archived.offset, parties);
-            // IRequest_Accept and IRequest_Reject are *nonconsuming* interface
-            // choices on IRequest. Their template impls (Request.daml's
-            // request_AcceptImpl / request_RejectImpl) end with `archive reqCid`,
-            // which Canton records as a consuming exercise of the implicit
-            // `Archive` choice. So in the transaction tree we see TWO exercises
-            // on the Request contract:
-            //   - a non-consuming `IRequest_Accept` (or `IRequest_Reject`)
-            //   - a consuming `Archive` (the actual archival)
-            // Scan for any IRequest_Accept/Reject exercise on it in the
-            // tree to determine the outcome, regardless of which one consumed.
-            let interfaceChoice: string | undefined;
-            let interfaceArg: unknown;
-            let consumingChoice: string | undefined;
-            for (const event of transaction.events ?? []) {
-                if (!('ExercisedEvent' in event)) continue;
-                const ex = event.ExercisedEvent;
-                if (ex.contractId !== requestContractId) continue;
-                if (ex.choice === IREQUEST_ACCEPT_CHOICE || ex.choice === IREQUEST_REJECT_CHOICE) {
-                    interfaceChoice = ex.choice;
-                    interfaceArg = ex.choiceArgument;
-                }
-                if (ex.consuming) {
-                    consumingChoice = ex.choice;
-                }
-            }
-            if (interfaceChoice === IREQUEST_ACCEPT_CHOICE) {
-                return interfaceArg;
-            }
-            if (interfaceChoice === IREQUEST_REJECT_CHOICE) {
-                const rejectContext =
-                    typeof interfaceArg === 'object' &&
-                    interfaceArg !== null &&
-                    'rejectContext' in interfaceArg
-                        ? interfaceArg.rejectContext
-                        : undefined;
-                const reason = rejectContext
-                    ? JSON.stringify(rejectContext).slice(0, 500)
-                    : 'unknown';
-                throw new NonRetryableError(`Request rejected — rejectContext: ${reason}`);
-            }
-            // No IRequest_Accept/Reject ran on this Request — it was archived
-            // via some other path (default `Archive`, or another consuming
-            // choice). That's unexpected for register-style flows — treat as
-            // failure so we don't silently call this a success.
-            throw new NonRetryableError(
-                `Request ${requestContractId} archived via unexpected choice ${consumingChoice ?? '<none>'}`,
-            );
+            return client.fetchTransactionByOffset(archived.offset, parties);
         }
-        // Skip the sleep on the final attempt — there's no next iteration to
-        // wait for, so it would only delay the timeout error pointlessly.
+        // Skip the sleep on the final attempt — there's no next iteration to wait for.
         if (attempt < REQUEST_ARCHIVAL_MAX_ATTEMPTS) {
             await new Promise((resolve) => setTimeout(resolve, REQUEST_ARCHIVAL_POLL_INTERVAL_MS));
         }
     }
     throw new NonRetryableError(
-        `Request archival timeout (${REQUEST_ARCHIVAL_MAX_ATTEMPTS} attempts) for ${requestContractId}`,
+        `Archival timeout (${REQUEST_ARCHIVAL_MAX_ATTEMPTS} attempts) for ${contractId}`,
+    );
+};
+
+/**
+ * Return the argument of the first exercise of `choice` on `contractId` in a
+ * transaction tree, typed as the caller expects. Generic over choice and arg
+ * type; returns undefined when no such exercise is present.
+ */
+export const getExercisedChoiceArgument = <TArg = unknown>(
+    transaction: CantonTransaction,
+    contractId: string,
+    choice: string,
+): TArg | undefined => {
+    for (const event of transaction.events ?? []) {
+        if (!('ExercisedEvent' in event)) continue;
+        const { ExercisedEvent: exercised } = event;
+        if (exercised.contractId === contractId && exercised.choice === choice) {
+            return exercised.choiceArgument as TArg;
+        }
+    }
+    return undefined;
+};
+
+/**
+ * Wait for a Request to be archived and confirm it was accepted, returning the
+ * IRequest_Accept choice argument typed as `TAccept` (callers pass the codegen
+ * `IRequest_Accept` type to get `acceptContext` typed).
+ *
+ * IRequest_Accept and IRequest_Reject both end with `archive reqCid` in their
+ * Daml impls, so the archive alone can't distinguish them — the choice is read
+ * off the archive transaction tree. Throws NonRetryableError on rejection, on
+ * archival via any other choice (unexpected), or on timeout.
+ */
+export const waitForRequestArchival = async <TAccept = unknown>(
+    client: ICantonClient,
+    requestContractId: string,
+    parties: string[],
+): Promise<TAccept> => {
+    const transaction = await waitForArchival(client, requestContractId, parties);
+
+    const accept = getExercisedChoiceArgument<TAccept>(
+        transaction,
+        requestContractId,
+        IREQUEST_ACCEPT_CHOICE,
+    );
+    if (accept !== undefined) return accept;
+
+    const reject = getExercisedChoiceArgument<{ rejectContext?: unknown }>(
+        transaction,
+        requestContractId,
+        IREQUEST_REJECT_CHOICE,
+    );
+    if (reject !== undefined) {
+        const reason = reject.rejectContext
+            ? JSON.stringify(reject.rejectContext).slice(0, 500)
+            : 'unknown';
+        throw new NonRetryableError(`Request rejected — rejectContext: ${reason}`);
+    }
+
+    const consuming = getConsumingChoice(transaction, requestContractId);
+    throw new NonRetryableError(
+        `Request ${requestContractId} archived via unexpected choice ${consuming ?? '<none>'}`,
     );
 };
+
+/** Name of the consuming exercise on `contractId` in a transaction tree, if any. */
+const getConsumingChoice = (
+    transaction: CantonTransaction,
+    contractId: string,
+): string | undefined => {
+    for (const event of transaction.events ?? []) {
+        if (!('ExercisedEvent' in event)) continue;
+        const { ExercisedEvent: exercised } = event;
+        if (exercised.contractId === contractId && exercised.consuming) {
+            return exercised.choice;
+        }
+    }
+    return undefined;
+};

package/src/sdk/canton-sdk.ts

@@ -334,6 +334,16 @@ export class CantonSdk {
         return this.#client.listParties(opts);
     }
 
+    /**
+     * List the parties the configured user can act/read as.
+     *
+     * Narrower than {@link listParties} (all parties on the node): use this when a
+     * call needs the caller's own read-scoped parties.
+     */
+    listUserParties(): Promise<string[]> {
+        return this.#client.listUserParties();
+    }
+
     /**
      * Allocate a new party on the participant node.
      *

package/src/senderPlaceholder.ts

@@ -99,6 +99,11 @@ export const CANTON_AMULET_CONTEXT_PLACEHOLDER = '<<CANTON_AMULET_CONTEXT_PLACEH
  *  freshly-fetched amulet fee bundle at sign time. */
 export const CANTON_AMULET_RULES_CID_PLACEHOLDER = '<<CANTON_AMULET_RULES_CID_PLACEHOLDER>>';
 
+/** Sentinel for a RequestFactoryConfig contract id, swapped for the sender's
+ *  active config CID at sign time so a re-deploy doesn't strand a baked-in id. */
+export const CANTON_REQUEST_FACTORY_CONFIG_CID_PLACEHOLDER =
+    '<<CANTON_REQUEST_FACTORY_CONFIG_CID_PLACEHOLDER>>';
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Generic placeholder helpers (sentinel-agnostic)
 //
@@ -107,6 +112,12 @@ export const CANTON_AMULET_RULES_CID_PLACEHOLDER = '<<CANTON_AMULET_RULES_CID_PL
 // hardcoding it here — keeping these helpers free of any contract knowledge.
 // ─────────────────────────────────────────────────────────────────────────────
 
+/** Returns true if `value` is any Canton sign-time sentinel — every placeholder
+ *  above uses the `<<…>>` wrapper, so callers can defer a cid's resolution
+ *  without matching a specific constant. */
+export const isCantonPlaceholder = (value: string): boolean =>
+    value.startsWith('<<') && value.endsWith('>>');
+
 /** Returns true if any scalar leaf in the tree equals `placeholder`. */
 export const containsPlaceholderValue = (value: unknown, placeholder: string): boolean =>
     containsLeaf(value, (leaf) => leaf === placeholder);

package/src/transaction.ts

@@ -53,11 +53,23 @@ export const cantonDisclosedContractSchema = z.object({
     synchronizerId: z.string(),
 });
 
+/** Whose Active Contract Set a refresh entry is queried against:
+ *  - `'sender'`: the deferred register sender, resolved at sign time. Correct for
+ *    contracts the sender is a stakeholder of (e.g. its own amulet holdings).
+ *  - `{ party }`: an explicit stakeholder party known at build time. Needed for
+ *    contracts the sender cannot see — e.g. a signatory-controlled
+ *    RequestFactoryConfig, which only its handler (the signatory) is guaranteed
+ *    to have in its ACS. */
+export const refreshPartyFilterSchema = z.union([
+    z.literal('sender'),
+    z.object({ party: z.string() }),
+]);
+
 /** A contract located by an Active Contract Set query, run as a party that can see
- *  it (the sender for holdings; a config admin for OFT/RequestFactory/… later). */
+ *  it (the sender for holdings; a config's handler/admin for RequestFactory/OFT). */
 const ledgerRefreshEntrySchema = z.object({
-    /** Party whose Active Contract Set to query; resolved at sign time. */
-    partyToFilter: z.literal('sender'),
+    /** Party whose Active Contract Set to query. `'sender'` is resolved at sign time. */
+    partyToFilter: refreshPartyFilterSchema,
     /** Template id to query. */
     templateId: z.string(),
 });
@@ -81,8 +93,8 @@ export const cantonRefreshSpecSchema = z.object({
             }),
         )
         .optional(),
-    /** Contracts fetched via a ledger query (run as the sender) and appended to
-     *  disclosedContracts. */
+    /** Contracts fetched via a ledger query (run as each entry's `partyToFilter`)
+     *  and appended to disclosedContracts. */
     disclosedContracts: z.array(ledgerRefreshEntrySchema).optional(),
 });
 

package/dist/3YCNHEVD.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/transaction.ts"],"names":["createCommandSchema","z","object","templateId","string","createArguments","any","exerciseCommandSchema","contractId","choice","choiceArgument","createAndExerciseCommandSchema","exerciseByKeyCommandSchema","contractKey","cantonCommandSchema","union","createCommand","exerciseCommand","createAndExerciseCommand","exerciseByKeyCommand","cantonDisclosedContractSchema","optional","createdEventBlob","synchronizerId","ledgerRefreshEntrySchema","partyToFilter","literal","cantonRefreshSpecSchema","commands","array","extend","placeholder","multiple","boolean","disclosedContracts","cantonInflightTransactionSchema","preparedTransaction","preparedTransactionHash","hashingSchemeVersion","enum","commandId","completionOffset","number","cantonTransactionSchema","transactionSchema","populatedTransaction","actAs","partyToSenderEntity","record","refreshSpec","cantonAssignedTransactionSchema","assignedTransactionSchema","shape","inflightTransaction","cantonSignedTransactionSchema","signedTransactionSchema","signedTransaction","signatures","party","format","signature","signedBy","signingAlgorithmSpec","cantonMinedTransactionSchema","minedTransactionSchema","buildCantonTransaction","chainName","tx","timestamps","created","Date","now"],"mappings":"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","file":"3YCNHEVD.js","sourcesContent":["import { z } from 'zod';\n\nimport {\n    assignedTransactionSchema,\n    minedTransactionSchema,\n    signedTransactionSchema,\n    transactionSchema,\n} from '@layerzerolabs/common-chain-model';\nimport type { PartialBy } from '@layerzerolabs/typescript-utils';\n\n// === Component schemas ===\n\n// Payload fields (createArguments, choiceArgument, contractKey) are z.any() —\n// arbitrary Daml values whose shape depends on the template.\n\nconst createCommandSchema = z.object({\n    templateId: z.string(),\n    createArguments: z.any(),\n});\n\nconst exerciseCommandSchema = z.object({\n    templateId: z.string(),\n    contractId: z.string(),\n    choice: z.string(),\n    choiceArgument: z.any(),\n});\n\nconst createAndExerciseCommandSchema = z.object({\n    templateId: z.string(),\n    createArguments: z.any(),\n    choice: z.string(),\n    choiceArgument: z.any(),\n});\n\nconst exerciseByKeyCommandSchema = z.object({\n    templateId: z.string(),\n    contractKey: z.any(),\n    choice: z.string(),\n    choiceArgument: z.any(),\n});\n\nexport const cantonCommandSchema = z.union([\n    z.object({ createCommand: createCommandSchema }),\n    z.object({ exerciseCommand: exerciseCommandSchema }),\n    z.object({ createAndExerciseCommand: createAndExerciseCommandSchema }),\n    z.object({ exerciseByKeyCommand: exerciseByKeyCommandSchema }),\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/** A contract located by an Active Contract Set query, run as a party that can see\n *  it (the sender for holdings; a config admin for OFT/RequestFactory/… later). */\nconst ledgerRefreshEntrySchema = z.object({\n    /** Party whose Active Contract Set to query; resolved at sign time. */\n    partyToFilter: z.literal('sender'),\n    /** Template id to query. */\n    templateId: z.string(),\n});\n\n/**\n * Declarative description of ledger contracts the building factory deferred to sign\n * time, resolved by a generic ledger-query refresh executor. (The amulet fee context is\n * refreshed automatically when a command carries its placeholder, so it isn't declared\n * here.)\n */\nexport const cantonRefreshSpecSchema = z.object({\n    /** Command-tree placeholders, each replaced with the contract id(s) from a ledger query. */\n    commands: z\n        .array(\n            ledgerRefreshEntrySchema.extend({\n                /** Sentinel to replace in the command tree. */\n                placeholder: z.string(),\n                /** When true, the placeholder is replaced with the full array of resolved\n                 *  contract ids (e.g. amulet holdings); otherwise with the single id. */\n                multiple: z.boolean().optional(),\n            }),\n        )\n        .optional(),\n    /** Contracts fetched via a ledger query (run as the sender) and appended to\n     *  disclosedContracts. */\n    disclosedContracts: z.array(ledgerRefreshEntrySchema).optional(),\n});\n\nexport type CantonRefreshSpec = z.infer<typeof cantonRefreshSpecSchema>;\n\n/** Output of prepareForSigning — needed by submitSigned to execute the transaction. */\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// === Lifecycle schemas ===\n\n/**\n * Canton transaction schema for Daml Ledger API commands.\n *\n * Canton uses an interactive submission (prepare-sign-submit) flow for external party signing.\n * The populatedTransaction contains the commands to send to prepareForSigning.\n */\nexport const cantonTransactionSchema = transactionSchema.extend({\n    populatedTransaction: z.object({\n        /** Parties submitting the command (actAs) */\n        actAs: z.array(z.string()),\n        /** Daml commands to send to prepareForSigning */\n        commands: z.array(cantonCommandSchema),\n        /** Disclosed contracts for contract/key lookups */\n        disclosedContracts: z.array(cantonDisclosedContractSchema),\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; by sign time every actAs party must map, or signing throws.\n         *  Multiple entries = a multisig party (decentralized namespace) whose keys must\n         *  all sign. */\n        partyToSenderEntity: z.record(z.string(), z.array(z.string())).optional(),\n        /** Sign-time refresh spec for placeholders the building factory deferred\n         *  (e.g. amulet input holdings, disclosures, time-sensitive choice context).\n         *  Resolved by the generic refresh executor before prepareForSigning. */\n        refreshSpec: cantonRefreshSpecSchema.optional(),\n    }),\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    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// === Types ===\n\nexport type CantonTx = z.infer<typeof cantonTransactionSchema>;\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/KEGAENCF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sdk/canton-sdk.ts"],"names":["CantonSdk","client","event","contractId","undefined","templateId","CantonProtocolError","createArgument","payload","buildCreate","template","packageId","parts","replace","split","createCommand","join","createArguments","encode","buildExercise","choice","args","encodedArgs","argumentEncode","exerciseCommand","choiceName","choiceArgument","submit","actors","commands","opts","prepareForSigning","submitSigned","prepared","signatures","waitForCommand","commandId","get","parties","fetchContractById","fetchTransaction","updateId","fetchTransactionByUpdateId","fetchTransactionByOffset","offset","fetchEventsByContractId","createDisclosure","connectedSynchronizers","uploadDar","dar","validateDar","listParties","allocateParty","partyIdHint","getPackageId","packageName","getLedgerEndOffset","queryActiveContracts","party","normalizeActiveContract","contract","e","createdEvent","synchronizerId","queryActiveContractsByParties","templateIds","queryActiveContractsForParties","templateFilter","apiOpts","perPartyResults","Promise","all","map","partyId","seen","Set","result","contracts","c","cid","has","add","normalized","push"],"mappings":"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","file":"KEGAENCF.js","sourcesContent":["import type { Choice, ContractId, Party, Template } from '@daml/types';\n\nimport type { CantonTransaction, ICantonClient } from '../client/index';\nimport { CantonProtocolError } from '../errors';\nimport type {\n    ArchivedEvent,\n    Command,\n    CreatedEvent,\n    DisclosedContract,\n    JsActiveContract,\n} from '../open-api/models';\nimport type {\n    Contract,\n    ExternalSignature,\n    NormalizedActiveContract,\n    PreparedTransaction,\n    SubmitActors,\n    SubmitResult,\n    WaitOptions,\n    WaitResult,\n} from '../types';\n\n/**\n * High-level SDK for Canton/DAML contract operations.\n *\n * Users interact with this SDK, not CantonClient directly.\n *\n * @example\n * ```ts\n * import { CantonClient, CantonSdk } from '@layerzerolabs/common-canton';\n *\n * const client = new CantonClient(config, userId);\n * const sdk = new CantonSdk(client);\n *\n * await sdk.submit({ actAs: [party] }, [cmd]);\n * ```\n */\nexport class CantonSdk {\n    readonly #client: ICantonClient;\n\n    constructor(client: ICantonClient) {\n        this.#client = client;\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Private Helpers\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Validate and extract contract fields from a CreatedEvent.\n     * Returns undefined if event is undefined (contract not found).\n     */\n    #validateContractEvent<T extends object>(\n        event: { templateId?: string; contractId?: string; createArgument?: unknown } | undefined,\n        contractId: ContractId<T>,\n    ): Contract<T> | undefined {\n        if (!event) return undefined;\n\n        if (!event.templateId) {\n            throw new CantonProtocolError('Contract response missing templateId', {\n                contractId,\n            });\n        }\n        if (!event.contractId) {\n            throw new CantonProtocolError('Contract response missing contractId', {\n                contractId,\n            });\n        }\n        if (event.createArgument === undefined) {\n            throw new CantonProtocolError('Contract response missing createArgument', {\n                contractId,\n            });\n        }\n        return {\n            templateId: event.templateId,\n            contractId: event.contractId as ContractId<T>,\n            payload: event.createArgument as T,\n        };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Command Builders\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Build a create command using a generated DAML template.\n     *\n     * @param template The generated DAML template (e.g., StateCommitment)\n     * @param payload The contract payload\n     * @param packageId The package ID from the generated package's index.js\n     */\n    buildCreate<T extends object, K, I extends string>(\n        template: Template<T, K, I>,\n        payload: T,\n        packageId: string,\n    ): Command {\n        // Generated templateId format: '#packageName:Module:Entity'\n        // Canton API needs: 'packageId:Module:Entity'\n        const parts = template.templateId.replace(/^#/, '').split(':');\n        parts[0] = packageId;\n\n        return {\n            createCommand: {\n                templateId: parts.join(':'),\n                createArguments: template.encode(payload),\n            },\n        };\n    }\n\n    /**\n     * Build an exercise command using a generated DAML choice.\n     *\n     * @param choice The generated DAML choice (e.g., StateCommitment.Archive)\n     * @param contractId The contract ID to exercise on\n     * @param args The choice arguments\n     * @param packageId The package ID from the generated package's index.js\n     */\n    buildExercise<T extends object, C, R, K>(\n        choice: Choice<T, C, R, K>,\n        contractId: ContractId<T>,\n        args: C,\n        packageId: string,\n    ): Command {\n        // Generated templateId format: '#packageName:Module:Entity'\n        // Canton API needs: 'packageId:Module:Entity'\n        const parts = choice.template().templateId.replace(/^#/, '').split(':');\n        parts[0] = packageId;\n\n        const encodedArgs = choice.argumentEncode(args);\n\n        return {\n            exerciseCommand: {\n                templateId: parts.join(':'),\n                contractId,\n                choice: choice.choiceName,\n                choiceArgument: encodedArgs,\n            },\n        };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Submission (networked)\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Submit commands to the ledger.\n     */\n    submit(\n        actors: SubmitActors,\n        commands: Command[],\n        opts?: { disclosedContracts?: DisclosedContract[]; commandId?: string },\n    ): Promise<SubmitResult> {\n        return this.#client.submit(actors, commands, opts);\n    }\n\n    /**\n     * Prepare commands for off-chain signing by external parties.\n     */\n    prepareForSigning(\n        actors: SubmitActors,\n        commands: Command[],\n        opts?: { disclosedContracts?: DisclosedContract[]; commandId?: string },\n    ): Promise<PreparedTransaction> {\n        return this.#client.prepareForSigning(actors, commands, opts);\n    }\n\n    /**\n     * Submit a pre-signed transaction (external party flow).\n     */\n    submitSigned(\n        prepared: PreparedTransaction,\n        signatures: ExternalSignature[],\n    ): Promise<SubmitResult> {\n        return this.#client.submitSigned(prepared, signatures);\n    }\n\n    /**\n     * Wait for a command to be accepted or rejected.\n     */\n    waitForCommand(commandId: string, opts: WaitOptions): Promise<WaitResult> {\n        return this.#client.waitForCommand(commandId, opts);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Queries\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Fetch a specific contract by ID.\n     * Returns undefined if archived or not visible.\n     *\n     * @param contractId The contract ID to fetch\n     * @param parties Parties to use for visibility filtering\n     */\n    async get<T extends object>(\n        contractId: ContractId<T>,\n        parties: Party[],\n    ): Promise<Contract<T> | undefined> {\n        const event = await this.#client.fetchContractById(contractId, parties);\n        return this.#validateContractEvent(event, contractId);\n    }\n\n    /**\n     * Fetch an update (transaction) by its ID.\n     *\n     * Use this to get created contract IDs after a command is accepted.\n     * The updateId comes from WaitResult.updateId.\n     *\n     * @param updateId The update ID from WaitResult\n     * @param parties Parties to filter events\n     * @returns Parsed update with events\n     *\n     * @example\n     * ```ts\n     * const waitResult = await sdk.waitForCommand(commandId, opts);\n     * if (waitResult.status === 'accepted') {\n     *     const tx = await sdk.fetchTransaction(waitResult.updateId, [party]);\n     *     const createdIds = (tx.events ?? [])\n     *         .filter(e => 'CreatedEvent' in e)\n     *         .map(e => e.CreatedEvent.contractId);\n     * }\n     * ```\n     */\n    fetchTransaction(updateId: string, parties: string[]): Promise<CantonTransaction> {\n        return this.#client.fetchTransactionByUpdateId(updateId, parties);\n    }\n\n    /**\n     * Fetch a transaction by its offset.\n     *\n     * @param offset The ledger offset\n     * @param parties Parties to filter events\n     * @returns Parsed transaction with events and timestamps\n     */\n    fetchTransactionByOffset(offset: number, parties: string[]): Promise<CantonTransaction> {\n        return this.#client.fetchTransactionByOffset(offset, parties);\n    }\n\n    /**\n     * Fetch both the created and archived events for a contract by ID.\n     *\n     * @param contractId - The contract ID to look up\n     * @param parties - Parties to use for visibility filtering\n     */\n    fetchEventsByContractId(\n        contractId: string,\n        parties: string[],\n    ): Promise<{ created: CreatedEvent | undefined; archived: ArchivedEvent | undefined }> {\n        return this.#client.fetchEventsByContractId(contractId, parties);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Disclosure\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Create a disclosure for a contract.\n     *\n     * Disclosures allow a party to share a contract's content with another party\n     * who isn't a stakeholder, enabling them to exercise choices that reference it.\n     *\n     * @param contractId The contract to create disclosure for\n     * @param parties Parties that have visibility to the contract\n     * @returns The disclosed contract, or undefined if contract not found\n     *\n     * @example\n     * ```ts\n     * // Alice creates disclosure for Bob to use\n     * const disclosure = await aliceSdk.createDisclosure(contractId, [aliceParty]);\n     * if (disclosure) {\n     *     // Bob uses the disclosure in his submission\n     *     await bobSdk.submit(\n     *         { actAs: [bobParty] },\n     *         [command],\n     *         { disclosedContracts: [disclosure] }\n     *     );\n     * }\n     * ```\n     */\n    createDisclosure<T extends object>(\n        contractId: ContractId<T>,\n        parties: Party[],\n    ): Promise<DisclosedContract | undefined> {\n        return this.#client.createDisclosure(contractId, parties);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Utilities\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Get connected synchronizers.\n     */\n    connectedSynchronizers(): Promise<string[]> {\n        return this.#client.connectedSynchronizers();\n    }\n\n    /**\n     * Upload a DAR to the participant node.\n     *\n     * POST /v2/dars\n     *\n     * @param opts.skipIfVetted - If true, treat KNOWN_PACKAGE_VERSION errors as success\n     */\n    uploadDar(\n        dar: Uint8Array<ArrayBuffer>,\n        opts?: { vetAllPackages?: boolean; synchronizerId?: string; skipIfVetted?: boolean },\n    ): Promise<object> {\n        return this.#client.uploadDar(dar, opts);\n    }\n\n    /**\n     * Validate a DAR for upgrade compatibility against the current vetting state.\n     *\n     * POST /v2/dars/validate\n     */\n    validateDar(dar: Uint8Array<ArrayBuffer>, opts?: { synchronizerId?: string }): Promise<void> {\n        return this.#client.validateDar(dar, opts);\n    }\n\n    /**\n     * List all known parties on the participant node.\n     *\n     * GET /v2/parties\n     *\n     * @param opts.pageSize - Maximum number of results per page\n     * @param opts.pageToken - Pagination token from previous response\n     * @returns Array of party IDs\n     */\n    listParties(opts?: {\n        pageSize?: number;\n        pageToken?: string;\n    }): Promise<{ parties: string[]; nextPageToken: string }> {\n        return this.#client.listParties(opts);\n    }\n\n    /**\n     * Allocate a new party on the participant node.\n     *\n     * POST /v2/parties\n     *\n     * @param partyIdHint - A hint for the party ID (e.g., \"alice\", \"bob\")\n     * @param opts.userId - User who gets actAs rights (empty string = no user)\n     * @param opts.synchronizerId - Synchronizer to allocate on (auto-detected if omitted)\n     * @param opts.identityProviderId - Identity provider ID (empty string = default)\n     * @returns The allocated party ID\n     */\n    allocateParty(\n        partyIdHint: string,\n        opts?: { userId?: string; synchronizerId?: string; identityProviderId?: string },\n    ): Promise<string> {\n        return this.#client.allocateParty(partyIdHint, opts);\n    }\n\n    /**\n     * Get the package ID for a package by name.\n     *\n     * POST /v2/interactive-submission/preferred-packages\n     *\n     * @param packageName - The package name (e.g., \"layerzero-oft\")\n     * @param parties - Parties whose vetting state should be considered\n     * @param opts.synchronizerId - Synchronizer to query (auto-detected if omitted)\n     * @returns The package ID (hash)\n     */\n    getPackageId(\n        packageName: string,\n        parties: string[],\n        opts?: { synchronizerId?: string },\n    ): Promise<string> {\n        return this.#client.getPackageId(packageName, parties, opts);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Active Contracts Query\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Get the current ledger end offset.\n     *\n     * GET /v2/state/ledger-end\n     *\n     * @returns The current ledger end offset\n     */\n    getLedgerEndOffset(): Promise<number> {\n        return this.#client.getLedgerEndOffset();\n    }\n\n    /**\n     * Query active contracts at a given offset with optional template filtering.\n     *\n     * POST /v2/state/active-contracts\n     *\n     * @param party - Party to query as (for visibility)\n     * @param offset - Ledger offset to query at\n     * @param opts.templateIds - Template IDs to filter by (e.g., \"packageId:Module:Template\")\n     * @param opts.limit - Maximum number of contracts to return\n     * @returns Array of active contracts\n     *\n     * @example\n     * ```ts\n     * const offset = await sdk.getLedgerEndOffset();\n     * const contracts = await sdk.queryActiveContracts(party, offset, {\n     *     templateIds: ['packageId:SimpleRequest:SimpleRequest'],\n     *     limit: 100,\n     * });\n     * for (const contract of contracts) {\n     *     console.log(contract.createdEvent.contractId, contract.createdEvent.templateId);\n     * }\n     * ```\n     */\n    queryActiveContracts(\n        party: string,\n        offset: number,\n        opts?: { templateIds?: string[]; limit?: number },\n    ): Promise<JsActiveContract[]> {\n        return this.#client.queryActiveContracts(party, offset, opts);\n    }\n\n    /**\n     * Normalize a ledger API JsActiveContract to a flat shape (contractId, templateId, payload, synchronizerId).\n     * Useful when you only need these fields and not createdEvent / reassignmentCounter.\n     */\n    static normalizeActiveContract(contract: JsActiveContract): NormalizedActiveContract {\n        const e = contract.createdEvent;\n        return {\n            contractId: e.contractId,\n            templateId: e.templateId,\n            payload: e.createArgument,\n            synchronizerId: contract.synchronizerId,\n        };\n    }\n\n    /**\n     * Query active contracts visible to any of the given parties (single API call).\n     */\n    queryActiveContractsByParties(\n        parties: string[],\n        offset: number,\n        templateIds: string[],\n        opts?: { limit?: number },\n    ): Promise<JsActiveContract[]> {\n        return this.#client.queryActiveContractsByParties(parties, offset, templateIds, opts);\n    }\n\n    /**\n     * Query active contracts visible to any of the given parties, deduplicated by contractId.\n     * Returns normalized contracts (flat shape). Use when you need a merged view across multiple parties.\n     *\n     * @param parties - Party IDs to query as (contracts visible to any party are included, each contract once)\n     * @param opts - Optional templateIds and limit (passed per-party to the ledger API); optional templateFilter (applied after fetch)\n     */\n    async queryActiveContractsForParties(\n        parties: string[],\n        opts?: {\n            templateIds?: string[];\n            limit?: number;\n            /** If provided, only contracts whose templateId passes this predicate are returned. */\n            templateFilter?: (templateId: string) => boolean;\n        },\n    ): Promise<NormalizedActiveContract[]> {\n        const offset = await this.#client.getLedgerEndOffset();\n        const { templateFilter, ...apiOpts } = opts ?? {};\n        const perPartyResults = await Promise.all(\n            parties.map((partyId) => this.#client.queryActiveContracts(partyId, offset, apiOpts)),\n        );\n        const seen = new Set<string>();\n        const result: NormalizedActiveContract[] = [];\n        for (const contracts of perPartyResults) {\n            for (const c of contracts) {\n                const cid = c.createdEvent.contractId;\n                if (!seen.has(cid)) {\n                    seen.add(cid);\n                    const normalized = CantonSdk.normalizeActiveContract(c);\n                    if (!templateFilter || templateFilter(normalized.templateId)) {\n                        result.push(normalized);\n                    }\n                }\n            }\n        }\n        return result;\n    }\n}\n"]}

package/dist/NO5PBPQH.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/events.ts"],"names":["cantonTxWithResultSchema","buildTransactionWithResultSchema","cantonTransactionSchema","REQUEST_ARCHIVAL_POLL_INTERVAL_MS","REQUEST_ARCHIVAL_MAX_ATTEMPTS","IREQUEST_ACCEPT_CHOICE","IREQUEST_REJECT_CHOICE","REQUEST_TEMPLATE_QUALIFIED_NAME","fetchCreatedEvents","client","updateId","parties","cantonTx","fetchTransactionByUpdateId","events","filter","event","map","CreatedEvent","findMatchingCreatedEvent","createdEvents","expectedTemplateId","expectedSignatories","expectedSet","Set","find","templateId","signatories","length","every","s","has","findMatchingCreatedEventFromTx","tx","parsed","safeParse","success","data","result","type","commands","actAs","populatedTransaction","minedTxHash","createCommand","cantonDeploymentSucceeded","txWithResult","cantonRegisterSucceeded","listUserParties","requestEvent","includes","waitForRequestArchival","contractId","requestContractId","attempt","archived","fetchEventsByContractId","transaction","fetchTransactionByOffset","offset","interfaceChoice","interfaceArg","consumingChoice","ex","ExercisedEvent","choice","choiceArgument","consuming","rejectContext","undefined","reason","JSON","stringify","slice","NonRetryableError","Promise","resolve","setTimeout"],"mappings":"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","file":"NO5PBPQH.js","sourcesContent":["import { buildTransactionWithResultSchema } from '@layerzerolabs/common-chain-model';\nimport { NonRetryableError } from '@layerzerolabs/common-error-utils';\n\nimport type { ICantonClient } from './client';\nimport type { CreatedEvent } from './open-api/models';\nimport { cantonTransactionSchema } from './transaction';\n\nconst cantonTxWithResultSchema = buildTransactionWithResultSchema(cantonTransactionSchema);\n\n// TODO(canton): confirm these poll values are enough to wait for archival across environments.\nconst REQUEST_ARCHIVAL_POLL_INTERVAL_MS = 2000;\nconst REQUEST_ARCHIVAL_MAX_ATTEMPTS = 60;\n\n// IRequest interface choices that consume the Request contract via `archive reqCid` in their impls.\nconst IREQUEST_ACCEPT_CHOICE = 'IRequest_Accept';\nconst IREQUEST_REJECT_CHOICE = 'IRequest_Reject';\n\nconst REQUEST_TEMPLATE_QUALIFIED_NAME = 'Request:Request';\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 * 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 * 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    if (!tx) return null;\n\n    const parsed = cantonTxWithResultSchema.safeParse(tx);\n    if (!parsed.success) return null;\n    if (parsed.data.result.type !== 'success') return null;\n\n    const { commands, actAs } = parsed.data.populatedTransaction;\n    const updateId = parsed.data.result.minedTxHash;\n\n    if (!updateId || !actAs.length) return null;\n\n    const createCommand = commands[0];\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 * Success check for register-style deploys (an exercise on Uln302 that creates a\n * Request, which the validator then accepts or rejects in a later transaction).\n *\n * Positively confirms acceptance: locate the Request created by this submission,\n * then delegate to waitForRequestArchival, which waits for the Request to be\n * archived and verifies the IRequest_Accept choice ran (throwing on reject,\n * unexpected archival, or timeout). This is a positive accept check rather than\n * inferring success from the absence of a rejection event.\n */\nexport const cantonRegisterSucceeded = async (\n    client: ICantonClient,\n    txWithResult: unknown,\n): Promise<boolean> => {\n    const parsed = cantonTxWithResultSchema.safeParse(txWithResult);\n    if (!parsed.success || parsed.data.result.type !== 'success') return false;\n\n    const updateId = parsed.data.result.minedTxHash;\n    if (!updateId) return false;\n\n    // Deferred-sender register payloads build with empty actAs (the sender is\n    // resolved at sign time), so fall back to the parties this user can read as.\n    const { actAs } = parsed.data.populatedTransaction;\n    const parties = actAs.length ? actAs : await client.listUserParties();\n    if (!parties.length) return false;\n\n    const createdEvents = await fetchCreatedEvents(client, updateId, parties);\n    const requestEvent = createdEvents.find((event) =>\n        event.templateId?.includes(REQUEST_TEMPLATE_QUALIFIED_NAME),\n    );\n    if (!requestEvent) return false;\n\n    try {\n        await waitForRequestArchival(client, requestEvent.contractId, parties);\n        return true;\n    } catch {\n        return false;\n    }\n};\n\n/**\n * Wait for a Request contract to be archived AND determine accept vs reject\n * by inspecting which IRequest choice ran on it.\n *\n * IRequest_Accept and IRequest_Reject are nonconsuming choices that both end\n * with `archive reqCid` in their implementations. We can't tell accept from\n * reject from the archive alone — must look at the ExercisedEvent in the\n * archive transaction tree.\n *\n * On accept, returns the IRequest_Accept choice argument (the accept call\n * context, including `acceptContext`) so callers can extract the validator's\n * internal address from it.\n *\n * Throws NonRetryableError on rejection, on archival via a non-Accept/Reject\n * path (unexpected), or on timeout.\n */\nexport const waitForRequestArchival = async (\n    client: ICantonClient,\n    requestContractId: string,\n    parties: string[],\n): Promise<unknown> => {\n    for (let attempt = 1; attempt <= REQUEST_ARCHIVAL_MAX_ATTEMPTS; attempt++) {\n        const { archived } = await client.fetchEventsByContractId(requestContractId, parties);\n        if (archived) {\n            const transaction = await client.fetchTransactionByOffset(archived.offset, parties);\n            // IRequest_Accept and IRequest_Reject are *nonconsuming* interface\n            // choices on IRequest. Their template impls (Request.daml's\n            // request_AcceptImpl / request_RejectImpl) end with `archive reqCid`,\n            // which Canton records as a consuming exercise of the implicit\n            // `Archive` choice. So in the transaction tree we see TWO exercises\n            // on the Request contract:\n            //   - a non-consuming `IRequest_Accept` (or `IRequest_Reject`)\n            //   - a consuming `Archive` (the actual archival)\n            // Scan for any IRequest_Accept/Reject exercise on it in the\n            // tree to determine the outcome, regardless of which one consumed.\n            let interfaceChoice: string | undefined;\n            let interfaceArg: unknown;\n            let consumingChoice: string | undefined;\n            for (const event of transaction.events ?? []) {\n                if (!('ExercisedEvent' in event)) continue;\n                const ex = event.ExercisedEvent;\n                if (ex.contractId !== requestContractId) continue;\n                if (ex.choice === IREQUEST_ACCEPT_CHOICE || ex.choice === IREQUEST_REJECT_CHOICE) {\n                    interfaceChoice = ex.choice;\n                    interfaceArg = ex.choiceArgument;\n                }\n                if (ex.consuming) {\n                    consumingChoice = ex.choice;\n                }\n            }\n            if (interfaceChoice === IREQUEST_ACCEPT_CHOICE) {\n                return interfaceArg;\n            }\n            if (interfaceChoice === IREQUEST_REJECT_CHOICE) {\n                const rejectContext =\n                    typeof interfaceArg === 'object' &&\n                    interfaceArg !== null &&\n                    'rejectContext' in interfaceArg\n                        ? interfaceArg.rejectContext\n                        : undefined;\n                const reason = rejectContext\n                    ? JSON.stringify(rejectContext).slice(0, 500)\n                    : 'unknown';\n                throw new NonRetryableError(`Request rejected — rejectContext: ${reason}`);\n            }\n            // No IRequest_Accept/Reject ran on this Request — it was archived\n            // via some other path (default `Archive`, or another consuming\n            // choice). That's unexpected for register-style flows — treat as\n            // failure so we don't silently call this a success.\n            throw new NonRetryableError(\n                `Request ${requestContractId} archived via unexpected choice ${consumingChoice ?? '<none>'}`,\n            );\n        }\n        // Skip the sleep on the final attempt — there's no next iteration to\n        // wait for, so it would only delay the timeout error pointlessly.\n        if (attempt < REQUEST_ARCHIVAL_MAX_ATTEMPTS) {\n            await new Promise((resolve) => setTimeout(resolve, REQUEST_ARCHIVAL_POLL_INTERVAL_MS));\n        }\n    }\n    throw new NonRetryableError(\n        `Request archival timeout (${REQUEST_ARCHIVAL_MAX_ATTEMPTS} attempts) for ${requestContractId}`,\n    );\n};\n"]}

package/dist/YVZO3C4U.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/senderPlaceholder.ts"],"names":["visit","value","replace","result","Array","isArray","map","item","mapValues","containsLeaf","predicate","some","Object","values","CANTON_SENDER_PLACEHOLDER","isCantonSenderPlaceholder","replaceCantonSenderPlaceholders","senderParty","leaf","undefined","containsCantonSenderPlaceholder","CANTON_AMULET_CIDS_PLACEHOLDER","isAmuletCidsPlaceholderArray","length","containsCantonAmuletCidsPlaceholder","replaceCantonAmuletCidsPlaceholder","amuletCids","CANTON_AMULET_CONTEXT_PLACEHOLDER","CANTON_AMULET_RULES_CID_PLACEHOLDER","containsPlaceholderValue","placeholder","replacePlaceholderValue","replacement"],"mappings":"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","file":"YVZO3C4U.js","sourcesContent":["import { mapValues } from 'es-toolkit';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Generic JSON-tree visitors\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Result of a leaf check: either the leaf has been replaced (with `value`),\n * or `undefined` to leave it alone and recurse into its children.\n */\ntype LeafResult = { value: unknown } | undefined;\n\n/** Walk a JSON value and rewrite leaves matched by `replace`; recursion stops at a swapped leaf. */\nconst visit = <T>(value: T, replace: (leaf: unknown) => LeafResult): T => {\n    const result = replace(value);\n    if (result) return result.value as T;\n    if (Array.isArray(value)) {\n        return value.map((item) => visit(item, replace)) as T;\n    }\n    if (value !== null && typeof value === 'object') {\n        return mapValues(value as Record<string, unknown>, (item) => visit(item, replace)) as T;\n    }\n    return value;\n};\n\n/** True if `predicate` matches any leaf or sub-value in the tree. */\nconst containsLeaf = (value: unknown, predicate: (leaf: unknown) => boolean): boolean => {\n    if (predicate(value)) return true;\n    if (Array.isArray(value)) return value.some((item) => containsLeaf(item, predicate));\n    return (\n        value !== null &&\n        typeof value === 'object' &&\n        Object.values(value).some((item) => containsLeaf(item, predicate))\n    );\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Sender placeholder\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Sentinel emitted in place of the sender `Party` when the sender is unknown at\n * create time; substituted for the real party at sign time.\n */\nexport const CANTON_SENDER_PLACEHOLDER = '<<CANTON_SENDER_PLACEHOLDER>>';\n\n/**\n * Returns true if `value` is the Canton sender placeholder.\n */\nexport const isCantonSenderPlaceholder = (value: string): boolean =>\n    value === CANTON_SENDER_PLACEHOLDER;\n\n/** Replace every {@link CANTON_SENDER_PLACEHOLDER} in a command tree with the actual sender party ID. */\nexport const replaceCantonSenderPlaceholders = <T>(value: T, senderParty: string): T =>\n    visit(value, (leaf) =>\n        leaf === CANTON_SENDER_PLACEHOLDER ? { value: senderParty } : undefined,\n    );\n\n/** Returns true if the command tree contains the sender placeholder anywhere. */\nexport const containsCantonSenderPlaceholder = (value: unknown): boolean =>\n    containsLeaf(value, (leaf) => leaf === CANTON_SENDER_PLACEHOLDER);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// AmuletCids placeholder\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Sentinel emitted as the sole element of the `amuletCids` array\n * (`amuletCids: [CANTON_AMULET_CIDS_PLACEHOLDER]`); substituted for the resolved\n * sender's Amulet contract IDs at sign time.\n */\nexport const CANTON_AMULET_CIDS_PLACEHOLDER = '<<CANTON_AMULET_CIDS_PLACEHOLDER>>';\n\nconst isAmuletCidsPlaceholderArray = (value: unknown): value is [string] =>\n    Array.isArray(value) && value.length === 1 && value[0] === CANTON_AMULET_CIDS_PLACEHOLDER;\n\n/**\n * Returns true if the command tree contains an amulet-cids placeholder array\n * anywhere — i.e. an array `[CANTON_AMULET_CIDS_PLACEHOLDER]`.\n */\nexport const containsCantonAmuletCidsPlaceholder = (value: unknown): boolean =>\n    containsLeaf(value, isAmuletCidsPlaceholderArray);\n\n/**\n * Recursively walks a JSON-serializable value and replaces every\n * `[CANTON_AMULET_CIDS_PLACEHOLDER]` array with the supplied list of resolved\n * Amulet contract IDs.\n */\nexport const replaceCantonAmuletCidsPlaceholder = <T>(value: T, amuletCids: string[]): T =>\n    visit(value, (leaf) =>\n        isAmuletCidsPlaceholderArray(leaf) ? { value: amuletCids } : undefined,\n    );\n\n/** Sentinel for a choice's `extraArgs.context`, replaced with the freshly-fetched\n *  amulet choice context at sign time. */\nexport const CANTON_AMULET_CONTEXT_PLACEHOLDER = '<<CANTON_AMULET_CONTEXT_PLACEHOLDER>>';\n\n/** Sentinel for the exercised ExternalPartyAmuletRules contract id, re-pinned to the\n *  freshly-fetched amulet fee bundle at sign time. */\nexport const CANTON_AMULET_RULES_CID_PLACEHOLDER = '<<CANTON_AMULET_RULES_CID_PLACEHOLDER>>';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Generic placeholder helpers (sentinel-agnostic)\n//\n// Used by the sign-time refresh executor, which receives the sentinel to match as\n// data (from the transaction's refreshSpec, or a known amulet sentinel) instead of\n// hardcoding it here — keeping these helpers free of any contract knowledge.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Returns true if any scalar leaf in the tree equals `placeholder`. */\nexport const containsPlaceholderValue = (value: unknown, placeholder: string): boolean =>\n    containsLeaf(value, (leaf) => leaf === placeholder);\n\n/** Replace every scalar sentinel leaf equal to `placeholder` with `replacement`. */\nexport const replacePlaceholderValue = <T>(\n    value: T,\n    placeholder: string,\n    replacement: unknown,\n): T => visit(value, (leaf) => (leaf === placeholder ? { value: replacement } : undefined));\n"]}