@distrohelena/canton-typescript-sdk 0.1.0 → 0.1.2

package/dist/services/topology-manager-write/topology-signed-transaction-assembler.js

@@ -0,0 +1,78 @@
+import { ValidationError } from "../../core/errors/validation-error.js";
+import { SignedTopologyTransaction } from "../../core/types/topology/signed-topology-transaction.js";
+import { TopologySignatureFormat } from "../../core/types/topology/topology-signature-format.js";
+import { TopologyTransactionSignature } from "../../core/types/topology/topology-transaction-signature.js";
+export function assembleSignedTopologyTransactions(request) {
+    const preparedTransactionsByHash = new Map(request.preparedTransactions.map((preparedTransaction) => [
+        toHex(preparedTransaction.transactionHash),
+        preparedTransaction,
+    ]));
+    const signaturesByHash = new Map();
+    const seenSignerPairs = new Set();
+    for (const signature of request.signatures) {
+        validateExternalSignature(signature);
+        const signatureFormat = signature.signatureFormat;
+        const hashKey = toHex(signature.transactionHash);
+        const preparedTransaction = preparedTransactionsByHash.get(hashKey);
+        if (preparedTransaction === undefined) {
+            throw new ValidationError(`No prepared transaction matches detached signature hash ${hashKey}.`);
+        }
+        const signerKey = `${hashKey}:${signature.signedByFingerprint}`;
+        if (seenSignerPairs.has(signerKey)) {
+            throw new ValidationError(`Duplicate detached signature for signer ${signature.signedByFingerprint} on transaction ${hashKey}.`);
+        }
+        seenSignerPairs.add(signerKey);
+        const mappedSignature = new TopologyTransactionSignature({
+            format: mapExternalSignatureFormatToRawFormat(signatureFormat),
+            signature: signature.signature,
+            signedByFingerprint: signature.signedByFingerprint,
+            signingAlgorithmSpec: signature.signingAlgorithmSpec
+                ?? mapExternalSignatureFormatToAlgorithmSpec(signatureFormat),
+            signatureDelegation: signature.signatureDelegation,
+        });
+        const existing = signaturesByHash.get(hashKey) ?? [];
+        existing.push(mappedSignature);
+        signaturesByHash.set(hashKey, existing);
+    }
+    return request.preparedTransactions.map((preparedTransaction) => new SignedTopologyTransaction({
+        transaction: preparedTransaction.serializedTransaction,
+        signatures: signaturesByHash.get(toHex(preparedTransaction.transactionHash)) ?? [],
+        proposal: preparedTransaction.proposal,
+        multiTransactionSignatures: [],
+    }));
+}
+function validateExternalSignature(signature) {
+    if (signature.transactionHash.length === 0) {
+        throw new ValidationError("Detached topology signatures require a transactionHash.");
+    }
+    else if (signature.signature.length === 0) {
+        throw new ValidationError("Detached topology signatures require signature bytes.");
+    }
+    else if (signature.signedByFingerprint.length === 0) {
+        throw new ValidationError("Detached topology signatures require signedByFingerprint.");
+    }
+    else if (signature.signatureFormat === undefined) {
+        throw new ValidationError("Detached topology signatures require signatureFormat.");
+    }
+}
+function mapExternalSignatureFormatToRawFormat(signatureFormat) {
+    switch (signatureFormat) {
+        case TopologySignatureFormat.ed25519:
+            return "concat";
+        default:
+            return "unspecified";
+    }
+}
+function mapExternalSignatureFormatToAlgorithmSpec(signatureFormat) {
+    switch (signatureFormat) {
+        case TopologySignatureFormat.ed25519:
+            return "ed25519";
+        default:
+            return "unspecified";
+    }
+}
+function toHex(bytes) {
+    return [...bytes]
+        .map((value) => value.toString(16).padStart(2, "0"))
+        .join("");
+}

package/dist/transports/grpc/grpc-channel-factory.d.ts

@@ -11,6 +11,7 @@ import { ITrafficControlServiceClient } from "./generated/canton/com/digitalasse
 import { IIdentityInitializationServiceClient } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/initialization_service.client.js";
 import { ITopologyAggregationServiceClient } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_aggregation_service.client.js";
 import { ITopologyManagerReadServiceClient } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_read_service.client.js";
+import { ITopologyManagerWriteServiceClient } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_write_service.client.js";
 import { ICommandInspectionServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.client.js";
 import { IIdentityProviderConfigServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/identity_provider_config_service.client.js";
 import { IPackageManagementServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/package_management_service.client.js";
@@ -33,6 +34,8 @@ export interface GrpcOperations {
     getHealthAsync(options?: RequestOptions): Promise<unknown>;
     createPartyAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
     listPartiesAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    generateExternalPartyTopologyAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    allocateExternalPartyAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getParticipantIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getPartiesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     grantUserRightsAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
@@ -63,6 +66,8 @@ export interface GrpcOperations {
     getIntervalsBehindForCounterParticipantsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     lookupSentAcsCommitmentsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     lookupReceivedAcsCommitmentsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    addPartyAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    clearPartyOnboardingFlagAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getHighestOffsetByTimestampAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getSafePruningOffsetAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getPruningScheduleAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
@@ -82,6 +87,14 @@ export interface GrpcOperations {
     listPartyToKeyMappingAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     listSynchronizerTrustCertificateAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     listParticipantSynchronizerPermissionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    authorizeTopologyTransactionsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    addTopologyTransactionsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    importTopologySnapshotAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    importTopologySnapshotV2Async?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    signTopologyTransactionsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    generateTopologyTransactionsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    createTemporaryTopologyStoreAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    dropTemporaryTopologyStoreAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     listPartyHostingLimitsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     topologyListVettedPackagesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     listPartyToParticipantAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
@@ -113,7 +126,7 @@ export interface GrpcOperations {
 export interface GrpcOperationDependencies {
     versionServiceClient?: Pick<IVersionServiceClient, "getLedgerApiVersion">;
     healthClient?: Pick<IHealthClient, "check">;
-    partyManagementServiceClient?: Pick<IPartyManagementServiceClient, "allocateParty" | "listKnownParties" | "getParticipantId" | "getParties">;
+    partyManagementServiceClient?: Pick<IPartyManagementServiceClient, "allocateParty" | "listKnownParties" | "generateExternalPartyTopology" | "allocateExternalParty" | "getParticipantId" | "getParties">;
     userManagementServiceClient?: Pick<IUserManagementServiceClient, "grantUserRights" | "getUser" | "listUsers" | "listUserRights">;
     commandInspectionServiceClient?: Pick<ICommandInspectionServiceClient, "getCommandStatus">;
     identityProviderConfigServiceClient?: Pick<IIdentityProviderConfigServiceClient, "getIdentityProviderConfig" | "listIdentityProviderConfigs">;
@@ -121,7 +134,7 @@ export interface GrpcOperationDependencies {
     ledgerPackageServiceClient?: Pick<ILedgerPackageServiceClient, "listPackages" | "getPackage" | "getPackageStatus" | "listVettedPackages">;
     participantPackageServiceClient?: Pick<IParticipantPackageServiceClient, "listPackages" | "getPackageContents" | "getPackageReferences" | "getDar" | "listDars" | "getDarContents">;
     participantInspectionServiceClient?: Pick<IParticipantInspectionServiceClient, "lookupOffsetByTime" | "openCommitment" | "inspectCommitmentContracts" | "countInFlight" | "getConfigForSlowCounterParticipants" | "getIntervalsBehindForCounterParticipants" | "lookupSentAcsCommitments" | "lookupReceivedAcsCommitments">;
-    participantPartyManagementServiceClient?: Pick<IParticipantPartyManagementServiceClient, "getHighestOffsetByTimestamp">;
+    participantPartyManagementServiceClient?: Pick<IParticipantPartyManagementServiceClient, "addPartyAsync" | "clearPartyOnboardingFlag" | "getHighestOffsetByTimestamp">;
     participantRepairServiceClient?: Pick<IParticipantRepairServiceClient, "listPendingOperations">;
     pruningServiceClient?: Pick<IPruningServiceClient, "getSafePruningOffset" | "getSchedule" | "getParticipantSchedule" | "getNoWaitCommitmentsFrom">;
     participantStatusServiceClient?: Pick<IParticipantStatusServiceClient, "participantStatus">;
@@ -130,6 +143,7 @@ export interface GrpcOperationDependencies {
     resourceManagementServiceClient?: Pick<IResourceManagementServiceClient, "getResourceLimits">;
     identityInitializationServiceClient?: Pick<IIdentityInitializationServiceClient, "getId" | "currentTime">;
     topologyManagerReadServiceClient?: Pick<ITopologyManagerReadServiceClient, "listNamespaceDelegation" | "listDecentralizedNamespaceDefinition" | "listOwnerToKeyMapping" | "listPartyToKeyMapping" | "listSynchronizerTrustCertificate" | "listParticipantSynchronizerPermission" | "listPartyHostingLimits" | "listVettedPackages" | "listPartyToParticipant" | "listSynchronizerParametersState" | "listSequencingParametersState" | "listMediatorSynchronizerState" | "listSequencerSynchronizerState" | "listLsuAnnouncement" | "listLsuSequencerConnectionSuccessor" | "listAvailableStores" | "listAll" | "listAllV2">;
+    topologyManagerWriteServiceClient?: Pick<ITopologyManagerWriteServiceClient, "authorize" | "addTransactions" | "importTopologySnapshot" | "importTopologySnapshotV2" | "signTransactions" | "generateTransactions" | "createTemporaryTopologyStore" | "dropTemporaryTopologyStore">;
     topologyAggregationServiceClient?: Pick<ITopologyAggregationServiceClient, "listParties" | "listKeyOwners">;
     contractServiceClient?: Pick<IContractServiceClient, "getContract">;
     eventQueryServiceClient?: Pick<IEventQueryServiceClient, "getEventsByContractId">;

package/dist/transports/grpc/grpc-channel-factory.js

@@ -11,6 +11,7 @@ import { TrafficControlServiceClient, } from "./generated/canton/com/digitalasse
 import { IdentityInitializationServiceClient, } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/initialization_service.client.js";
 import { TopologyAggregationServiceClient, } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_aggregation_service.client.js";
 import { TopologyManagerReadServiceClient, } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_read_service.client.js";
+import { TopologyManagerWriteServiceClient, } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_write_service.client.js";
 import { CommandInspectionServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.client.js";
 import { IdentityProviderConfigServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/admin/identity_provider_config_service.client.js";
 import { PackageManagementServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/admin/package_management_service.client.js";
@@ -72,6 +73,8 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
         ?? new TrafficControlServiceClient(rpcTransport);
     const topologyManagerReadServiceClient = dependencies.topologyManagerReadServiceClient
         ?? new TopologyManagerReadServiceClient(rpcTransport);
+    const topologyManagerWriteServiceClient = dependencies.topologyManagerWriteServiceClient
+        ?? new TopologyManagerWriteServiceClient(rpcTransport);
     const topologyAggregationServiceClient = dependencies.topologyAggregationServiceClient
         ?? new TopologyAggregationServiceClient(rpcTransport);
     const contractServiceClient = dependencies.contractServiceClient
@@ -104,6 +107,14 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(partyManagementServiceClient.listKnownParties(request, callOptions));
         },
+        async generateExternalPartyTopologyAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.generateExternalPartyTopology(request, callOptions));
+        },
+        async allocateExternalPartyAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.allocateExternalParty(request, callOptions));
+        },
         async getParticipantIdAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(partyManagementServiceClient.getParticipantId(request, callOptions));
@@ -224,6 +235,14 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(participantInspectionServiceClient.lookupReceivedAcsCommitments(request, callOptions));
         },
+        async addPartyAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPartyManagementServiceClient.addPartyAsync(request, callOptions));
+        },
+        async clearPartyOnboardingFlagAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPartyManagementServiceClient.clearPartyOnboardingFlag(request, callOptions));
+        },
         async getHighestOffsetByTimestampAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(participantPartyManagementServiceClient.getHighestOffsetByTimestamp(request, callOptions));
@@ -348,6 +367,38 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(topologyManagerReadServiceClient.listAllV2(request, callOptions));
         },
+        async authorizeTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.authorize(request, callOptions));
+        },
+        async addTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.addTransactions(request, callOptions));
+        },
+        async importTopologySnapshotAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await sendClientStreamRequestAndReadResponseAsync(topologyManagerWriteServiceClient.importTopologySnapshot(callOptions), request);
+        },
+        async importTopologySnapshotV2Async(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await sendClientStreamRequestAndReadResponseAsync(topologyManagerWriteServiceClient.importTopologySnapshotV2(callOptions), request);
+        },
+        async signTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.signTransactions(request, callOptions));
+        },
+        async generateTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.generateTransactions(request, callOptions));
+        },
+        async createTemporaryTopologyStoreAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.createTemporaryTopologyStore(request, callOptions));
+        },
+        async dropTemporaryTopologyStoreAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.dropTemporaryTopologyStore(request, callOptions));
+        },
         async topologyListPartiesAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(topologyAggregationServiceClient.listParties(request, callOptions));
@@ -428,6 +479,11 @@ function normalizeGrpcHost(endpoint) {
 async function unwrapUnaryResponse(call) {
     return await call.response;
 }
+async function sendClientStreamRequestAndReadResponseAsync(call, request) {
+    await call.requests.send(request);
+    await call.requests.complete();
+    return await call.response;
+}
 async function collectServerResponsesAsync(call) {
     const responses = [];
     for await (const response of call.responses) {

package/dist/transports/grpc/grpc-transport.d.ts

@@ -1,9 +1,12 @@
 import { CantonClientOptions } from "../../client/canton-client-options.js";
+import { AllocateExternalPartyRequest } from "../../core/types/requests/allocate-external-party-request.js";
 import { AllocatePartyRequest } from "../../core/types/requests/allocate-party-request.js";
+import { AddPartyAsyncRequest } from "../../core/types/requests/add-party-async-request.js";
 import { GetCompletionsRequest } from "../../core/types/requests/get-completions-request.js";
 import { GetConnectedSynchronizersRequest } from "../../core/types/requests/get-connected-synchronizers-request.js";
 import { CountInFlightRequest } from "../../core/types/requests/count-in-flight-request.js";
 import { CurrentTimeRequest } from "../../core/types/requests/current-time-request.js";
+import { ClearPartyOnboardingFlagRequest } from "../../core/types/requests/clear-party-onboarding-flag-request.js";
 import { GetDarContentsRequest } from "../../core/types/requests/get-dar-contents-request.js";
 import { GetDarRequest } from "../../core/types/requests/get-dar-request.js";
 import { GetActiveContractsPageRequest } from "../../core/types/requests/get-active-contracts-page-request.js";
@@ -37,6 +40,7 @@ import { GetUpdateByHashRequest } from "../../core/types/requests/get-update-by-
 import { GetUpdateByIdRequest } from "../../core/types/requests/get-update-by-id-request.js";
 import { GetUpdateByOffsetRequest } from "../../core/types/requests/get-update-by-offset-request.js";
 import { GrantUserRightsRequest } from "../../core/types/requests/grant-user-rights-request.js";
+import { GenerateExternalPartyTopologyRequest } from "../../core/types/requests/generate-external-party-topology-request.js";
 import { GetUpdatesRequest } from "../../core/types/requests/get-updates-request.js";
 import { GetUpdatesPageRequest } from "../../core/types/requests/get-updates-page-request.js";
 import { GetUserRequest } from "../../core/types/requests/get-user-request.js";
@@ -82,6 +86,8 @@ import { TrafficControlStateRequest } from "../../core/types/requests/traffic-co
 import { UploadDarFileRequest } from "../../core/types/requests/upload-dar-file-request.js";
 import { SignCommandResult } from "../../core/signing/sign-command-result.js";
 import { AllocatePartyResponse as SdkAllocatePartyResponse } from "../../core/types/responses/allocate-party-response.js";
+import { AllocateExternalPartyResponse } from "../../core/types/responses/allocate-external-party-response.js";
+import { AddPartyAsyncResponse } from "../../core/types/responses/add-party-async-response.js";
 import { GetPackageContentsResponse } from "../../core/types/responses/get-package-contents-response.js";
 import { GetPackageReferencesResponse } from "../../core/types/responses/get-package-references-response.js";
 import { GetConnectedSynchronizersResponse } from "../../core/types/responses/get-connected-synchronizers-response.js";
@@ -119,7 +125,9 @@ import { GetUpdateByOffsetResponse } from "../../core/types/responses/get-update
 import { GetUpdatesPageResponse } from "../../core/types/responses/get-updates-page-response.js";
 import { GetUserResponse } from "../../core/types/responses/get-user-response.js";
 import { GrantUserRightsResponse } from "../../core/types/responses/grant-user-rights-response.js";
+import { GenerateExternalPartyTopologyResponse } from "../../core/types/responses/generate-external-party-topology-response.js";
 import { HealthCheckResponse } from "../../core/types/responses/health-check-response.js";
+import { ClearPartyOnboardingFlagResponse } from "../../core/types/responses/clear-party-onboarding-flag-response.js";
 import { ListAllResponse } from "../../core/types/responses/list-all-response.js";
 import { ListAllV2Response } from "../../core/types/responses/list-all-v2-response.js";
 import { ListAvailableStoresResponse } from "../../core/types/responses/list-available-stores-response.js";
@@ -179,6 +187,8 @@ export declare class GrpcTransport implements ITransport {
     checkHealthAsync(request: HealthCheckRequest, options?: RequestOptions): Promise<HealthCheckResponse>;
     allocatePartyAsync(request: AllocatePartyRequest, options?: RequestOptions): Promise<SdkAllocatePartyResponse>;
     listKnownPartiesAsync(request: ListKnownPartiesRequest, options?: RequestOptions): Promise<SdkListKnownPartiesResponse>;
+    generateExternalPartyTopologyAsync(request: GenerateExternalPartyTopologyRequest, options?: RequestOptions): Promise<GenerateExternalPartyTopologyResponse>;
+    allocateExternalPartyAsync(request: AllocateExternalPartyRequest, options?: RequestOptions): Promise<AllocateExternalPartyResponse>;
     getParticipantIdAsync(request: GetParticipantIdRequest, options?: RequestOptions): Promise<GetParticipantIdResponse>;
     getPartiesAsync(request: GetPartiesRequest, options?: RequestOptions): Promise<GetPartiesResponse>;
     grantUserRightsAsync(request: GrantUserRightsRequest, options?: RequestOptions): Promise<GrantUserRightsResponse>;
@@ -209,6 +219,8 @@ export declare class GrpcTransport implements ITransport {
     getIntervalsBehindForCounterParticipantsAsync(request: GetIntervalsBehindForCounterParticipantsRequest, options?: RequestOptions): Promise<GetIntervalsBehindForCounterParticipantsResponse>;
     lookupSentAcsCommitmentsAsync(request: LookupSentAcsCommitmentsRequest, options?: RequestOptions): Promise<LookupSentAcsCommitmentsResponse>;
     lookupReceivedAcsCommitmentsAsync(request: LookupReceivedAcsCommitmentsRequest, options?: RequestOptions): Promise<LookupReceivedAcsCommitmentsResponse>;
+    addPartyAsync(request: AddPartyAsyncRequest, options?: RequestOptions): Promise<AddPartyAsyncResponse>;
+    clearPartyOnboardingFlagAsync(request: ClearPartyOnboardingFlagRequest, options?: RequestOptions): Promise<ClearPartyOnboardingFlagResponse>;
     getHighestOffsetByTimestampAsync(request: GetHighestOffsetByTimestampRequest, options?: RequestOptions): Promise<GetHighestOffsetByTimestampResponse>;
     getSafePruningOffsetAsync(request: GetSafePruningOffsetRequest, options?: RequestOptions): Promise<GetSafePruningOffsetResponse>;
     getPruningScheduleAsync(request: GetPruningScheduleRequest, options?: RequestOptions): Promise<GetPruningScheduleResponse>;
@@ -230,6 +242,14 @@ export declare class GrpcTransport implements ITransport {
     listPartyToKeyMappingAsync(request: ListPartyToKeyMappingRequest, options?: RequestOptions): Promise<ListPartyToKeyMappingResponse>;
     listSynchronizerTrustCertificateAsync(request: ListSynchronizerTrustCertificateRequest, options?: RequestOptions): Promise<ListSynchronizerTrustCertificateResponse>;
     listParticipantSynchronizerPermissionAsync(request: ListParticipantSynchronizerPermissionRequest, options?: RequestOptions): Promise<ListParticipantSynchronizerPermissionResponse>;
+    authorizeTopologyTransactionsAsync(request: any, options?: RequestOptions): Promise<any>;
+    addTopologyTransactionsAsync(request: any, options?: RequestOptions): Promise<any>;
+    importTopologySnapshotAsync(request: any, options?: RequestOptions): Promise<any>;
+    importTopologySnapshotV2Async(request: any, options?: RequestOptions): Promise<any>;
+    signTopologyTransactionsAsync(request: any, options?: RequestOptions): Promise<any>;
+    generateTopologyTransactionsAsync(request: any, options?: RequestOptions): Promise<any>;
+    createTemporaryTopologyStoreAsync(request: any, options?: RequestOptions): Promise<any>;
+    dropTemporaryTopologyStoreAsync(request: any, options?: RequestOptions): Promise<any>;
     listPartyHostingLimitsAsync(request: ListPartyHostingLimitsRequest, options?: RequestOptions): Promise<ListPartyHostingLimitsResponse>;
     topologyListVettedPackagesAsync(request: TopologyListVettedPackagesRequest, options?: RequestOptions): Promise<TopologyListVettedPackagesResponse>;
     listPartyToParticipantAsync(request: ListPartyToParticipantRequest, options?: RequestOptions): Promise<ListPartyToParticipantResponse>;

package/dist/transports/grpc/grpc-transport.js

@@ -12,6 +12,7 @@ import { mapGrpcGetContract, mapGrpcGetContractRequest, mapGrpcQueryContracts, m
 import { mapGrpcCompletionStreamResponse, mapGrpcGetCompletionsRequest, } from "./mappers/command-completion-mapper.js";
 import { mapGrpcGetCommandStatus, mapGrpcGetCommandStatusRequest, } from "./mappers/command-inspection-mapper.js";
 import { mapGrpcGetEventsByContractId, mapGrpcGetEventsByContractIdRequest, } from "./mappers/event-query-mapper.js";
+import { mapGrpcAllocateExternalPartyRequest, mapGrpcAllocateExternalPartyResponse, mapGrpcGenerateExternalPartyTopologyRequest, mapGrpcGenerateExternalPartyTopologyResponse, } from "./mappers/external-party-management-mapper.js";
 import { mapGrpcCurrentTime, mapGrpcCurrentTimeRequest, mapGrpcGetId, mapGrpcGetIdRequest, } from "./mappers/identity-initialization-mapper.js";
 import { mapGrpcGetIdentityProviderConfig, mapGrpcGetIdentityProviderConfigRequest, mapGrpcListIdentityProviderConfigs, mapGrpcListIdentityProviderConfigsRequest, } from "./mappers/identity-provider-config-mapper.js";
 import { mapGrpcStreamTransactionsRequest, mapGrpcTransactionEvents, } from "./mappers/events-mapper.js";
@@ -19,7 +20,7 @@ import { mapGrpcGetUpdateByHash, mapGrpcGetUpdateByHashRequest, mapGrpcGetUpdate
 import { mapGrpcListKnownPackages, mapGrpcListKnownPackagesRequest, mapGrpcGetPackage, mapGrpcGetPackageRequest, mapGrpcGetPackageStatus, mapGrpcGetPackageStatusRequest, mapGrpcGetParticipantPackageContents, mapGrpcGetParticipantPackageContentsRequest, mapGrpcGetParticipantDar, mapGrpcGetParticipantDarContents, mapGrpcGetParticipantDarContentsRequest, mapGrpcGetParticipantDarRequest, mapGrpcGetParticipantPackageReferences, mapGrpcGetParticipantPackageReferencesRequest, mapGrpcListParticipantDars, mapGrpcListParticipantDarsRequest, mapGrpcListPackages, mapGrpcListPackagesRequest, mapGrpcListVettedPackages, mapGrpcListVettedPackagesRequest, mapGrpcParticipantListPackages, mapGrpcParticipantListPackagesRequest, mapGrpcUploadPackage, mapGrpcUploadPackageRequest, } from "./mappers/packages-mapper.js";
 import { mapGrpcGetParticipantStatusRequest, mapGrpcParticipantStatusResponse, } from "./mappers/participant-status-mapper.js";
 import { mapGrpcCountInFlight, mapGrpcCountInFlightRequest, mapGrpcGetConfigForSlowCounterParticipants, mapGrpcGetConfigForSlowCounterParticipantsRequest, mapGrpcGetIntervalsBehindForCounterParticipants, mapGrpcGetIntervalsBehindForCounterParticipantsRequest, mapGrpcInspectCommitmentContracts, mapGrpcInspectCommitmentContractsRequest, mapGrpcLookupReceivedAcsCommitments, mapGrpcLookupReceivedAcsCommitmentsRequest, mapGrpcLookupOffsetByTime, mapGrpcLookupOffsetByTimeRequest, mapGrpcLookupSentAcsCommitments, mapGrpcLookupSentAcsCommitmentsRequest, mapGrpcOpenCommitment, mapGrpcOpenCommitmentRequest, } from "./mappers/participant-inspection-mapper.js";
-import { mapGrpcGetHighestOffsetByTimestamp, mapGrpcGetHighestOffsetByTimestampRequest, } from "./mappers/participant-party-management-mapper.js";
+import { mapGrpcAddPartyAsyncRequest, mapGrpcAddPartyAsyncResponse, mapGrpcClearPartyOnboardingFlagRequest, mapGrpcClearPartyOnboardingFlagResponse, mapGrpcGetHighestOffsetByTimestamp, mapGrpcGetHighestOffsetByTimestampRequest, } from "./mappers/participant-party-management-mapper.js";
 import { mapGrpcListPendingOperations, mapGrpcListPendingOperationsRequest, } from "./mappers/participant-repair-mapper.js";
 import { mapGrpcGetNoWaitCommitmentsFrom, mapGrpcGetNoWaitCommitmentsFromRequest, mapGrpcGetParticipantPruningSchedule, mapGrpcGetParticipantPruningScheduleRequest, mapGrpcGetPruningSchedule, mapGrpcGetPruningScheduleRequest, mapGrpcGetSafePruningOffset, mapGrpcGetSafePruningOffsetRequest, } from "./mappers/pruning-mapper.js";
 import { mapGrpcGetSynchronizerId, mapGrpcGetSynchronizerIdRequest, mapGrpcListConnectedSynchronizers, mapGrpcListConnectedSynchronizersRequest, mapGrpcListRegisteredSynchronizers, mapGrpcListRegisteredSynchronizersRequest, } from "./mappers/synchronizer-connectivity-mapper.js";
@@ -30,6 +31,7 @@ import { mapGrpcListKeyOwnersRequest, mapGrpcListKeyOwnersResponse, mapGrpcTopol
 import { mapGrpcGetResourceLimits, mapGrpcGetResourceLimitsRequest, } from "./mappers/resource-management-mapper.js";
 import { mapGrpcGetConnectedSynchronizers, mapGrpcGetConnectedSynchronizersRequest, mapGrpcGetLatestPrunedOffsets, mapGrpcGetLatestPrunedOffsetsRequest, mapGrpcGetLedgerEnd, mapGrpcGetLedgerEndRequest, } from "./mappers/state-read-mapper.js";
 import { mapGrpcListAllRequest, mapGrpcListAllResponse, mapGrpcListAllV2Request, mapGrpcListAllV2Response, mapGrpcListAvailableStoresRequest, mapGrpcListAvailableStoresResponse, mapGrpcListDecentralizedNamespaceDefinitionRequest, mapGrpcListDecentralizedNamespaceDefinitionResponse, mapGrpcListLsuAnnouncementRequest, mapGrpcListLsuAnnouncementResponse, mapGrpcListLsuSequencerConnectionSuccessorRequest, mapGrpcListLsuSequencerConnectionSuccessorResponse, mapGrpcListMediatorSynchronizerStateRequest, mapGrpcListMediatorSynchronizerStateResponse, mapGrpcListNamespaceDelegationRequest, mapGrpcListNamespaceDelegationResponse, mapGrpcListOwnerToKeyMappingRequest, mapGrpcListOwnerToKeyMappingResponse, mapGrpcListParticipantSynchronizerPermissionRequest, mapGrpcListParticipantSynchronizerPermissionResponse, mapGrpcListPartyHostingLimitsRequest, mapGrpcListPartyHostingLimitsResponse, mapGrpcListPartyToKeyMappingRequest, mapGrpcListPartyToKeyMappingResponse, mapGrpcListPartyToParticipantRequest, mapGrpcListPartyToParticipantResponse, mapGrpcListSequencerSynchronizerStateRequest, mapGrpcListSequencerSynchronizerStateResponse, mapGrpcListSequencingParametersStateRequest, mapGrpcListSequencingParametersStateResponse, mapGrpcListSynchronizerParametersStateRequest, mapGrpcListSynchronizerParametersStateResponse, mapGrpcListSynchronizerTrustCertificateRequest, mapGrpcListSynchronizerTrustCertificateResponse, mapGrpcTopologyListVettedPackagesRequest, mapGrpcTopologyListVettedPackagesResponse, } from "./mappers/topology-manager-read-mapper.js";
+import { mapGrpcAddTopologyTransactionsRequest, mapGrpcAddTopologyTransactionsResponse, mapGrpcAuthorizeTopologyTransactionsRequest, mapGrpcAuthorizeTopologyTransactionsResponse, mapGrpcCreateTemporaryTopologyStoreRequest, mapGrpcCreateTemporaryTopologyStoreResponse, mapGrpcDropTemporaryTopologyStoreRequest, mapGrpcDropTemporaryTopologyStoreResponse, mapGrpcGenerateTopologyTransactionsRequest, mapGrpcGenerateTopologyTransactionsResponse, mapGrpcImportTopologySnapshotRequest, mapGrpcImportTopologySnapshotResponse, mapGrpcImportTopologySnapshotV2Request, mapGrpcImportTopologySnapshotV2Response, mapGrpcSignTopologyTransactionsRequest, mapGrpcSignTopologyTransactionsResponse, } from "./mappers/topology-manager-write-mapper.js";
 import { mapGrpcGetUser, mapGrpcGetUserRequest, mapGrpcGrantUserRights, mapGrpcGrantUserRightsRequest, mapGrpcListUserRights, mapGrpcListUserRightsRequest, mapGrpcListUsers, mapGrpcListUsersRequest, } from "./mappers/users-mapper.js";
 import { mapGrpcHealthCheckResponse } from "./mappers/health-mapper.js";
 import { ObjectDisposedError } from "../../core/errors/object-disposed-error.js";
@@ -83,6 +85,16 @@ export class GrpcTransport {
             nextPageToken: response.nextPageToken,
         });
     }
+    async generateExternalPartyTopologyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.generateExternalPartyTopologyAsync(mapGrpcGenerateExternalPartyTopologyRequest(request), options);
+        return mapGrpcGenerateExternalPartyTopologyResponse(payload);
+    }
+    async allocateExternalPartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.allocateExternalPartyAsync(mapGrpcAllocateExternalPartyRequest(request), options);
+        return mapGrpcAllocateExternalPartyResponse(payload);
+    }
     async getParticipantIdAsync(request, options) {
         this.throwIfDisposed();
         const payload = await this.operations.getParticipantIdAsync(mapGrpcGetParticipantIdRequest(request), options);
@@ -243,6 +255,16 @@ export class GrpcTransport {
         const payload = await this.operations.lookupReceivedAcsCommitmentsAsync(mapGrpcLookupReceivedAcsCommitmentsRequest(request), options);
         return mapGrpcLookupReceivedAcsCommitments(payload);
     }
+    async addPartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.addPartyAsync(mapGrpcAddPartyAsyncRequest(request), options);
+        return mapGrpcAddPartyAsyncResponse(payload);
+    }
+    async clearPartyOnboardingFlagAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.clearPartyOnboardingFlagAsync(mapGrpcClearPartyOnboardingFlagRequest(request), options);
+        return mapGrpcClearPartyOnboardingFlagResponse(payload);
+    }
     async getHighestOffsetByTimestampAsync(request, options) {
         this.throwIfDisposed();
         const payload = await this.operations.getHighestOffsetByTimestampAsync(mapGrpcGetHighestOffsetByTimestampRequest(request), options);
@@ -354,6 +376,46 @@ export class GrpcTransport {
         const payload = await this.operations.listParticipantSynchronizerPermissionAsync(mapGrpcListParticipantSynchronizerPermissionRequest(request), options);
         return mapGrpcListParticipantSynchronizerPermissionResponse(payload);
     }
+    async authorizeTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.authorizeTopologyTransactionsAsync(mapGrpcAuthorizeTopologyTransactionsRequest(request), options);
+        return mapGrpcAuthorizeTopologyTransactionsResponse(payload);
+    }
+    async addTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.addTopologyTransactionsAsync(mapGrpcAddTopologyTransactionsRequest(request), options);
+        return mapGrpcAddTopologyTransactionsResponse(payload);
+    }
+    async importTopologySnapshotAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.importTopologySnapshotAsync(mapGrpcImportTopologySnapshotRequest(request), options);
+        return mapGrpcImportTopologySnapshotResponse(payload);
+    }
+    async importTopologySnapshotV2Async(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.importTopologySnapshotV2Async(mapGrpcImportTopologySnapshotV2Request(request), options);
+        return mapGrpcImportTopologySnapshotV2Response(payload);
+    }
+    async signTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.signTopologyTransactionsAsync(mapGrpcSignTopologyTransactionsRequest(request), options);
+        return mapGrpcSignTopologyTransactionsResponse(payload);
+    }
+    async generateTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.generateTopologyTransactionsAsync(mapGrpcGenerateTopologyTransactionsRequest(request), options);
+        return mapGrpcGenerateTopologyTransactionsResponse(payload);
+    }
+    async createTemporaryTopologyStoreAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.createTemporaryTopologyStoreAsync(mapGrpcCreateTemporaryTopologyStoreRequest(request), options);
+        return mapGrpcCreateTemporaryTopologyStoreResponse(payload);
+    }
+    async dropTemporaryTopologyStoreAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.dropTemporaryTopologyStoreAsync(mapGrpcDropTemporaryTopologyStoreRequest(request), options);
+        return mapGrpcDropTemporaryTopologyStoreResponse(payload);
+    }
     async listPartyHostingLimitsAsync(request, options) {
         this.throwIfDisposed();
         const payload = await this.operations.listPartyHostingLimitsAsync(mapGrpcListPartyHostingLimitsRequest(request), options);
@@ -435,10 +497,19 @@ export class GrpcTransport {
         const payload = await this.operations.queryContractsAsync(mapGrpcQueryContractsRequest({
             party: request.party,
             templateId: request.templateId,
+            interfaceId: request.interfaceId,
+            includeInterfaceView: request.includeInterfaceView,
+            includeCreatedEventBlob: request.includeCreatedEventBlob,
+            activeAtOffset: request.activeAtOffset,
+            maxPageSize: request.maxPageSize,
+            pageToken: request.pageToken,
         }), options);
         const response = mapGrpcQueryContracts(payload);
+        const pagePayload = payload;
         return new GetActiveContractsPageResponse({
             contracts: response.contracts,
+            activeAtOffset: pagePayload.activeAtOffset,
+            nextPageToken: pagePayload.nextPageToken,
         });
     }
     async getConnectedSynchronizersAsync(request, options) {

package/dist/transports/grpc/mappers/contracts-mapper.d.ts

@@ -7,6 +7,12 @@ import { GetActiveContractsPageRequest } from "../generated/canton/com/daml/ledg
 export declare function mapGrpcQueryContractsRequest(request: {
     party: string;
     templateId?: string;
+    interfaceId?: string;
+    includeInterfaceView?: boolean;
+    includeCreatedEventBlob?: boolean;
+    activeAtOffset?: string;
+    maxPageSize?: number;
+    pageToken?: Uint8Array;
 }): GetActiveContractsPageRequest;
 export declare function mapGrpcQueryContracts(payload: {
     contracts?: unknown[];

package/dist/transports/grpc/mappers/contracts-mapper.js

@@ -3,7 +3,10 @@ import { GetContractResponse } from "../../../core/types/responses/get-contract-
 import { QueryContractsResponse } from "../../../core/types/responses/query-contracts-response.js";
 export function mapGrpcQueryContractsRequest(request) {
     return {
-        eventFormat: createEventFormat(request.party, request.templateId),
+        activeAtOffset: request.activeAtOffset,
+        eventFormat: createEventFormat(request),
+        maxPageSize: request.maxPageSize,
+        pageToken: request.pageToken,
     };
 }
 export function mapGrpcQueryContracts(payload) {
@@ -26,39 +29,57 @@ export function mapGrpcGetContract(payload) {
         createdEvent: payload.createdEvent,
     });
 }
-function createEventFormat(party, templateId) {
+function createEventFormat(request) {
     return {
         filtersByParty: {
-            [party]: {
-                cumulative: [createTemplateFilter(templateId)],
-            },
+            [request.party]: createFilters(request),
         },
         verbose: true,
     };
 }
-function createTemplateFilter(templateId) {
-    if (!templateId) {
-        return {
+function createFilters(request) {
+    const cumulative = [];
+    const includeCreatedEventBlob = request.includeCreatedEventBlob ?? false;
+    if (request.templateId) {
+        cumulative.push({
             identifierFilter: {
-                oneofKind: "wildcardFilter",
-                wildcardFilter: {
-                    includeCreatedEventBlob: false,
+                oneofKind: "templateFilter",
+                templateFilter: {
+                    templateId: parseIdentifier(request.templateId, "templateId"),
+                    includeCreatedEventBlob,
                 },
             },
-        };
+        });
     }
+    if (request.interfaceId) {
+        cumulative.push({
+            identifierFilter: {
+                oneofKind: "interfaceFilter",
+                interfaceFilter: {
+                    interfaceId: parseIdentifier(request.interfaceId, "interfaceId"),
+                    includeInterfaceView: request.includeInterfaceView ?? false,
+                    includeCreatedEventBlob,
+                },
+            },
+        });
+    }
+    if (cumulative.length === 0) {
+        cumulative.push(createWildcardFilter(includeCreatedEventBlob));
+    }
+    return { cumulative };
+}
+function createWildcardFilter(includeCreatedEventBlob) {
     return {
         identifierFilter: {
-            oneofKind: "templateFilter",
-            templateFilter: {
-                templateId: parseTemplateIdentifier(templateId),
-                includeCreatedEventBlob: false,
+            oneofKind: "wildcardFilter",
+            wildcardFilter: {
+                includeCreatedEventBlob,
             },
         },
     };
 }
-function parseTemplateIdentifier(templateId) {
-    const parts = templateId.split(":");
+function parseIdentifier(value, propertyName) {
+    const parts = value.split(":");
     if (parts.length === 2) {
         return {
             packageId: "",
@@ -73,5 +94,5 @@ function parseTemplateIdentifier(templateId) {
             entityName: parts[2],
         };
     }
-    throw new ValidationError(`templateId must be '<module>:<entity>' or '<package>:<module>:<entity>', but was '${templateId}'.`);
+    throw new ValidationError(`${propertyName} must be '<module>:<entity>' or '<package>:<module>:<entity>', but was '${value}'.`);
 }

package/dist/transports/grpc/mappers/external-party-management-mapper.d.ts

@@ -0,0 +1,9 @@
+import { AllocateExternalPartyRequest as SdkAllocateExternalPartyRequest } from "../../../core/types/requests/allocate-external-party-request.js";
+import { GenerateExternalPartyTopologyRequest as SdkGenerateExternalPartyTopologyRequest } from "../../../core/types/requests/generate-external-party-topology-request.js";
+import { AllocateExternalPartyResponse as SdkAllocateExternalPartyResponse } from "../../../core/types/responses/allocate-external-party-response.js";
+import { GenerateExternalPartyTopologyResponse as SdkGenerateExternalPartyTopologyResponse } from "../../../core/types/responses/generate-external-party-topology-response.js";
+import { AllocateExternalPartyRequest, AllocateExternalPartyResponse, GenerateExternalPartyTopologyRequest, GenerateExternalPartyTopologyResponse } from "../generated/canton/com/daml/ledger/api/v2/admin/party_management_service.js";
+export declare function mapGrpcGenerateExternalPartyTopologyRequest(request: SdkGenerateExternalPartyTopologyRequest): GenerateExternalPartyTopologyRequest;
+export declare function mapGrpcGenerateExternalPartyTopologyResponse(response: GenerateExternalPartyTopologyResponse): SdkGenerateExternalPartyTopologyResponse;
+export declare function mapGrpcAllocateExternalPartyRequest(request: SdkAllocateExternalPartyRequest): AllocateExternalPartyRequest;
+export declare function mapGrpcAllocateExternalPartyResponse(response: AllocateExternalPartyResponse): SdkAllocateExternalPartyResponse;