@layerzerolabs/common-canton 1.2.76 → 1.2.77

package/dist/MLMQSKCV.js

@@ -1,922 +0,0 @@
-import { DefaultApi } from './B42Y5JOK.js';
-import { JsActiveContractFromJSON } from './NIN7X4D3.js';
-import { ResponseError } from './KBNUN3MF.js';
-import { fetchDsoParty, fetchAmuletContext, injectExternalPartyAmuletRules } from './QEE5QCHB.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: {
-        eventFormat: {
-          filtersByParty,
-          verbose: false
-        },
-        // TODO(canton): drop the deprecated top-level `verbose` once the canton-openapi
-        // generator is bumped to a 3.6.1+ spec, where it is optional. Canton 3.4.8–3.6.1
-        // accept requests without it, and 3.7 removes it.
-        verbose: false,
-        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,
-        // TODO(canton): drop the deprecated top-level `verbose` once the canton-openapi
-        // generator is bumped to a 3.6.1+ spec, where it is optional. Canton 3.4.8–3.6.1
-        // accept requests without it, and 3.7 removes it.
-        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=MLMQSKCV.js.map
-//# sourceMappingURL=MLMQSKCV.js.map