@distrohelena/canton-typescript-sdk 0.1.0 → 0.1.2

package/README.md

@@ -13,6 +13,60 @@ TypeScript SDK for Canton with:
 npm install @distrohelena/canton-typescript-sdk
 ```
 
+## Live Integration Tests
+
+The repository also supports a live SDK validation suite against an already-running CN quickstart localnet.
+
+The live suite runs single-worker with an extended timeout because it mutates and reads a shared localnet.
+
+Prerequisites:
+
+- CN quickstart is already running on your machine
+- the suite is expected to fail fast if the configured node is unreachable
+
+Default local endpoints:
+
+- gRPC ledger: `http://localhost:3901`
+- gRPC ledger admin: `http://localhost:3901`
+- gRPC participant admin: `http://localhost:3902`
+- JSON ledger and ledger admin: `http://localhost:3975`
+
+Override environment variables:
+
+- `SDK_TEST_LEDGER_ENDPOINT`
+- `SDK_TEST_LEDGER_ADMIN_ENDPOINT`
+- `SDK_TEST_PARTICIPANT_ADMIN_ENDPOINT`
+- `SDK_TEST_SECONDARY_LEDGER_ENDPOINT`
+- `SDK_TEST_SECONDARY_LEDGER_ADMIN_ENDPOINT`
+- `SDK_TEST_SECONDARY_PARTICIPANT_ADMIN_ENDPOINT`
+- `SDK_TEST_TERTIARY_LEDGER_ENDPOINT`
+- `SDK_TEST_TERTIARY_LEDGER_ADMIN_ENDPOINT`
+- `SDK_TEST_TERTIARY_PARTICIPANT_ADMIN_ENDPOINT`
+
+The live harness also supports bearer-token overrides:
+
+- `SDK_TEST_LEDGER_BEARER_TOKEN`
+- `SDK_TEST_LEDGER_ADMIN_BEARER_TOKEN`
+- `SDK_TEST_PARTICIPANT_ADMIN_BEARER_TOKEN`
+
+For CN quickstart shared-secret mode, the harness generates a default bearer token automatically using:
+
+- subject `ledger-api-user`
+- audience `https://canton.network.global`
+- shared secret `unsafe`
+
+Run:
+
+```bash
+npm run test:live
+```
+
+Experimental multi-host external-party coverage is opt-in:
+
+- set `SDK_TEST_ENABLE_MULTI_HOST_EXTERNAL_PARTY=1` to enable the multi-host live spec
+- the default quickstart assumptions cover 2 nodes (`390x` and `490x`)
+- configure the tertiary endpoint variables above to enable the 3-host scenario
+
 ## Shared Client
 
 ```ts
@@ -65,6 +119,10 @@ const contracts = await client.stateService.getActiveContractsPageAsync(
 );
 ```
 
+`stateService.getActiveContractsPageAsync(...)` keeps `templateId` as the simple helper path, and on gRPC also supports interface-based ACS reads with `interfaceId`, `includeInterfaceView`, `includeCreatedEventBlob`, `activeAtOffset`, `maxPageSize`, and `pageToken`. JSON remains template-query only.
+
+For interface views, do not use `contractService.getContractAsync(...)`. That contract lookup surface cannot return interface views; use `stateService` or `updateService` instead.
+
 `CantonClient` now splits its public surface across the real API boundaries:
 
 - ledger services use `ledgerEndpoint`
@@ -98,6 +156,10 @@ For gRPC, channel security resolves per surface:
 - Ledger Admin endpoint:
 - `partyManagementService.allocatePartyAsync(...)`: `json`, `grpc`
 - `partyManagementService.listKnownPartiesAsync(...)`: `json`, `grpc`
+- `partyManagementService.getParticipantIdAsync(...)`: `grpc` only
+- `partyManagementService.getPartiesAsync(...)`: `grpc` only
+- `partyManagementService.generateExternalPartyTopologyAsync(...)`: `grpc` only
+- `partyManagementService.allocateExternalPartyAsync(...)`: `grpc` only
 - `userManagementService.grantUserRightsAsync(...)`: `json`, `grpc`
 - `packageManagementService.uploadDarFileAsync(...)`: `json`, `grpc`
 
@@ -106,6 +168,19 @@ For gRPC, channel security resolves per surface:
 - `participantPackageService.getPackageContentsAsync(...)`: `grpc` only
 - `participantPackageService.getPackageReferencesAsync(...)`: `grpc` only
 - `participantStatusService.getParticipantStatusAsync(...)`: `grpc` only
+- `topologyManagerReadService.*`: `grpc` only
+- `topologyAggregationService.*`: `grpc` only
+- `topologyManagerWriteService.authorizeAsync(...)`: `grpc` only
+- `topologyManagerWriteService.addTransactionsAsync(...)`: `grpc` only
+- `topologyManagerWriteService.importTopologySnapshotAsync(...)`: `grpc` only
+- `topologyManagerWriteService.importTopologySnapshotV2Async(...)`: `grpc` only
+- `topologyManagerWriteService.signTransactionsAsync(...)`: `grpc` only
+- `topologyManagerWriteService.generateTransactionsAsync(...)`: `grpc` only
+- `topologyManagerWriteService.createTemporaryTopologyStoreAsync(...)`: `grpc` only
+- `topologyManagerWriteService.dropTemporaryTopologyStoreAsync(...)`: `grpc` only
+- `topologyManagerWriteService.assembleSignedTransactions(...)`: SDK-local on any client
+
+Raw topology-write mapping support currently starts with `PartyToParticipant`. The detached-signature assembler is transport-independent, but the actual participant-admin write RPCs are `grpc` only and JSON rejects them with `NotSupportedError`.
 
 ## Protocol-Specific Clients
 
@@ -120,6 +195,7 @@ Subpath exports are available when you want to construct directly over a transpo
 
 JSON does not provide a `grpc.health.v1.Health.Check` equivalent. The shared SDK still exposes `healthService`, but JSON rejects calls with `NotSupportedError`.
 JSON also does not provide a participant-admin status equivalent, so `participantStatusService` is currently `grpc` only.
+JSON also does not expose the ledger-admin external-party RPCs, so `partyManagementService.generateExternalPartyTopologyAsync(...)` and `partyManagementService.allocateExternalPartyAsync(...)` are `grpc` only.
 
 ## DAML-LF Parser
 

package/dist/client/canton-client.d.ts

@@ -20,11 +20,13 @@ import { ResourceManagementServiceClient } from "../services/resource-management
 import { StateServiceClient } from "../services/state/state-service-client.js";
 import { TopologyAggregationServiceClient } from "../services/topology-aggregation/topology-aggregation-service-client.js";
 import { TopologyManagerReadServiceClient } from "../services/topology-manager-read/topology-manager-read-service-client.js";
+import { TopologyManagerWriteServiceClient } from "../services/topology-manager-write/topology-manager-write-service-client.js";
 import { TrafficControlServiceClient } from "../services/traffic-control/traffic-control-service-client.js";
 import { UpdateServiceClient } from "../services/update/update-service-client.js";
 import { UserManagementServiceClient } from "../services/user-management/user-management-service-client.js";
 import { VersionServiceClient } from "../services/version/version-service-client.js";
 import { SynchronizerConnectivityServiceClient } from "../services/synchronizer-connectivity/synchronizer-connectivity-service-client.js";
+import { CantonHashingClient } from "./canton-hashing-client.js";
 import { CantonClientOptions } from "./canton-client-options.js";
 export declare class CantonClient {
     private readonly options;
@@ -48,6 +50,7 @@ export declare class CantonClient {
     readonly identityInitializationService: IdentityInitializationServiceClient;
     readonly synchronizerConnectivityService: SynchronizerConnectivityServiceClient;
     readonly topologyManagerReadService: TopologyManagerReadServiceClient;
+    readonly topologyManagerWriteService: TopologyManagerWriteServiceClient;
     readonly trafficControlService: TrafficControlServiceClient;
     readonly topologyAggregationService: TopologyAggregationServiceClient;
     readonly commandService: CommandServiceClient;
@@ -57,6 +60,7 @@ export declare class CantonClient {
     readonly updateService: UpdateServiceClient;
     readonly eventQueryService: EventQueryServiceClient;
     readonly contractService: ContractServiceClient;
+    readonly hashing: CantonHashingClient;
     constructor(options: CantonClientOptions);
     /** Disposes transport-owned resources for this client instance. */
     disposeAsync(): Promise<void>;

package/dist/client/canton-client.js

@@ -1,5 +1,6 @@
 import { NotSupportedError } from "../core/errors/not-supported-error.js";
 import { TransportKind } from "../core/types/transport-kind.js";
+import { CantonHashingClient } from "./canton-hashing-client.js";
 import { createServiceRegistry } from "./service-registry.js";
 export class CantonClient {
     options;
@@ -23,6 +24,7 @@ export class CantonClient {
     identityInitializationService;
     synchronizerConnectivityService;
     topologyManagerReadService;
+    topologyManagerWriteService;
     trafficControlService;
     topologyAggregationService;
     commandService;
@@ -32,6 +34,7 @@ export class CantonClient {
     updateService;
     eventQueryService;
     contractService;
+    hashing;
     constructor(options) {
         this.options = options;
         if (options.transportKind === TransportKind.json &&
@@ -61,6 +64,7 @@ export class CantonClient {
         this.synchronizerConnectivityService =
             services.synchronizerConnectivityService;
         this.topologyManagerReadService = services.topologyManagerReadService;
+        this.topologyManagerWriteService = services.topologyManagerWriteService;
         this.trafficControlService = services.trafficControlService;
         this.topologyAggregationService = services.topologyAggregationService;
         this.commandService = services.commandService;
@@ -70,6 +74,7 @@ export class CantonClient {
         this.updateService = services.updateService;
         this.eventQueryService = services.eventQueryService;
         this.contractService = services.contractService;
+        this.hashing = new CantonHashingClient();
     }
     /** Disposes transport-owned resources for this client instance. */
     async disposeAsync() {

package/dist/client/canton-hashing-client.d.ts

@@ -0,0 +1,8 @@
+export declare class CantonHashingClient {
+    /** Computes a Canton multihash for the provided content and hash purpose. */
+    computeHash(content: Uint8Array, purpose: number): Uint8Array;
+    /** Computes a Canton multihash as lowercase hexadecimal for the provided content and hash purpose. */
+    computeHashHex(content: Uint8Array, purpose: number): string;
+    /** Computes the canonical Canton public-key fingerprint from serialized public key bytes. */
+    computePublicKeyFingerprint(publicKey: Uint8Array): string;
+}

package/dist/client/canton-hashing-client.js

@@ -0,0 +1,16 @@
+import { computeCantonHash, computeCantonHashHex, } from "../core/hashing/canton-hash.js";
+import { CantonHashPurpose } from "../core/types/canton-hash-purpose.js";
+export class CantonHashingClient {
+    /** Computes a Canton multihash for the provided content and hash purpose. */
+    computeHash(content, purpose) {
+        return computeCantonHash(content, purpose);
+    }
+    /** Computes a Canton multihash as lowercase hexadecimal for the provided content and hash purpose. */
+    computeHashHex(content, purpose) {
+        return computeCantonHashHex(content, purpose);
+    }
+    /** Computes the canonical Canton public-key fingerprint from serialized public key bytes. */
+    computePublicKeyFingerprint(publicKey) {
+        return computeCantonHashHex(publicKey, CantonHashPurpose.publicKeyFingerprint);
+    }
+}

package/dist/client/external-party-activation-client.d.ts

@@ -0,0 +1,15 @@
+import { RequestOptions } from "../core/types/request-options.js";
+import { CantonClient } from "./canton-client.js";
+import { ExternalPartyActivationRequest } from "./external-party-activation-request.js";
+import { ExternalPartyActivationResponse } from "./external-party-activation-response.js";
+/** Coordinates multi-host external-party activation across participant-admin topology reads and writes. gRPC only. */
+export declare class ExternalPartyActivationClient {
+    private readonly sourceClient;
+    constructor(sourceClient: CantonClient);
+    /** Waits for a PartyToParticipant proposal, asks additional participants to co-authorize it, and waits for activation. gRPC only. */
+    activateAsync(request: ExternalPartyActivationRequest, options?: RequestOptions): Promise<ExternalPartyActivationResponse>;
+    private waitForProposalOrActivationAsync;
+    private waitForActivationAsync;
+    private readStateAsync;
+    private createActivationResponse;
+}

package/dist/client/external-party-activation-client.js

@@ -0,0 +1,126 @@
+import { AuthorizeTopologyTransactionsRequest } from "../core/types/requests/authorize-topology-transactions-request.js";
+import { ListPartyToParticipantRequest } from "../core/types/requests/list-party-to-participant-request.js";
+import { TopologyBaseQuery } from "../core/types/topology/topology-base-query.js";
+import { TopologyStoreId, TopologyStoreKind, TopologyStoreSynchronizer } from "../core/types/topology/topology-store-id.js";
+import { ExternalPartyActivationResponse } from "./external-party-activation-response.js";
+/** Coordinates multi-host external-party activation across participant-admin topology reads and writes. gRPC only. */
+export class ExternalPartyActivationClient {
+    sourceClient;
+    constructor(sourceClient) {
+        this.sourceClient = sourceClient;
+    }
+    /** Waits for a PartyToParticipant proposal, asks additional participants to co-authorize it, and waits for activation. gRPC only. */
+    async activateAsync(request, options) {
+        if (request.activationTimeoutMs <= 0) {
+            throw new Error(`External party activation timeout must be greater than zero, received ${request.activationTimeoutMs}.`);
+        }
+        if (request.pollIntervalMs < 0) {
+            throw new Error(`External party activation poll interval must be zero or greater, received ${request.pollIntervalMs}.`);
+        }
+        const initialState = await this.waitForProposalOrActivationAsync(request, options);
+        if (initialState.active !== undefined) {
+            return this.createActivationResponse(request, initialState.active.context, initialState.active.mapping);
+        }
+        if (initialState.proposal === undefined) {
+            throw new Error(`External party activation did not find an active or proposed PartyToParticipant mapping for '${request.partyId}'.`);
+        }
+        const transactionHash = convertBytesToHex(initialState.proposal.context.transactionHash);
+        if (transactionHash.length === 0) {
+            throw new Error(`External party activation could not read a transaction hash for '${request.partyId}'.`);
+        }
+        const authorizeRequest = new AuthorizeTopologyTransactionsRequest({
+            transactionHash,
+            mustFullyAuthorize: false,
+            store: createSynchronizerStoreId(request.synchronizerId),
+        });
+        for (const client of request.authorizingClients) {
+            await client.topologyManagerWriteService.authorizeAsync(authorizeRequest, options);
+        }
+        const activatedState = await this.waitForActivationAsync(request, options);
+        return this.createActivationResponse(request, activatedState.context, activatedState.mapping);
+    }
+    async waitForProposalOrActivationAsync(request, options) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt <= request.activationTimeoutMs) {
+            const state = await this.readStateAsync(request, options);
+            if (state.active !== undefined || state.proposal !== undefined) {
+                return state;
+            }
+            await delayAsync(request.pollIntervalMs);
+        }
+        throw new Error(`External party activation timed out while waiting for a PartyToParticipant proposal for '${request.partyId}' on synchronizer '${request.synchronizerId}'.`);
+    }
+    async waitForActivationAsync(request, options) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt <= request.activationTimeoutMs) {
+            const state = await this.readStateAsync(request, options);
+            if (state.active !== undefined) {
+                return state.active;
+            }
+            await delayAsync(request.pollIntervalMs);
+        }
+        throw new Error(`External party activation timed out while waiting for '${request.partyId}' to become active on synchronizer '${request.synchronizerId}'.`);
+    }
+    async readStateAsync(request, options) {
+        const [activeResponse, proposalResponse] = await Promise.all([
+            this.sourceClient.topologyManagerReadService.listPartyToParticipantAsync(new ListPartyToParticipantRequest({
+                baseQuery: createSynchronizerQuery(request.synchronizerId, false),
+                filterParty: request.partyId,
+            }), options),
+            this.sourceClient.topologyManagerReadService.listPartyToParticipantAsync(new ListPartyToParticipantRequest({
+                baseQuery: createSynchronizerQuery(request.synchronizerId, true),
+                filterParty: request.partyId,
+            }), options),
+        ]);
+        const active = activeResponse.results.find((item) => item.item.party === request.partyId);
+        const proposal = proposalResponse.results.find((item) => item.item.party === request.partyId);
+        return {
+            active: active === undefined || active.context === undefined
+                ? undefined
+                : {
+                    context: active.context,
+                    mapping: active.item,
+                },
+            proposal: proposal === undefined || proposal.context === undefined
+                ? undefined
+                : {
+                    context: proposal.context,
+                    mapping: proposal.item,
+                },
+        };
+    }
+    createActivationResponse(request, context, mapping) {
+        return new ExternalPartyActivationResponse({
+            partyId: request.partyId,
+            synchronizerId: request.synchronizerId,
+            transactionHash: convertBytesToHex(context.transactionHash),
+            mapping,
+        });
+    }
+}
+function createSynchronizerStoreId(synchronizerId) {
+    return new TopologyStoreId({
+        kind: TopologyStoreKind.synchronizer,
+        synchronizer: new TopologyStoreSynchronizer({
+            id: synchronizerId,
+        }),
+    });
+}
+function createSynchronizerQuery(synchronizerId, includeProposals) {
+    return new TopologyBaseQuery({
+        storeId: createSynchronizerStoreId(synchronizerId),
+        includeProposals,
+        headState: true,
+    });
+}
+function convertBytesToHex(value) {
+    return Array.from(value, (item) => item.toString(16).padStart(2, "0")).join("");
+}
+async function delayAsync(durationMs) {
+    if (durationMs <= 0) {
+        return;
+    }
+    await new Promise((resolve) => {
+        setTimeout(resolve, durationMs);
+    });
+}

package/dist/client/external-party-activation-request.d.ts

@@ -0,0 +1,15 @@
+import type { CantonClient } from "./canton-client.js";
+export declare class ExternalPartyActivationRequest {
+    readonly partyId: string;
+    readonly synchronizerId: string;
+    readonly authorizingClients: readonly CantonClient[];
+    readonly activationTimeoutMs: number;
+    readonly pollIntervalMs: number;
+    constructor(init: {
+        partyId: string;
+        synchronizerId: string;
+        authorizingClients?: readonly CantonClient[];
+        activationTimeoutMs?: number;
+        pollIntervalMs?: number;
+    });
+}

package/dist/client/external-party-activation-request.js

@@ -0,0 +1,14 @@
+export class ExternalPartyActivationRequest {
+    partyId;
+    synchronizerId;
+    authorizingClients;
+    activationTimeoutMs;
+    pollIntervalMs;
+    constructor(init) {
+        this.partyId = init.partyId;
+        this.synchronizerId = init.synchronizerId;
+        this.authorizingClients = [...(init.authorizingClients ?? [])];
+        this.activationTimeoutMs = init.activationTimeoutMs ?? 45_000;
+        this.pollIntervalMs = init.pollIntervalMs ?? 500;
+    }
+}

package/dist/client/external-party-activation-response.d.ts

@@ -0,0 +1,13 @@
+import { PartyToParticipant } from "../core/types/topology/party-to-participant.js";
+export declare class ExternalPartyActivationResponse {
+    readonly partyId: string;
+    readonly synchronizerId: string;
+    readonly transactionHash: string;
+    readonly mapping: PartyToParticipant;
+    constructor(init: {
+        partyId: string;
+        synchronizerId: string;
+        transactionHash: string;
+        mapping: PartyToParticipant;
+    });
+}

package/dist/client/external-party-activation-response.js

@@ -0,0 +1,12 @@
+export class ExternalPartyActivationResponse {
+    partyId;
+    synchronizerId;
+    transactionHash;
+    mapping;
+    constructor(init) {
+        this.partyId = init.partyId;
+        this.synchronizerId = init.synchronizerId;
+        this.transactionHash = init.transactionHash;
+        this.mapping = init.mapping;
+    }
+}

package/dist/client/service-registry.d.ts

@@ -22,6 +22,7 @@ import { ResourceManagementServiceClient } from "../services/resource-management
 import { StateServiceClient } from "../services/state/state-service-client.js";
 import { TopologyAggregationServiceClient } from "../services/topology-aggregation/topology-aggregation-service-client.js";
 import { TopologyManagerReadServiceClient } from "../services/topology-manager-read/topology-manager-read-service-client.js";
+import { TopologyManagerWriteServiceClient } from "../services/topology-manager-write/topology-manager-write-service-client.js";
 import { TrafficControlServiceClient } from "../services/traffic-control/traffic-control-service-client.js";
 import { UpdateServiceClient } from "../services/update/update-service-client.js";
 import { UserManagementServiceClient } from "../services/user-management/user-management-service-client.js";
@@ -47,6 +48,7 @@ export interface ServiceRegistry {
     readonly identityInitializationService: IdentityInitializationServiceClient;
     readonly synchronizerConnectivityService: SynchronizerConnectivityServiceClient;
     readonly topologyManagerReadService: TopologyManagerReadServiceClient;
+    readonly topologyManagerWriteService: TopologyManagerWriteServiceClient;
     readonly trafficControlService: TrafficControlServiceClient;
     readonly topologyAggregationService: TopologyAggregationServiceClient;
     readonly commandService: CommandServiceClient;

package/dist/client/service-registry.js

@@ -25,6 +25,7 @@ import { ResourceManagementServiceClient } from "../services/resource-management
 import { StateServiceClient } from "../services/state/state-service-client.js";
 import { TopologyAggregationServiceClient } from "../services/topology-aggregation/topology-aggregation-service-client.js";
 import { TopologyManagerReadServiceClient } from "../services/topology-manager-read/topology-manager-read-service-client.js";
+import { TopologyManagerWriteServiceClient } from "../services/topology-manager-write/topology-manager-write-service-client.js";
 import { TrafficControlServiceClient } from "../services/traffic-control/traffic-control-service-client.js";
 import { UpdateServiceClient } from "../services/update/update-service-client.js";
 import { UserManagementServiceClient } from "../services/user-management/user-management-service-client.js";
@@ -55,6 +56,14 @@ class PlaceholderTransport {
         this.throwIfDisposed();
         throw new TransportError("party allocation is not available yet");
     }
+    async generateExternalPartyTopologyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("external party topology generation is not available yet");
+    }
+    async allocateExternalPartyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("external party allocation is not available yet");
+    }
     async listKnownPartiesAsync(_request, _options) {
         this.throwIfDisposed();
         throw new TransportError("known party listing is not available yet");
@@ -179,6 +188,14 @@ class PlaceholderTransport {
         this.throwIfDisposed();
         throw new TransportError("received ACS commitment inspection is not available yet");
     }
+    async addPartyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant party replication is not available yet");
+    }
+    async clearPartyOnboardingFlagAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("party onboarding flag clearing is not available yet");
+    }
     async getHighestOffsetByTimestampAsync(_request, _options) {
         this.throwIfDisposed();
         throw new TransportError("highest offset by timestamp is not available yet");
@@ -263,6 +280,38 @@ class PlaceholderTransport {
         this.throwIfDisposed();
         throw new TransportError("topology participant synchronizer permissions are not available yet");
     }
+    async authorizeTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology transaction authorization is not available yet");
+    }
+    async addTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology transaction writes are not available yet");
+    }
+    async importTopologySnapshotAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology snapshot import is not available yet");
+    }
+    async importTopologySnapshotV2Async(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology snapshot import v2 is not available yet");
+    }
+    async signTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology transaction signing is not available yet");
+    }
+    async generateTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology transaction generation is not available yet");
+    }
+    async createTemporaryTopologyStoreAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("temporary topology stores are not available yet");
+    }
+    async dropTemporaryTopologyStoreAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("temporary topology store deletion is not available yet");
+    }
     async listPartyHostingLimitsAsync(_request, _options) {
         this.throwIfDisposed();
         throw new TransportError("topology party hosting limits are not available yet");
@@ -396,6 +445,12 @@ class MissingEndpointTransport {
     async allocatePartyAsync() {
         this.throwMissingEndpoint();
     }
+    async generateExternalPartyTopologyAsync() {
+        this.throwMissingEndpoint();
+    }
+    async allocateExternalPartyAsync() {
+        this.throwMissingEndpoint();
+    }
     async listKnownPartiesAsync() {
         this.throwMissingEndpoint();
     }
@@ -489,6 +544,12 @@ class MissingEndpointTransport {
     async lookupReceivedAcsCommitmentsAsync() {
         this.throwMissingEndpoint();
     }
+    async addPartyAsync() {
+        this.throwMissingEndpoint();
+    }
+    async clearPartyOnboardingFlagAsync() {
+        this.throwMissingEndpoint();
+    }
     async getHighestOffsetByTimestampAsync() {
         this.throwMissingEndpoint();
     }
@@ -552,6 +613,30 @@ class MissingEndpointTransport {
     async listParticipantSynchronizerPermissionAsync() {
         this.throwMissingEndpoint();
     }
+    async authorizeTopologyTransactionsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async addTopologyTransactionsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async importTopologySnapshotAsync() {
+        this.throwMissingEndpoint();
+    }
+    async importTopologySnapshotV2Async() {
+        this.throwMissingEndpoint();
+    }
+    async signTopologyTransactionsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async generateTopologyTransactionsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async createTemporaryTopologyStoreAsync() {
+        this.throwMissingEndpoint();
+    }
+    async dropTemporaryTopologyStoreAsync() {
+        this.throwMissingEndpoint();
+    }
     async listPartyHostingLimitsAsync() {
         this.throwMissingEndpoint();
     }
@@ -655,6 +740,12 @@ class CompositeTransport {
     async allocatePartyAsync() {
         throw new TransportError("Composite transport does not forward service calls.");
     }
+    async generateExternalPartyTopologyAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async allocateExternalPartyAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
     async listKnownPartiesAsync() {
         throw new TransportError("Composite transport does not forward service calls.");
     }
@@ -748,6 +839,12 @@ class CompositeTransport {
     async lookupReceivedAcsCommitmentsAsync() {
         throw new TransportError("Composite transport does not forward service calls.");
     }
+    async addPartyAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async clearPartyOnboardingFlagAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
     async getHighestOffsetByTimestampAsync() {
         throw new TransportError("Composite transport does not forward service calls.");
     }
@@ -811,6 +908,30 @@ class CompositeTransport {
     async listParticipantSynchronizerPermissionAsync() {
         throw new TransportError("Composite transport does not forward service calls.");
     }
+    async authorizeTopologyTransactionsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async addTopologyTransactionsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async importTopologySnapshotAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async importTopologySnapshotV2Async() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async signTopologyTransactionsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async generateTopologyTransactionsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async createTemporaryTopologyStoreAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async dropTemporaryTopologyStoreAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
     async listPartyHostingLimitsAsync() {
         throw new TransportError("Composite transport does not forward service calls.");
     }
@@ -989,6 +1110,8 @@ export function createServiceRegistry(options) {
         ?? createMissingParticipantAdminTransport(options, "trafficControlService");
     const topologyManagerReadTransport = participantAdminTransport
         ?? createMissingParticipantAdminTransport(options, "topologyManagerReadService");
+    const topologyManagerWriteTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "topologyManagerWriteService");
     const topologyAggregationTransport = participantAdminTransport
         ?? createMissingParticipantAdminTransport(options, "topologyAggregationService");
     const transport = new CompositeTransport([
@@ -1016,6 +1139,7 @@ export function createServiceRegistry(options) {
         identityInitializationService: new IdentityInitializationServiceClient(identityInitializationTransport),
         synchronizerConnectivityService: new SynchronizerConnectivityServiceClient(synchronizerConnectivityTransport),
         topologyManagerReadService: new TopologyManagerReadServiceClient(topologyManagerReadTransport),
+        topologyManagerWriteService: new TopologyManagerWriteServiceClient(topologyManagerWriteTransport),
         trafficControlService: new TrafficControlServiceClient(trafficControlTransport),
         topologyAggregationService: new TopologyAggregationServiceClient(topologyAggregationTransport),
         commandService: new CommandServiceClient(commandTransport, options.commandSigner),

package/dist/core/hashing/canton-hash.d.ts

@@ -0,0 +1,3 @@
+export declare function computeCantonHash(content: Uint8Array, purpose: number): Uint8Array;
+export declare function computeCantonHashHex(content: Uint8Array, purpose: number): string;
+export declare function computeCantonPublicKeyFingerprint(publicKey: Uint8Array | undefined): string | undefined;

package/dist/core/hashing/canton-hash.js

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto";
+import { CantonHashPurpose } from "../types/canton-hash-purpose.js";
+const sha256MultihashPrefix = new Uint8Array([0x12, 0x20]);
+export function computeCantonHash(content, purpose) {
+    const purposePrefix = Buffer.alloc(4);
+    purposePrefix.writeUInt32BE(purpose, 0);
+    const digest = createHash("sha256")
+        .update(purposePrefix)
+        .update(content)
+        .digest();
+    return new Uint8Array(Buffer.concat([
+        Buffer.from(sha256MultihashPrefix),
+        digest,
+    ]));
+}
+export function computeCantonHashHex(content, purpose) {
+    return Buffer.from(computeCantonHash(content, purpose)).toString("hex");
+}
+export function computeCantonPublicKeyFingerprint(publicKey) {
+    if (publicKey === undefined || publicKey.length === 0) {
+        return undefined;
+    }
+    return computeCantonHashHex(publicKey, CantonHashPurpose.publicKeyFingerprint);
+}