@layerzerolabs/common-canton 1.2.69 → 1.2.70

package/dist/MI3L7BKC.js

@@ -0,0 +1,915 @@
+import { DefaultApi } from './B42Y5JOK.js';
+import { JsActiveContractFromJSON } from './NIN7X4D3.js';
+import { ResponseError } from './KBNUN3MF.js';
+import { fetchDsoParty, fetchAmuletContext, injectExternalPartyAmuletRules } from './SEKD553P.js';
+import { CantonProtocolError, cantonApiErrorFromResponse, CantonTransportError, CantonApiError } from './3K5JL2TP.js';
+import { __name } from './VUOMXK5T.js';
+import { once } from 'es-toolkit';
+import { randomUUID } from 'crypto';
+
+var CantonClient = class {
+  static {
+    __name(this, "CantonClient");
+  }
+  #api;
+  #userId;
+  #wallet;
+  #dsoParty;
+  constructor(config, userId = "participant_admin", wallet) {
+    this.#api = new DefaultApi(config);
+    this.#userId = userId;
+    this.#wallet = wallet;
+  }
+  #requireWallet() {
+    if (!this.#wallet) {
+      throw new CantonProtocolError("CantonClient has no wallet config (walletUrl + tokenProvider); amulet endpoints are unavailable");
+    }
+    return this.#wallet;
+  }
+  async getDsoParty() {
+    const { walletUrl, tokenProvider } = this.#requireWallet();
+    if (this.#dsoParty) return this.#dsoParty;
+    this.#dsoParty = await fetchDsoParty(walletUrl, await tokenProvider.getToken());
+    return this.#dsoParty;
+  }
+  /** Amulet ChoiceContext with ExternalPartyAmuletRules injected — required by every flow hitting FeeUtils.validateContext. */
+  async getAmuletContextWithExternalRules(instrumentId) {
+    const { walletUrl, tokenProvider } = this.#requireWallet();
+    const { amuletContext, disclosedContracts } = await fetchAmuletContext(walletUrl, await tokenProvider.getToken(), instrumentId);
+    const { amuletContext: contextWithRules, externalPartyAmuletRulesCid } = injectExternalPartyAmuletRules(amuletContext, disclosedContracts);
+    return {
+      amuletContext: contextWithRules,
+      disclosedContracts,
+      externalPartyAmuletRulesCid
+    };
+  }
+  /**
+   * Get a property from an object, trying PascalCase first then camelCase.
+   * Canton API returns PascalCase but OpenAPI expects camelCase.
+   */
+  #getField(obj, key) {
+    if (!obj) return void 0;
+    const pascal = key.charAt(0).toUpperCase() + key.slice(1);
+    const camel = key.charAt(0).toLowerCase() + key.slice(1);
+    return obj[pascal] ?? obj[camel];
+  }
+  /**
+   * Run an API call, normalizing a thrown `ResponseError` into a `CantonApiError`
+   * that carries `errorCategory` (for retry classification). Other errors pass through.
+   */
+  async #invoke(call) {
+    try {
+      return await call();
+    } catch (err) {
+      if (err instanceof ResponseError) {
+        throw await cantonApiErrorFromResponse(err.response);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Build party-based filter object for event queries.
+   */
+  #buildPartyFilters(parties, includeCreatedEventBlob) {
+    return Object.fromEntries(parties.map((p) => [
+      p,
+      {
+        cumulative: [
+          {
+            identifierFilter: {
+              wildcardFilter: {
+                value: {
+                  includeCreatedEventBlob
+                }
+              }
+            }
+          }
+        ]
+      }
+    ]));
+  }
+  /**
+   * Validate and extract disclosure fields from a CreatedEvent.
+   */
+  #validateDisclosureEvent(event, contractId) {
+    if (!event.templateId) {
+      throw new CantonProtocolError("Disclosure response missing templateId", {
+        contractId
+      });
+    }
+    if (!event.contractId) {
+      throw new CantonProtocolError("Disclosure response missing contractId", {
+        contractId
+      });
+    }
+    if (!event.createdEventBlob) {
+      throw new CantonProtocolError("Disclosure response missing createdEventBlob", {
+        contractId
+      });
+    }
+    return {
+      templateId: event.templateId,
+      contractId: event.contractId,
+      createdEventBlob: event.createdEventBlob
+    };
+  }
+  /**
+   * Validate and extract prepared transaction fields from a prepare response.
+   */
+  #validatePrepareResponse(response) {
+    if (!response.preparedTransaction) {
+      throw new CantonProtocolError("Prepare response missing preparedTransaction");
+    }
+    if (!response.preparedTransactionHash) {
+      throw new CantonProtocolError("Prepare response missing preparedTransactionHash");
+    }
+    if (!response.hashingSchemeVersion) {
+      throw new CantonProtocolError("Prepare response missing hashingSchemeVersion");
+    }
+    return {
+      preparedTransaction: response.preparedTransaction,
+      preparedTransactionHash: response.preparedTransactionHash,
+      hashingSchemeVersion: response.hashingSchemeVersion
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Synchronizer Discovery
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Returns all connected synchronizer IDs.
+   */
+  async connectedSynchronizers() {
+    const response = await this.#invoke(() => this.#api.getV2StateConnectedSynchronizers());
+    return response.connectedSynchronizers?.map(({ synchronizerId }) => synchronizerId) ?? [];
+  }
+  /**
+   * Internal: ensures we have a cached synchronizer ID, fetching if needed.
+   */
+  #ensureSynchronizerId = once(async () => {
+    const [id] = await this.connectedSynchronizers();
+    if (!id) {
+      throw new CantonTransportError("No connected synchronizers found");
+    }
+    return id;
+  });
+  // ─────────────────────────────────────────────────────────────────────────
+  // DAR Upload / Validation
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Upload a DAR (Daml Archive) to the participant node.
+   *
+   * @param dar - Raw DAR bytes.
+   * @param opts.vetAllPackages - Whether to vet all packages in the DAR.
+   * @param opts.synchronizerId - Synchronizer to upload to (auto-detected if omitted).
+   * @param opts.skipIfVetted - If true, silently succeeds when the DAR is already vetted.
+   */
+  async uploadDar(dar, opts = {}) {
+    const bytes = dar.byteOffset === 0 && dar.byteLength === dar.buffer.byteLength ? dar.buffer : dar.buffer.slice(dar.byteOffset, dar.byteOffset + dar.byteLength);
+    const body = new Blob([
+      bytes
+    ], {
+      type: "application/octet-stream"
+    });
+    const synchronizerId = opts.synchronizerId ?? await this.#ensureSynchronizerId();
+    const request = {
+      body,
+      vetAllPackages: opts.vetAllPackages,
+      synchronizerId
+    };
+    try {
+      return await this.#invoke(() => this.#api.postV2Dars(request));
+    } catch (err) {
+      if (opts.skipIfVetted && err instanceof CantonApiError && err.code === "KNOWN_PACKAGE_VERSION") {
+        return {
+          skipped: true,
+          reason: "already_vetted",
+          details: err.body
+        };
+      }
+      throw err;
+    }
+  }
+  /**
+   * Validate a DAR against the participant without uploading it.
+   *
+   * @param dar - Raw DAR bytes.
+   * @param opts.synchronizerId - Synchronizer to validate against (auto-detected if omitted).
+   */
+  async validateDar(dar, opts = {}) {
+    const bytes = dar.byteOffset === 0 && dar.byteLength === dar.buffer.byteLength ? dar.buffer : dar.buffer.slice(dar.byteOffset, dar.byteOffset + dar.byteLength);
+    const body = new Blob([
+      bytes
+    ], {
+      type: "application/octet-stream"
+    });
+    const request = {
+      body,
+      synchronizerId: opts.synchronizerId
+    };
+    if (!request.synchronizerId) {
+      return this.#ensureSynchronizerId().then((synchronizerId) => this.#invoke(() => this.#api.postV2DarsValidate({
+        ...request,
+        synchronizerId
+      })));
+    }
+    return this.#invoke(() => this.#api.postV2DarsValidate(request));
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Party Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * List all known parties on the participant node.
+   *
+   * @param opts.pageSize - Maximum number of results per page
+   * @param opts.pageToken - Pagination token from previous response
+   * @returns Array of party IDs and pagination token
+   */
+  async listParties(opts = {}) {
+    const response = await this.#invoke(() => this.#api.getV2Parties({
+      pageSize: opts.pageSize,
+      pageToken: opts.pageToken
+    }));
+    return {
+      parties: response.partyDetails?.map((p) => p.party) ?? [],
+      nextPageToken: response.nextPageToken
+    };
+  }
+  /**
+   * Return the rights granted to the current user (this.#userId).
+   *
+   * Bypasses the OpenAPI generator's typed `Kind` converter, which is
+   * broken: `instanceOfKindOneOf` checks lowercase `canActAs in value`, but
+   * `KindOneOfFromJSONTyped` reads uppercase `json['CanActAs']`, so the
+   * typed client returns every `kind` as `{}`. We parse the raw JSON
+   * ourselves to preserve the actual variant payload.
+   */
+  async listUserRights() {
+    const apiResponse = await this.#invoke(() => this.#api.getV2UsersUserIdRightsRaw({
+      userId: this.#userId
+    }));
+    const raw = await apiResponse.raw.json();
+    return raw.rights ?? [];
+  }
+  /**
+   * Return the parties the current user has CanActAs or CanReadAs rights
+   * for. Convenience wrapper over `listUserRights()` for the common case
+   * where the caller just needs party-scoped access (e.g. to query events
+   * or fetch transactions).
+   *
+   * Use this instead of `listParties()` when the caller only has scoped
+   * rights — `listParties()` returns *all* parties on the participant
+   * (including DSO, splice parties), and Canton returns 403 if you query
+   * as a party you can't read.
+   */
+  async listUserParties() {
+    const rights = await this.listUserRights();
+    const parties = /* @__PURE__ */ new Set();
+    for (const right of rights) {
+      const party = right.kind.CanActAs?.value.party ?? right.kind.CanReadAs?.value.party;
+      if (party !== void 0) {
+        parties.add(party);
+      }
+    }
+    return [
+      ...parties
+    ];
+  }
+  /**
+   * Allocate a new party on the participant node.
+   *
+   * @param partyIdHint - A hint for the party ID (e.g., "alice", "bob")
+   * @param opts.userId - User who gets actAs rights (empty string = no user)
+   * @param opts.synchronizerId - Synchronizer to allocate on (auto-detected if omitted)
+   * @param opts.identityProviderId - Identity provider ID (empty string = default)
+   * @returns The allocated party ID
+   */
+  async allocateParty(partyIdHint, opts = {}) {
+    const synchronizerId = opts.synchronizerId ?? await this.#ensureSynchronizerId();
+    const response = await this.#invoke(() => this.#api.postV2Parties({
+      allocatePartyRequest: {
+        partyIdHint,
+        synchronizerId,
+        userId: opts.userId ?? "",
+        identityProviderId: opts.identityProviderId ?? ""
+      }
+    }));
+    const party = response.partyDetails?.party;
+    if (!party) {
+      throw new CantonProtocolError("Party allocation response missing party ID");
+    }
+    return party;
+  }
+  /**
+   * Generate unsigned topology transactions for an external party.
+   *
+   * POST /v2/parties/external/generate-topology
+   */
+  async generateExternalPartyTopology(args) {
+    const synchronizerId = await this.#ensureSynchronizerId();
+    const request = {
+      generateExternalPartyTopologyRequest: {
+        synchronizer: synchronizerId,
+        partyHint: args.partyHint,
+        publicKey: args.publicKey,
+        localParticipantObservationOnly: args.localParticipantObservationOnly,
+        confirmationThreshold: args.confirmationThreshold
+      }
+    };
+    const response = await this.#invoke(() => this.#api.postV2PartiesExternalGenerateTopology(request));
+    if (!response.partyId || !response.multiHash) {
+      throw new CantonProtocolError("generateExternalPartyTopology response missing partyId or multiHash");
+    }
+    if (!response.topologyTransactions?.length) {
+      throw new CantonProtocolError("generateExternalPartyTopology response missing topologyTransactions");
+    }
+    return {
+      partyId: response.partyId,
+      topologyTransactions: response.topologyTransactions,
+      multiHash: response.multiHash,
+      synchronizerId
+    };
+  }
+  /**
+   * Submit signed topology transactions to register an external party.
+   *
+   * POST /v2/parties/external/allocate
+   */
+  async allocateExternalParty(args) {
+    const request = {
+      allocateExternalPartyRequest: {
+        synchronizer: args.synchronizerId,
+        onboardingTransactions: args.topologyTransactions.map((tx) => ({
+          transaction: tx
+        })),
+        multiHashSignatures: args.multiHashSignatures,
+        identityProviderId: ""
+      }
+    };
+    const response = await this.#invoke(() => this.#api.postV2PartiesExternalAllocate(request));
+    if (!response.partyId) {
+      throw new CantonProtocolError("allocateExternalParty response missing partyId");
+    }
+    return response.partyId;
+  }
+  /**
+   * Grant canActAs right for a party to the current service user.
+   * Idempotent — safe to call even if the right is already granted.
+   *
+   * POST /v2/users/{userId}/rights
+   */
+  async grantCanActAs(partyId) {
+    await this.#invoke(() => this.#api.postV2UsersUserIdRights({
+      userId: this.#userId,
+      grantUserRightsRequest: {
+        userId: this.#userId,
+        rights: [
+          {
+            kind: {
+              canActAs: {
+                value: {
+                  party: partyId
+                }
+              }
+            }
+          }
+        ],
+        identityProviderId: ""
+      }
+    }));
+  }
+  /**
+   * Get the package ID for a package by name.
+   *
+   * @param packageName - The package name (e.g., "layerzero-oft")
+   * @param parties - Parties whose vetting state should be considered
+   * @param opts.synchronizerId - Synchronizer to query (auto-detected if omitted)
+   * @returns The package ID (hash)
+   */
+  async getPackageId(packageName, parties, opts = {}) {
+    const synchronizerId = opts.synchronizerId ?? await this.#ensureSynchronizerId();
+    const request = {
+      getPreferredPackagesRequest: {
+        packageVettingRequirements: [
+          {
+            packageName,
+            parties
+          }
+        ],
+        synchronizerId
+      }
+    };
+    const response = await this.#invoke(() => this.#api.postV2InteractiveSubmissionPreferredPackages(request));
+    const packageRef = response.packageReferences?.find((ref) => ref.packageName === packageName);
+    if (!packageRef?.packageId) {
+      throw new CantonProtocolError(`Package "${packageName}" not found or not vetted for parties`);
+    }
+    return packageRef.packageId;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Command Submission
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Submit a batch of commands atomically.
+   *
+   * @returns commandId and completionOffset for use with waitForCommand()
+   */
+  async submit(actors, commands, opts = {}) {
+    const synchronizerId = await this.#ensureSynchronizerId();
+    const commandId = opts.commandId ?? randomUUID();
+    const ledgerEndResponse = await this.#invoke(() => this.#api.getV2StateLedgerEnd());
+    const completionOffset = ledgerEndResponse.offset;
+    const request = {
+      jsCommands: {
+        commandId,
+        actAs: actors.actAs,
+        readAs: actors.readAs ?? actors.actAs,
+        userId: this.#userId,
+        synchronizerId,
+        commands,
+        disclosedContracts: opts.disclosedContracts
+      }
+    };
+    await this.#invoke(() => this.#api.postV2CommandsAsyncSubmit(request));
+    return {
+      commandId,
+      completionOffset
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Completion Waiting / Reconciliation
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Wait for a command to be accepted or rejected.
+   *
+   * Uses bounded exponential backoff to avoid hammering the participant.
+   */
+  async waitForCommand(commandId, opts) {
+    const { parties, timeoutMs = 3e4, poll = {} } = opts;
+    const limit = poll.limit ?? 50;
+    const streamIdleTimeoutMs = poll.streamIdleTimeoutMs ?? 1e3;
+    const initialBackoffMs = poll.backoffMs?.initial ?? 100;
+    const maxBackoffMs = poll.backoffMs?.max ?? 5e3;
+    let beginExclusive = opts.beginExclusive ?? 0;
+    let currentBackoff = initialBackoffMs;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const request = {
+        completionStreamRequest: {
+          beginExclusive,
+          parties,
+          userId: this.#userId
+        },
+        limit,
+        streamIdleTimeoutMs
+      };
+      const rawResponse = await this.#invoke(() => this.#api.postV2CommandsCompletionsRaw(request));
+      const responseText = await rawResponse.raw.text();
+      const completions = JSON.parse(responseText);
+      for (const item of completions) {
+        const normalized = item;
+        const completionResponse = this.#getField(normalized, "completionResponse");
+        if (!completionResponse) continue;
+        const offsetCheckpoint = this.#getField(completionResponse, "offsetCheckpoint");
+        if (offsetCheckpoint) {
+          const checkpoint = this.#getField(offsetCheckpoint, "value") ?? offsetCheckpoint;
+          const checkpointOffset = this.#getField(checkpoint, "offset");
+          if (checkpointOffset !== void 0) {
+            beginExclusive = Math.max(beginExclusive, checkpointOffset);
+          }
+          continue;
+        }
+        const completionWrapper = this.#getField(completionResponse, "completion");
+        const completion = this.#getField(completionWrapper, "value") ?? completionWrapper;
+        if (!completion) continue;
+        const offset = this.#getField(completion, "offset");
+        const completionCommandId = this.#getField(completion, "commandId");
+        if (completionCommandId === commandId) {
+          const status = this.#getField(completion, "status");
+          if (!status || status.code === 0) {
+            return {
+              status: "accepted",
+              commandId,
+              updateId: this.#getField(completion, "updateId") ?? "",
+              offset: offset ?? 0
+            };
+          } else {
+            return {
+              status: "rejected",
+              commandId,
+              offset: offset ?? 0,
+              error: {
+                code: status.code,
+                message: status.message ?? "Unknown rejection",
+                details: status.details
+              }
+            };
+          }
+        }
+        if (offset !== void 0) {
+          beginExclusive = Math.max(beginExclusive, offset);
+        }
+      }
+      const remainingTime = deadline - Date.now();
+      const sleepTime = Math.min(currentBackoff, remainingTime, maxBackoffMs);
+      if (sleepTime > 0) {
+        await new Promise((resolve) => setTimeout(resolve, sleepTime));
+      }
+      currentBackoff = Math.min(currentBackoff * 2, maxBackoffMs);
+    }
+    return {
+      status: "timeout",
+      commandId,
+      lastCheckedOffset: beginExclusive
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Disclosed Contracts
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Fetch active contract's created event by ID.
+   * Returns undefined if contract doesn't exist or is archived.
+   */
+  async #fetchActiveContractEvent(contractId, parties, includeCreatedEventBlob) {
+    const request = {
+      getEventsByContractIdRequest: {
+        contractId,
+        eventFormat: {
+          filtersByParty: this.#buildPartyFilters(parties, includeCreatedEventBlob),
+          verbose: false
+        }
+      }
+    };
+    const response = await this.#invoke(() => this.#api.postV2EventsEventsByContractId(request));
+    if (response.archived) return void 0;
+    return response.created?.createdEvent;
+  }
+  /**
+   * Build a disclosure for a contract.
+   *
+   * @param contractId - The contract ID to create disclosure for
+   * @param parties - Parties that have visibility to the contract
+   * @returns DisclosedContract if visible, undefined if not found
+   * @throws CantonProtocolError if contract visible but blob missing (server/config mismatch)
+   */
+  async createDisclosure(contractId, parties) {
+    const synchronizerId = await this.#ensureSynchronizerId();
+    const created = await this.#fetchActiveContractEvent(contractId, parties, true);
+    if (!created) return void 0;
+    const validated = this.#validateDisclosureEvent(created, contractId);
+    return {
+      ...validated,
+      synchronizerId
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Internal: Active Contract Queries (used by CantonSdk)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Fetch a single contract by ID.
+   *
+   * @param contractId The contract ID to fetch
+   * @param parties Parties to use for filtering (required for non-admin tokens)
+   */
+  async fetchContractById(contractId, parties) {
+    return this.#fetchActiveContractEvent(contractId, parties, false);
+  }
+  /**
+   * Fetch both the created and archived events for a contract by ID.
+   * Unlike fetchContractById, this preserves archival information.
+   */
+  async fetchEventsByContractId(contractId, parties) {
+    const request = {
+      getEventsByContractIdRequest: {
+        contractId,
+        eventFormat: {
+          filtersByParty: this.#buildPartyFilters(parties, false),
+          verbose: false
+        }
+      }
+    };
+    const response = await this.#invoke(() => this.#api.postV2EventsEventsByContractId(request));
+    return {
+      created: response.created?.createdEvent,
+      archived: response.archived?.archivedEvent
+    };
+  }
+  /**
+   * Fetch an update (transaction) by its ID.
+   * @param updateId The update ID from a completion
+   * @param parties Parties to use for the query filter
+   * @returns The full update response
+   */
+  async fetchTransactionByUpdateId(updateId, parties) {
+    const response = await this.#invoke(() => this.#api.postV2UpdatesUpdateByIdRaw({
+      getUpdateByIdRequest: {
+        updateId,
+        updateFormat: this.#buildUpdateFormat(parties)
+      }
+    }));
+    const updateResponse = await response.raw.json();
+    return this.#parseTransactionFromUpdate(updateResponse, `Update ${updateId} is not a transaction`);
+  }
+  /**
+   * Fetch a transaction by its offset.
+   * @param offset - The ledger offset
+   * @param parties - Parties to use for the query filter
+   * @returns The full transaction including recordTime
+   */
+  async fetchTransactionByOffset(offset, parties) {
+    const response = await this.#invoke(() => this.#api.postV2UpdatesUpdateByOffsetRaw({
+      getUpdateByOffsetRequest: {
+        offset,
+        updateFormat: this.#buildUpdateFormat(parties)
+      }
+    }));
+    const updateResponse = await response.raw.json();
+    return this.#parseTransactionFromUpdate(updateResponse, `Update at offset ${offset} is not a transaction`);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // External Party / Interactive Submission
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Prepare commands for external party signing.
+   *
+   * Returns a typed PreparedTransaction that preserves the contract type
+   * through the signing flow. After signing, use submitSigned() to submit.
+   *
+   * @typeparam T The contract payload type (phantom type for type safety)
+   *
+   * @example
+   * ```ts
+   * const prepared = await client.prepareForSigning<Oft>({ actAs: [party] }, [cmd]);
+   * const signature = await sign(prepared.preparedTransactionHash);
+   * await client.submitSigned(prepared, [signature]);
+   * ```
+   */
+  async prepareForSigning(actors, commands, opts = {}) {
+    const synchronizerId = await this.#ensureSynchronizerId();
+    const commandId = opts.commandId ?? randomUUID();
+    const request = {
+      jsPrepareSubmissionRequest: {
+        userId: this.#userId,
+        commandId,
+        commands,
+        actAs: actors.actAs,
+        readAs: actors.readAs ?? actors.actAs,
+        disclosedContracts: opts.disclosedContracts,
+        synchronizerId,
+        verboseHashing: false,
+        packageIdSelectionPreference: []
+      }
+    };
+    const response = await this.#invoke(() => this.#api.postV2InteractiveSubmissionPrepare(request));
+    const validated = this.#validatePrepareResponse(response);
+    return {
+      ...validated,
+      hashingSchemeVersion: validated.hashingSchemeVersion,
+      commandId
+    };
+  }
+  /**
+   * Submit a pre-signed transaction.
+   *
+   * The generic type T flows from prepareForSigning() for type documentation.
+   */
+  async submitSigned(prepared, signatures) {
+    const ledgerEndResponse = await this.#invoke(() => this.#api.getV2StateLedgerEnd());
+    const completionOffset = ledgerEndResponse.offset;
+    const request = {
+      jsExecuteSubmissionRequest: {
+        preparedTransaction: prepared.preparedTransaction,
+        // Map each ExternalSignature into the Canton per-party signature format
+        partySignatures: {
+          signatures: signatures.map((sig) => ({
+            party: sig.party,
+            signatures: [
+              {
+                format: sig.format,
+                signature: sig.signature,
+                signedBy: sig.signedBy,
+                signingAlgorithmSpec: sig.signingAlgorithmSpec
+              }
+            ]
+          }))
+        },
+        deduplicationPeriod: {
+          deduplicationDuration: {
+            value: {
+              seconds: 3600,
+              nanos: 0
+            }
+          }
+        },
+        submissionId: randomUUID(),
+        userId: this.#userId,
+        hashingSchemeVersion: prepared.hashingSchemeVersion
+      }
+    };
+    await this.#invoke(() => this.#api.postV2InteractiveSubmissionExecute(request));
+    return {
+      commandId: prepared.commandId,
+      completionOffset
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Active Contracts Query
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Get the current ledger end offset.
+   */
+  async getLedgerEndOffset() {
+    const response = await this.#invoke(() => this.#api.getV2StateLedgerEnd());
+    return response.offset;
+  }
+  /**
+   * Query active contracts at a given offset with optional template filtering.
+   *
+   * @param party - Party to query as
+   * @param offset - Ledger offset for the snapshot
+   * @param opts.templateIds - Optional template IDs to filter by
+   * @param opts.limit - Maximum number of contracts to return
+   * @param opts.includeCreatedEventBlob - Include CIP disclosure blobs (default false)
+   */
+  async queryActiveContracts(party, offset, opts) {
+    return this.queryActiveContractsByParties([
+      party
+    ], offset, opts?.templateIds ?? [], {
+      limit: opts?.limit,
+      includeCreatedEventBlob: opts?.includeCreatedEventBlob
+    });
+  }
+  /**
+   * Query active contracts visible to any of the given parties.
+   *
+   * Single API call with all parties in filtersByParty.
+   *
+   * @param parties - Parties to query as (for visibility)
+   * @param offset - Ledger offset for the snapshot
+   * @param templateIds - Template IDs to filter by
+   * @param opts.limit - Maximum number of contracts to return
+   * @param opts.includeCreatedEventBlob - Include CIP disclosure blobs (default false)
+   */
+  async queryActiveContractsByParties(parties, offset, templateIds, opts) {
+    return this.#fetchActiveContracts(parties, offset, this.#buildCumulativeFilters(templateIds, opts?.includeCreatedEventBlob), opts);
+  }
+  /**
+   * Query active contracts visible to any of the given parties that implement
+   * the given interfaces.
+   *
+   * @param parties - Parties to query as (for visibility)
+   * @param offset - Ledger offset for the snapshot
+   * @param interfaceIds - Interface IDs to filter by (e.g. "#package:Module:Interface")
+   * @param opts.limit - Maximum number of contracts to return
+   */
+  async queryActiveContractsByInterface(parties, offset, interfaceIds, opts) {
+    return this.#fetchActiveContracts(parties, offset, this.#buildInterfaceCumulativeFilters(interfaceIds, opts?.includeCreatedEventBlob), opts);
+  }
+  async #fetchActiveContracts(parties, offset, cumulativeFilter, opts) {
+    const filtersByParty = Object.fromEntries(parties.map((party) => [
+      party,
+      {
+        cumulative: cumulativeFilter
+      }
+    ]));
+    const rawResponse = await this.#invoke(() => this.#api.postV2StateActiveContractsRaw({
+      getActiveContractsRequest: {
+        filter: {
+          filtersByParty
+        },
+        verbose: true,
+        activeAtOffset: offset
+      },
+      limit: opts?.limit
+    }));
+    const rawJson = await rawResponse.raw.json();
+    return rawJson.map((item) => item.contractEntry?.JsActiveContract).filter((contract) => contract != null).map((contract) => JsActiveContractFromJSON(contract));
+  }
+  /**
+   * Stream transactions from a given offset.
+   *
+   * Uses `updateFormat` with `TRANSACTION_SHAPE_LEDGER_EFFECTS` so consumers
+   * receive `ExercisedEvent`s (e.g. the request-poller depends on
+   * `Request_Create` exercise results). The deprecated legacy `filter`
+   * shape would default to `ACS_DELTA`, which only emits Created/Archived
+   * events and silently drops every exercise on the wire.
+   *
+   * @param party - Party to query as
+   * @param beginExclusive - Start offset (exclusive)
+   * @param endInclusive - End offset (inclusive)
+   * @param opts.templateIds - Optional template IDs to filter by
+   * @param opts.limit - Maximum number of transactions to return
+   */
+  async getUpdates(party, beginExclusive, endInclusive, opts) {
+    const eventFormat = {
+      filtersByParty: {
+        [party]: {
+          cumulative: this.#buildCumulativeFilters(opts?.templateIds)
+        }
+      },
+      verbose: false
+    };
+    const rawResponse = await this.#invoke(() => this.#api.postV2UpdatesRaw({
+      getUpdatesRequest: {
+        beginExclusive,
+        endInclusive,
+        verbose: false,
+        updateFormat: {
+          includeTransactions: {
+            eventFormat,
+            transactionShape: "TRANSACTION_SHAPE_LEDGER_EFFECTS"
+          }
+        }
+      },
+      limit: opts?.limit
+    }));
+    const updateResponses = await rawResponse.raw.json();
+    return updateResponses.map((response) => response.update);
+  }
+  /**
+   * Build cumulative filters for party-based queries.
+   * If templateIds provided, filters by those templates; otherwise uses wildcard.
+   */
+  #buildCumulativeFilters(templateIds, includeCreatedEventBlob = false) {
+    if (templateIds?.length) {
+      return templateIds.map((templateId) => ({
+        identifierFilter: {
+          templateFilter: {
+            value: {
+              templateId,
+              includeCreatedEventBlob
+            }
+          }
+        }
+      }));
+    }
+    return [
+      {
+        identifierFilter: {
+          wildcardFilter: {
+            value: {
+              includeCreatedEventBlob
+            }
+          }
+        }
+      }
+    ];
+  }
+  /**
+   * Build cumulative filters for interface-based ACS queries.
+   * If interfaceIds provided, filters by those interfaces; otherwise uses wildcard.
+   */
+  #buildInterfaceCumulativeFilters(interfaceIds, includeCreatedEventBlob = false) {
+    if (interfaceIds?.length) {
+      return interfaceIds.map((interfaceId) => ({
+        identifierFilter: {
+          interfaceFilter: {
+            value: {
+              interfaceId,
+              includeInterfaceView: true,
+              includeCreatedEventBlob
+            }
+          }
+        }
+      }));
+    }
+    return [
+      {
+        identifierFilter: {
+          wildcardFilter: {
+            value: {
+              includeCreatedEventBlob
+            }
+          }
+        }
+      }
+    ];
+  }
+  /**
+   * Build the standard update format for fetching transactions.
+   */
+  #buildUpdateFormat(parties) {
+    return {
+      includeTransactions: {
+        eventFormat: {
+          filtersByParty: this.#buildPartyFilters(parties, false),
+          verbose: false
+        },
+        transactionShape: "TRANSACTION_SHAPE_LEDGER_EFFECTS"
+      }
+    };
+  }
+  /**
+   * Parse an update response and extract the transaction.
+   * The response structure is: { update: { Transaction: { value: CantonTransaction } } }
+   */
+  #parseTransactionFromUpdate(json, notFoundMessage) {
+    if (!("Transaction" in json.update)) {
+      throw new CantonProtocolError(notFoundMessage);
+    }
+    return json.update.Transaction.value;
+  }
+};
+
+export { CantonClient };
+//# sourceMappingURL=MI3L7BKC.js.map
+//# sourceMappingURL=MI3L7BKC.js.map