@distrohelena/canton-typescript-sdk 0.1.1 → 0.1.2

package/README.md

@@ -36,6 +36,12 @@ 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:
 
@@ -55,6 +61,12 @@ Run:
 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
@@ -107,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`

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

@@ -26,6 +26,7 @@ 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;
@@ -59,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;
@@ -33,6 +34,7 @@ export class CantonClient {
     updateService;
     eventQueryService;
     contractService;
+    hashing;
     constructor(options) {
         this.options = options;
         if (options.transportKind === TransportKind.json &&
@@ -72,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.js

@@ -188,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");
@@ -536,6 +544,12 @@ class MissingEndpointTransport {
     async lookupReceivedAcsCommitmentsAsync() {
         this.throwMissingEndpoint();
     }
+    async addPartyAsync() {
+        this.throwMissingEndpoint();
+    }
+    async clearPartyOnboardingFlagAsync() {
+        this.throwMissingEndpoint();
+    }
     async getHighestOffsetByTimestampAsync() {
         this.throwMissingEndpoint();
     }
@@ -825,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.");
     }

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);
+}

package/dist/core/transports/transport.interface.d.ts

@@ -1,8 +1,10 @@
 import { TransportFeatures } from "./transport-features.interface.js";
 import { AllocateExternalPartyRequest } from "../types/requests/allocate-external-party-request.js";
 import { AllocatePartyRequest } from "../types/requests/allocate-party-request.js";
+import { AddPartyAsyncRequest } from "../types/requests/add-party-async-request.js";
 import { AddTopologyTransactionsRequest } from "../types/requests/add-topology-transactions-request.js";
 import { AuthorizeTopologyTransactionsRequest } from "../types/requests/authorize-topology-transactions-request.js";
+import { ClearPartyOnboardingFlagRequest } from "../types/requests/clear-party-onboarding-flag-request.js";
 import { GrantUserRightsRequest } from "../types/requests/grant-user-rights-request.js";
 import { CreateTemporaryTopologyStoreRequest } from "../types/requests/create-temporary-topology-store-request.js";
 import { GetActiveContractsPageRequest } from "../types/requests/get-active-contracts-page-request.js";
@@ -127,9 +129,11 @@ import { GetActiveContractsPageResponse } from "../types/responses/get-active-co
 import { GetLedgerApiVersionResponse } from "../types/responses/get-ledger-api-version-response.js";
 import { GetUpdatesPageResponse } from "../types/responses/get-updates-page-response.js";
 import { GetUserResponse } from "../types/responses/get-user-response.js";
+import { AddPartyAsyncResponse } from "../types/responses/add-party-async-response.js";
 import { AddTopologyTransactionsResponse } from "../types/responses/add-topology-transactions-response.js";
 import { AllocateExternalPartyResponse } from "../types/responses/allocate-external-party-response.js";
 import { AuthorizeTopologyTransactionsResponse } from "../types/responses/authorize-topology-transactions-response.js";
+import { ClearPartyOnboardingFlagResponse } from "../types/responses/clear-party-onboarding-flag-response.js";
 import { CreateTemporaryTopologyStoreResponse } from "../types/responses/create-temporary-topology-store-response.js";
 import { DropTemporaryTopologyStoreResponse } from "../types/responses/drop-temporary-topology-store-response.js";
 import { GenerateTopologyTransactionsResponse } from "../types/responses/generate-topology-transactions-response.js";
@@ -260,6 +264,10 @@ export interface ITransport {
     lookupSentAcsCommitmentsAsync(request: LookupSentAcsCommitmentsRequest, options?: RequestOptions): Promise<LookupSentAcsCommitmentsResponse>;
     /** Reads received ACS commitments. Supported on gRPC; JSON rejects it. */
     lookupReceivedAcsCommitmentsAsync(request: LookupReceivedAcsCommitmentsRequest, options?: RequestOptions): Promise<LookupReceivedAcsCommitmentsResponse>;
+    /** Starts online party replication on the target participant. Supported on gRPC; JSON rejects it. */
+    addPartyAsync(request: AddPartyAsyncRequest, options?: RequestOptions): Promise<AddPartyAsyncResponse>;
+    /** Clears an onboarding flag on the target participant. Supported on gRPC; JSON rejects it. */
+    clearPartyOnboardingFlagAsync(request: ClearPartyOnboardingFlagRequest, options?: RequestOptions): Promise<ClearPartyOnboardingFlagResponse>;
     /** Reads the highest participant ledger offset before or at a timestamp. Supported on gRPC; JSON rejects it. */
     getHighestOffsetByTimestampAsync(request: GetHighestOffsetByTimestampRequest, options?: RequestOptions): Promise<GetHighestOffsetByTimestampResponse>;
     /** Reads the safe participant pruning offset. Supported on gRPC; JSON rejects it. */

package/dist/core/types/canton-hash-purpose.d.ts

@@ -0,0 +1,4 @@
+export declare enum CantonHashPurpose {
+    topologyTransactionSignature = 11,
+    publicKeyFingerprint = 12
+}

package/dist/core/types/canton-hash-purpose.js

@@ -0,0 +1,5 @@
+export var CantonHashPurpose;
+(function (CantonHashPurpose) {
+    CantonHashPurpose[CantonHashPurpose["topologyTransactionSignature"] = 11] = "topologyTransactionSignature";
+    CantonHashPurpose[CantonHashPurpose["publicKeyFingerprint"] = 12] = "publicKeyFingerprint";
+})(CantonHashPurpose || (CantonHashPurpose = {}));

package/dist/core/types/requests/add-party-async-request.d.ts

@@ -0,0 +1,27 @@
+import { ParticipantPermission } from "../topology/participant-permission.js";
+export declare class AddPartyAsyncArguments {
+    readonly partyId: string;
+    readonly synchronizerId: string;
+    readonly sourceParticipantUid: string;
+    readonly topologySerial: number;
+    readonly participantPermission: ParticipantPermission;
+    constructor(init: {
+        partyId: string;
+        synchronizerId: string;
+        sourceParticipantUid: string;
+        topologySerial: number;
+        participantPermission?: ParticipantPermission;
+    });
+}
+export declare class AddPartyAsyncRequest {
+    readonly arguments: AddPartyAsyncArguments;
+    constructor(init: {
+        arguments: AddPartyAsyncArguments | {
+            partyId: string;
+            synchronizerId: string;
+            sourceParticipantUid: string;
+            topologySerial: number;
+            participantPermission?: ParticipantPermission;
+        };
+    });
+}

package/dist/core/types/requests/add-party-async-request.js

@@ -0,0 +1,25 @@
+import { ParticipantPermission } from "../topology/participant-permission.js";
+export class AddPartyAsyncArguments {
+    partyId;
+    synchronizerId;
+    sourceParticipantUid;
+    topologySerial;
+    participantPermission;
+    constructor(init) {
+        this.partyId = init.partyId;
+        this.synchronizerId = init.synchronizerId;
+        this.sourceParticipantUid = init.sourceParticipantUid;
+        this.topologySerial = init.topologySerial;
+        this.participantPermission =
+            init.participantPermission ?? ParticipantPermission.unspecified;
+    }
+}
+export class AddPartyAsyncRequest {
+    arguments;
+    constructor(init) {
+        this.arguments =
+            init.arguments instanceof AddPartyAsyncArguments
+                ? init.arguments
+                : new AddPartyAsyncArguments(init.arguments);
+    }
+}

package/dist/core/types/requests/clear-party-onboarding-flag-request.d.ts

@@ -0,0 +1,13 @@
+import { TopologyDuration } from "../topology/topology-duration.js";
+export declare class ClearPartyOnboardingFlagRequest {
+    readonly partyId: string;
+    readonly synchronizerId: string;
+    readonly beginOffsetExclusive: string;
+    readonly waitForActivationTimeout?: TopologyDuration;
+    constructor(init: {
+        partyId: string;
+        synchronizerId: string;
+        beginOffsetExclusive: string;
+        waitForActivationTimeout?: TopologyDuration;
+    });
+}

package/dist/core/types/requests/clear-party-onboarding-flag-request.js

@@ -0,0 +1,12 @@
+export class ClearPartyOnboardingFlagRequest {
+    partyId;
+    synchronizerId;
+    beginOffsetExclusive;
+    waitForActivationTimeout;
+    constructor(init) {
+        this.partyId = init.partyId;
+        this.synchronizerId = init.synchronizerId;
+        this.beginOffsetExclusive = init.beginOffsetExclusive;
+        this.waitForActivationTimeout = init.waitForActivationTimeout;
+    }
+}

package/dist/core/types/requests/get-active-contracts-page-request.d.ts

@@ -1,8 +1,20 @@
 export declare class GetActiveContractsPageRequest {
     readonly party: string;
     readonly templateId?: string;
+    readonly interfaceId?: string;
+    readonly includeInterfaceView?: boolean;
+    readonly includeCreatedEventBlob?: boolean;
+    readonly activeAtOffset?: string;
+    readonly maxPageSize?: number;
+    readonly pageToken?: Uint8Array;
     constructor(init: {
         party: string;
         templateId?: string;
+        interfaceId?: string;
+        includeInterfaceView?: boolean;
+        includeCreatedEventBlob?: boolean;
+        activeAtOffset?: string;
+        maxPageSize?: number;
+        pageToken?: Uint8Array;
     });
 }

package/dist/core/types/requests/get-active-contracts-page-request.js

@@ -1,8 +1,20 @@
 export class GetActiveContractsPageRequest {
     party;
     templateId;
+    interfaceId;
+    includeInterfaceView;
+    includeCreatedEventBlob;
+    activeAtOffset;
+    maxPageSize;
+    pageToken;
     constructor(init) {
         this.party = init.party;
         this.templateId = init.templateId;
+        this.interfaceId = init.interfaceId;
+        this.includeInterfaceView = init.includeInterfaceView;
+        this.includeCreatedEventBlob = init.includeCreatedEventBlob;
+        this.activeAtOffset = init.activeAtOffset;
+        this.maxPageSize = init.maxPageSize;
+        this.pageToken = init.pageToken;
     }
 }

package/dist/core/types/responses/add-party-async-response.d.ts

@@ -0,0 +1,6 @@
+export declare class AddPartyAsyncResponse {
+    readonly addPartyRequestId: string;
+    constructor(init?: {
+        addPartyRequestId?: string;
+    });
+}

package/dist/core/types/responses/add-party-async-response.js

@@ -0,0 +1,6 @@
+export class AddPartyAsyncResponse {
+    addPartyRequestId;
+    constructor(init = {}) {
+        this.addPartyRequestId = init.addPartyRequestId ?? "";
+    }
+}

package/dist/core/types/responses/clear-party-onboarding-flag-response.d.ts

@@ -0,0 +1,8 @@
+export declare class ClearPartyOnboardingFlagResponse {
+    readonly onboarded: boolean;
+    readonly earliestRetryTimestamp?: Date;
+    constructor(init?: {
+        onboarded?: boolean;
+        earliestRetryTimestamp?: Date;
+    });
+}

package/dist/core/types/responses/clear-party-onboarding-flag-response.js

@@ -0,0 +1,8 @@
+export class ClearPartyOnboardingFlagResponse {
+    onboarded;
+    earliestRetryTimestamp;
+    constructor(init = {}) {
+        this.onboarded = init.onboarded ?? false;
+        this.earliestRetryTimestamp = init.earliestRetryTimestamp;
+    }
+}

package/dist/core/types/responses/get-active-contracts-page-response.d.ts

@@ -1,6 +1,10 @@
 export declare class GetActiveContractsPageResponse<TContract = unknown> {
     readonly contracts: readonly TContract[];
+    readonly activeAtOffset?: string;
+    readonly nextPageToken?: Uint8Array;
     constructor(init: {
         contracts: readonly TContract[];
+        activeAtOffset?: string;
+        nextPageToken?: Uint8Array;
     });
 }

package/dist/core/types/responses/get-active-contracts-page-response.js

@@ -1,6 +1,10 @@
 export class GetActiveContractsPageResponse {
     contracts;
+    activeAtOffset;
+    nextPageToken;
     constructor(init) {
         this.contracts = init.contracts;
+        this.activeAtOffset = init.activeAtOffset;
+        this.nextPageToken = init.nextPageToken;
     }
 }

package/dist/core/types/topology/topology-public-key.d.ts

@@ -1,10 +1,12 @@
 export declare class TopologySigningPublicKey {
+    readonly fingerprint?: string;
     readonly format?: string;
     readonly publicKey: Uint8Array;
     readonly scheme?: string;
     readonly usage: string[];
     readonly keySpec?: string;
     constructor(init?: {
+        fingerprint?: string;
         format?: string;
         publicKey?: Uint8Array;
         scheme?: string;
@@ -13,11 +15,13 @@ export declare class TopologySigningPublicKey {
     });
 }
 export declare class TopologyEncryptionPublicKey {
+    readonly fingerprint?: string;
     readonly format?: string;
     readonly publicKey: Uint8Array;
     readonly scheme?: string;
     readonly keySpec?: string;
     constructor(init?: {
+        fingerprint?: string;
         format?: string;
         publicKey?: Uint8Array;
         scheme?: string;