@distrohelena/canton-typescript-sdk 0.1.0 → 0.1.2

package/dist/transports/grpc/mappers/topology-manager-write-mapper.js

@@ -0,0 +1,451 @@
+import { ValidationError } from "../../../core/errors/validation-error.js";
+import { AddTopologyTransactionsResponse } from "../../../core/types/responses/add-topology-transactions-response.js";
+import { AuthorizeTopologyTransactionsResponse } from "../../../core/types/responses/authorize-topology-transactions-response.js";
+import { CreateTemporaryTopologyStoreResponse } from "../../../core/types/responses/create-temporary-topology-store-response.js";
+import { DropTemporaryTopologyStoreResponse } from "../../../core/types/responses/drop-temporary-topology-store-response.js";
+import { GenerateTopologyTransactionsResponse } from "../../../core/types/responses/generate-topology-transactions-response.js";
+import { ImportTopologySnapshotResponse } from "../../../core/types/responses/import-topology-snapshot-response.js";
+import { ImportTopologySnapshotV2Response } from "../../../core/types/responses/import-topology-snapshot-v2-response.js";
+import { SignTopologyTransactionsResponse } from "../../../core/types/responses/sign-topology-transactions-response.js";
+import { GeneratedTopologyTransaction } from "../../../core/types/topology/generated-topology-transaction.js";
+import { MultiTopologyTransactionSignature } from "../../../core/types/topology/multi-topology-transaction-signature.js";
+import { PartyToParticipant, PartyToParticipantOnboarding, } from "../../../core/types/topology/party-to-participant.js";
+import { SignedTopologyTransaction } from "../../../core/types/topology/signed-topology-transaction.js";
+import { TopologyForceFlag } from "../../../core/types/topology/topology-force-flag.js";
+import { TopologySignatureDelegation } from "../../../core/types/topology/topology-signature-delegation.js";
+import { TopologyStoreTemporary } from "../../../core/types/topology/topology-store-id.js";
+import { TopologyTransactionSignature } from "../../../core/types/topology/topology-transaction-signature.js";
+import { CryptoKeyFormat, SignatureFormat as GrpcSignatureFormat, SigningAlgorithmSpec, SigningKeyScheme, SigningKeySpec, SigningKeyUsage, } from "../generated/canton/com/digitalasset/canton/crypto/v30/crypto.js";
+import { ForceFlag, } from "../generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_write_service.js";
+import { Enums_ParticipantPermission, } from "../generated/canton/com/digitalasset/canton/protocol/v30/topology.js";
+import { mapGrpcTopologyChangeOp, mapGrpcTopologyStoreId, } from "./topology-common-mapper.js";
+export function mapGrpcGenerateTopologyTransactionsRequest(request) {
+    return {
+        proposals: request.proposals.map(mapGrpcGenerateTopologyTransactionsProposal),
+    };
+}
+export function mapGrpcGenerateTopologyTransactionsResponse(payload) {
+    return new GenerateTopologyTransactionsResponse({
+        generatedTransactions: (payload.generatedTransactions ?? []).map((item) => new GeneratedTopologyTransaction({
+            serializedTransaction: item.serializedTransaction,
+            transactionHash: item.transactionHash,
+        })),
+    });
+}
+export function mapGrpcAuthorizeTopologyTransactionsRequest(request) {
+    return {
+        type: request.proposal !== undefined
+            ? {
+                oneofKind: "proposal",
+                proposal: mapGrpcAuthorizeTopologyTransactionsProposal(request.proposal),
+            }
+            : request.transactionHash !== undefined
+                ? {
+                    oneofKind: "transactionHash",
+                    transactionHash: request.transactionHash,
+                }
+                : {
+                    oneofKind: undefined,
+                },
+        mustFullyAuthorize: request.mustFullyAuthorize,
+        forceChanges: request.forceChanges.map(mapGrpcForceFlag),
+        signedBy: [...request.signedBy],
+        store: mapGrpcTopologyStoreId(request.store),
+        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
+    };
+}
+export function mapGrpcAuthorizeTopologyTransactionsResponse(payload) {
+    return new AuthorizeTopologyTransactionsResponse({
+        transaction: payload.transaction === undefined
+            ? undefined
+            : mapSdkSignedTopologyTransaction(payload.transaction),
+    });
+}
+export function mapGrpcAddTopologyTransactionsRequest(request) {
+    return {
+        transactions: request.transactions.map(mapGrpcSignedTopologyTransaction),
+        forceChanges: request.forceChanges.map(mapGrpcForceFlag),
+        store: mapGrpcTopologyStoreId(request.store),
+        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
+    };
+}
+export function mapGrpcAddTopologyTransactionsResponse(_payload) {
+    return new AddTopologyTransactionsResponse();
+}
+export function mapGrpcImportTopologySnapshotRequest(request) {
+    return {
+        topologySnapshot: new Uint8Array(request.topologySnapshot),
+        store: mapGrpcTopologyStoreId(request.store),
+        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
+    };
+}
+export function mapGrpcImportTopologySnapshotResponse(_payload) {
+    return new ImportTopologySnapshotResponse();
+}
+export function mapGrpcImportTopologySnapshotV2Request(request) {
+    return {
+        topologySnapshot: new Uint8Array(request.topologySnapshot),
+        store: mapGrpcTopologyStoreId(request.store),
+        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
+    };
+}
+export function mapGrpcImportTopologySnapshotV2Response(_payload) {
+    return new ImportTopologySnapshotV2Response();
+}
+export function mapGrpcSignTopologyTransactionsRequest(request) {
+    return {
+        transactions: request.transactions.map(mapGrpcSignedTopologyTransaction),
+        signedBy: [...request.signedBy],
+        store: mapGrpcTopologyStoreId(request.store),
+        forceFlags: request.forceFlags.map(mapGrpcForceFlag),
+    };
+}
+export function mapGrpcSignTopologyTransactionsResponse(payload) {
+    return new SignTopologyTransactionsResponse({
+        transactions: (payload.transactions ?? []).map(mapSdkSignedTopologyTransaction),
+    });
+}
+export function mapGrpcCreateTemporaryTopologyStoreRequest(request) {
+    return {
+        name: request.name,
+        protocolVersion: request.protocolVersion,
+    };
+}
+export function mapGrpcCreateTemporaryTopologyStoreResponse(payload) {
+    return new CreateTemporaryTopologyStoreResponse({
+        storeId: payload.storeId === undefined
+            ? undefined
+            : new TopologyStoreTemporary({
+                name: payload.storeId.name,
+            }),
+    });
+}
+export function mapGrpcDropTemporaryTopologyStoreRequest(request) {
+    return {
+        storeId: mapGrpcTemporaryStoreId(request.storeId),
+    };
+}
+export function mapGrpcDropTemporaryTopologyStoreResponse(_payload) {
+    return new DropTemporaryTopologyStoreResponse();
+}
+function mapGrpcGenerateTopologyTransactionsProposal(proposal) {
+    return {
+        operation: mapGrpcTopologyChangeOp(proposal.operation),
+        serial: proposal.serial,
+        mapping: mapGrpcTopologyMapping(proposal.mapping),
+        store: mapGrpcTopologyStoreId(proposal.store),
+    };
+}
+function mapGrpcAuthorizeTopologyTransactionsProposal(proposal) {
+    return {
+        change: mapGrpcTopologyChangeOp(proposal.operation),
+        serial: proposal.serial,
+        mapping: mapGrpcTopologyMapping(proposal.mapping),
+    };
+}
+function mapGrpcTopologyMapping(mapping) {
+    if (mapping === undefined) {
+        return undefined;
+    }
+    else if (mapping instanceof PartyToParticipant) {
+        return {
+            mapping: {
+                oneofKind: "partyToParticipant",
+                partyToParticipant: mapGrpcPartyToParticipant(mapping),
+            },
+        };
+    }
+    throw new ValidationError(`Unsupported topology write mapping type: ${mapping.constructor.name}.`);
+}
+function mapGrpcPartyToParticipant(value) {
+    return {
+        party: value.party,
+        threshold: value.threshold,
+        participants: value.participants.map(mapGrpcPartyToParticipantParticipant),
+        partySigningKeys: mapGrpcSigningKeysWithThreshold(value.partySigningKeys),
+    };
+}
+function mapGrpcPartyToParticipantParticipant(value) {
+    return {
+        participantUid: value.participantUid,
+        permission: mapGrpcParticipantPermission(value.permission),
+        onboarding: value.onboarding instanceof PartyToParticipantOnboarding
+            ? {}
+            : undefined,
+    };
+}
+function mapGrpcSigningKeysWithThreshold(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return {
+        threshold: value.threshold,
+        keys: value.keys.map(mapGrpcSigningPublicKey),
+    };
+}
+function mapGrpcSigningPublicKey(value) {
+    return {
+        format: mapGrpcCryptoKeyFormat(value.format),
+        publicKey: new Uint8Array(value.publicKey),
+        scheme: mapGrpcSigningKeyScheme(value.scheme, value.keySpec),
+        usage: value.usage.map(mapGrpcSigningKeyUsage),
+        keySpec: mapGrpcSigningKeySpec(value.keySpec),
+    };
+}
+function mapGrpcSignedTopologyTransaction(value) {
+    return {
+        transaction: new Uint8Array(value.transaction),
+        signatures: value.signatures.map(mapGrpcTopologyTransactionSignature),
+        proposal: value.proposal,
+        multiTransactionSignatures: value.multiTransactionSignatures.map(mapGrpcMultiTopologyTransactionSignature),
+    };
+}
+function mapSdkSignedTopologyTransaction(value) {
+    return new SignedTopologyTransaction({
+        transaction: value.transaction,
+        signatures: (value.signatures ?? []).map(mapSdkTopologyTransactionSignature),
+        proposal: value.proposal ?? false,
+        multiTransactionSignatures: (value.multiTransactionSignatures ?? []).map(mapSdkMultiTopologyTransactionSignature),
+    });
+}
+function mapGrpcTopologyTransactionSignature(value) {
+    return {
+        format: mapGrpcSignatureFormat(value.format),
+        signature: new Uint8Array(value.signature),
+        signedBy: value.signedByFingerprint,
+        signingAlgorithmSpec: mapGrpcSigningAlgorithmSpec(value.signingAlgorithmSpec),
+        signatureDelegation: value.signatureDelegation === undefined
+            ? undefined
+            : mapGrpcSignatureDelegation(value.signatureDelegation),
+    };
+}
+function mapSdkTopologyTransactionSignature(value) {
+    return new TopologyTransactionSignature({
+        format: mapSdkSignatureFormat(value.format),
+        signature: value.signature,
+        signedByFingerprint: value.signedBy ?? "",
+        signingAlgorithmSpec: mapSdkSigningAlgorithmSpec(value.signingAlgorithmSpec),
+        signatureDelegation: value.signatureDelegation === undefined
+            ? undefined
+            : mapSdkSignatureDelegation(value.signatureDelegation),
+    });
+}
+function mapGrpcMultiTopologyTransactionSignature(value) {
+    return {
+        transactionHashes: value.transactionHashes.map((item) => new Uint8Array(item)),
+        signatures: value.signatures.map(mapGrpcTopologyTransactionSignature),
+    };
+}
+function mapSdkMultiTopologyTransactionSignature(value) {
+    return new MultiTopologyTransactionSignature({
+        transactionHashes: (value.transactionHashes ?? []).map((item) => new Uint8Array(item)),
+        signatures: (value.signatures ?? []).map(mapSdkTopologyTransactionSignature),
+    });
+}
+function mapGrpcSignatureDelegation(value) {
+    return {
+        sessionKey: new Uint8Array(value.sessionKey),
+        sessionKeySpec: mapGrpcSigningKeySpec(value.sessionKeySpec),
+        validityPeriodFromInclusive: value.validityPeriodFromInclusive,
+        validityPeriodDurationSeconds: value.validityPeriodDurationSeconds,
+        format: mapGrpcSignatureFormat(value.format),
+        signature: new Uint8Array(value.signature),
+        signingAlgorithmSpec: mapGrpcSigningAlgorithmSpec(value.signingAlgorithmSpec),
+    };
+}
+function mapSdkSignatureDelegation(value) {
+    return new TopologySignatureDelegation({
+        sessionKey: value.sessionKey,
+        sessionKeySpec: mapSdkSigningKeySpec(value.sessionKeySpec),
+        validityPeriodFromInclusive: value.validityPeriodFromInclusive ?? "0",
+        validityPeriodDurationSeconds: value.validityPeriodDurationSeconds ?? 0,
+        format: mapSdkSignatureFormat(value.format),
+        signature: value.signature,
+        signingAlgorithmSpec: mapSdkSigningAlgorithmSpec(value.signingAlgorithmSpec),
+    });
+}
+function mapGrpcDuration(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return {
+        seconds: value.seconds,
+        nanos: value.nanos,
+    };
+}
+function mapGrpcForceFlag(value) {
+    switch (value) {
+        case TopologyForceFlag.alienMember:
+            return ForceFlag.ALIEN_MEMBER;
+        case TopologyForceFlag.ledgerTimeRecordTimeToleranceIncrease:
+            return ForceFlag.LEDGER_TIME_RECORD_TIME_TOLERANCE_INCREASE;
+        case TopologyForceFlag.allowUnknownPackage:
+            return ForceFlag.ALLOW_UNKNOWN_PACKAGE;
+        case TopologyForceFlag.allowUnvettedDependencies:
+            return ForceFlag.ALLOW_UNVETTED_DEPENDENCIES;
+        case TopologyForceFlag.disablePartyWithActiveContracts:
+            return ForceFlag.DISABLE_PARTY_WITH_ACTIVE_CONTRACTS;
+        case TopologyForceFlag.unspecified:
+        default:
+            return ForceFlag.UNSPECIFIED;
+    }
+}
+function mapGrpcParticipantPermission(value) {
+    switch (value) {
+        case "submission":
+            return Enums_ParticipantPermission.SUBMISSION;
+        case "confirmation":
+            return Enums_ParticipantPermission.CONFIRMATION;
+        case "observation":
+            return Enums_ParticipantPermission.OBSERVATION;
+        case "unspecified":
+        default:
+            return Enums_ParticipantPermission.UNSPECIFIED;
+    }
+}
+function mapGrpcSignatureFormat(value) {
+    switch (value) {
+        case "raw":
+            return GrpcSignatureFormat.RAW;
+        case "der":
+            return GrpcSignatureFormat.DER;
+        case "concat":
+            return GrpcSignatureFormat.CONCAT;
+        case "symbolic":
+            return GrpcSignatureFormat.SYMBOLIC;
+        default:
+            return GrpcSignatureFormat.UNSPECIFIED;
+    }
+}
+function mapSdkSignatureFormat(value) {
+    switch (value) {
+        case GrpcSignatureFormat.RAW:
+            return "raw";
+        case GrpcSignatureFormat.DER:
+            return "der";
+        case GrpcSignatureFormat.CONCAT:
+            return "concat";
+        case GrpcSignatureFormat.SYMBOLIC:
+            return "symbolic";
+        case GrpcSignatureFormat.UNSPECIFIED:
+        default:
+            return "unspecified";
+    }
+}
+function mapGrpcSigningAlgorithmSpec(value) {
+    switch (value) {
+        case "ed25519":
+            return SigningAlgorithmSpec.ED25519;
+        case "ecDsaSha256":
+            return SigningAlgorithmSpec.EC_DSA_SHA_256;
+        case "ecDsaSha384":
+            return SigningAlgorithmSpec.EC_DSA_SHA_384;
+        case "mlDsa65":
+            return SigningAlgorithmSpec.ML_DSA_65;
+        default:
+            return SigningAlgorithmSpec.UNSPECIFIED;
+    }
+}
+function mapSdkSigningAlgorithmSpec(value) {
+    switch (value) {
+        case SigningAlgorithmSpec.ED25519:
+            return "ed25519";
+        case SigningAlgorithmSpec.EC_DSA_SHA_256:
+            return "ecDsaSha256";
+        case SigningAlgorithmSpec.EC_DSA_SHA_384:
+            return "ecDsaSha384";
+        case SigningAlgorithmSpec.ML_DSA_65:
+            return "mlDsa65";
+        case SigningAlgorithmSpec.UNSPECIFIED:
+        default:
+            return "unspecified";
+    }
+}
+function mapGrpcCryptoKeyFormat(value) {
+    switch (value) {
+        case "der":
+            return CryptoKeyFormat.DER;
+        case "raw":
+            return CryptoKeyFormat.RAW;
+        case "derX509SubjectPublicKeyInfo":
+            return CryptoKeyFormat.DER_X509_SUBJECT_PUBLIC_KEY_INFO;
+        case "derPkcs8PrivateKeyInfo":
+            return CryptoKeyFormat.DER_PKCS8_PRIVATE_KEY_INFO;
+        case "symbolic":
+            return CryptoKeyFormat.SYMBOLIC;
+        default:
+            return CryptoKeyFormat.UNSPECIFIED;
+    }
+}
+function mapGrpcSigningKeyUsage(value) {
+    switch (value) {
+        case "namespace":
+            return SigningKeyUsage.NAMESPACE;
+        case "identityDelegation":
+            return SigningKeyUsage.IDENTITY_DELEGATION;
+        case "sequencerAuthentication":
+            return SigningKeyUsage.SEQUENCER_AUTHENTICATION;
+        case "protocol":
+            return SigningKeyUsage.PROTOCOL;
+        case "proofOfOwnership":
+            return SigningKeyUsage.PROOF_OF_OWNERSHIP;
+        default:
+            return SigningKeyUsage.UNSPECIFIED;
+    }
+}
+function mapGrpcSigningKeySpec(value) {
+    switch (value) {
+        case "ecCurve25519":
+            return SigningKeySpec.EC_CURVE25519;
+        case "ecP256":
+            return SigningKeySpec.EC_P256;
+        case "ecP384":
+            return SigningKeySpec.EC_P384;
+        case "ecSecp256k1":
+            return SigningKeySpec.EC_SECP256K1;
+        case "mlDsa65":
+            return SigningKeySpec.ML_DSA_65;
+        default:
+            return SigningKeySpec.UNSPECIFIED;
+    }
+}
+function mapGrpcSigningKeyScheme(scheme, keySpec) {
+    switch (scheme ?? keySpec) {
+        case "ed25519":
+        case "ecCurve25519":
+            return SigningKeyScheme.ED25519;
+        case "ecDsaP256":
+        case "ecP256":
+            return SigningKeyScheme.EC_DSA_P256;
+        case "ecDsaP384":
+        case "ecP384":
+            return SigningKeyScheme.EC_DSA_P384;
+        default:
+            return SigningKeyScheme.UNSPECIFIED;
+    }
+}
+function mapSdkSigningKeySpec(value) {
+    switch (value) {
+        case SigningKeySpec.EC_CURVE25519:
+            return "ecCurve25519";
+        case SigningKeySpec.EC_P256:
+            return "ecP256";
+        case SigningKeySpec.EC_P384:
+            return "ecP384";
+        case SigningKeySpec.EC_SECP256K1:
+            return "ecSecp256k1";
+        case SigningKeySpec.ML_DSA_65:
+            return "mlDsa65";
+        case SigningKeySpec.UNSPECIFIED:
+        default:
+            return "unspecified";
+    }
+}
+function mapGrpcTemporaryStoreId(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return {
+        name: value.name,
+    };
+}

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

@@ -1,8 +1,11 @@
+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";
@@ -39,6 +42,7 @@ import { GrantUserRightsRequest } from "../../core/types/requests/grant-user-rig
 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";
+import { GenerateExternalPartyTopologyRequest } from "../../core/types/requests/generate-external-party-topology-request.js";
 import { HealthCheckRequest } from "../../core/types/requests/health-check-request.js";
 import { ListPackagesRequest } from "../../core/types/requests/list-packages-request.js";
 import { ListVettedPackagesRequest } from "../../core/types/requests/list-vetted-packages-request.js";
@@ -61,6 +65,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 } 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 { GetConnectedSynchronizersResponse } from "../../core/types/responses/get-connected-synchronizers-response.js";
 import { CountInFlightResponse } from "../../core/types/responses/count-in-flight-response.js";
 import { CurrentTimeResponse } from "../../core/types/responses/current-time-response.js";
@@ -98,7 +104,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 { ListKnownPackagesResponse } from "../../core/types/responses/list-known-packages-response.js";
 import { ListDarsResponse } from "../../core/types/responses/list-dars-response.js";
 import { ListConnectedSynchronizersResponse } from "../../core/types/responses/list-connected-synchronizers-response.js";
@@ -139,6 +147,8 @@ export declare class JsonTransport implements ITransport {
     listKnownPartiesAsync(request: ListKnownPartiesRequest, options?: RequestOptions): Promise<ListKnownPartiesResponse>;
     getParticipantIdAsync(_request: GetParticipantIdRequest, _options?: RequestOptions): Promise<GetParticipantIdResponse>;
     getPartiesAsync(_request: GetPartiesRequest, _options?: RequestOptions): Promise<GetPartiesResponse>;
+    generateExternalPartyTopologyAsync(_request: GenerateExternalPartyTopologyRequest, _options?: RequestOptions): Promise<GenerateExternalPartyTopologyResponse>;
+    allocateExternalPartyAsync(_request: AllocateExternalPartyRequest, _options?: RequestOptions): Promise<AllocateExternalPartyResponse>;
     grantUserRightsAsync(request: GrantUserRightsRequest, options?: RequestOptions): Promise<GrantUserRightsResponse>;
     getCommandStatusAsync(_request: GetCommandStatusRequest, _options?: RequestOptions): Promise<GetCommandStatusResponse>;
     getUserAsync(_request: GetUserRequest, _options?: RequestOptions): Promise<GetUserResponse>;
@@ -167,6 +177,8 @@ export declare class JsonTransport 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>;
@@ -188,6 +200,14 @@ export declare class JsonTransport implements ITransport {
     listPartyToKeyMappingAsync(_request: any, _options?: RequestOptions): Promise<any>;
     listSynchronizerTrustCertificateAsync(_request: any, _options?: RequestOptions): Promise<any>;
     listParticipantSynchronizerPermissionAsync(_request: any, _options?: RequestOptions): Promise<any>;
+    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: any, _options?: RequestOptions): Promise<any>;
     topologyListVettedPackagesAsync(_request: any, _options?: RequestOptions): Promise<any>;
     listPartyToParticipantAsync(_request: any, _options?: RequestOptions): Promise<any>;

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

@@ -7,7 +7,7 @@ import { NotSupportedError } from "../../core/errors/not-supported-error.js";
 import { ObjectDisposedError } from "../../core/errors/object-disposed-error.js";
 import { mapJsonSubmitCommand } from "./mappers/commands-mapper.js";
 import { mapJsonUploadPackage } from "./mappers/packages-mapper.js";
-import { mapJsonCreateParty, mapJsonListParties } from "./mappers/parties-mapper.js";
+import { mapJsonAllocatePartyRequest, mapJsonCreateParty, mapJsonListParties, } from "./mappers/parties-mapper.js";
 import { mapJsonQueryContracts } from "./mappers/contracts-mapper.js";
 import { mapJsonTransactionEvents } from "./mappers/events-mapper.js";
 import { mapJsonGrantRights } from "./mappers/users-mapper.js";
@@ -25,7 +25,7 @@ export class JsonTransport {
     }
     async getLedgerApiVersionAsync(_request, options) {
         this.throwIfDisposed();
-        const payload = await this.httpClient.getAsync("/livez", options);
+        const payload = await this.httpClient.getAsync("/v2/version", options);
         return new GetLedgerApiVersionResponse({
             version: payload.version
                 ?? "unknown",
@@ -37,10 +37,7 @@ export class JsonTransport {
     }
     async allocatePartyAsync(request, options) {
         this.throwIfDisposed();
-        const payload = await this.httpClient.postAsync("/v1/parties/allocate", {
-            identifierHint: request.partyIdHint,
-            displayName: request.displayName,
-        }, options);
+        const payload = await this.httpClient.postAsync("/v2/parties", mapJsonAllocatePartyRequest(request), options);
         const response = mapJsonCreateParty(payload);
         return new AllocatePartyResponse({
             party: response.party,
@@ -77,6 +74,14 @@ export class JsonTransport {
         this.throwIfDisposed();
         throw new NotSupportedError("PartyManagementService.GetParties is not supported by json transport");
     }
+    async generateExternalPartyTopologyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PartyManagementService.GenerateExternalPartyTopology is not supported by json transport");
+    }
+    async allocateExternalPartyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PartyManagementService.AllocateExternalParty is not supported by json transport");
+    }
     async grantUserRightsAsync(request, options) {
         this.throwIfDisposed();
         const payload = await this.httpClient.postAsync("/v1/user/rights/grant", {
@@ -203,6 +208,14 @@ export class JsonTransport {
         this.throwIfDisposed();
         throw new NotSupportedError("ParticipantInspectionService.LookupReceivedAcsCommitments is not supported by json transport");
     }
+    async addPartyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantPartyManagementService.AddPartyAsync is not supported by json transport");
+    }
+    async clearPartyOnboardingFlagAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantPartyManagementService.ClearPartyOnboardingFlag is not supported by json transport");
+    }
     async getHighestOffsetByTimestampAsync(_request, _options) {
         this.throwIfDisposed();
         throw new NotSupportedError("ParticipantPartyManagementService.GetHighestOffsetByTimestamp is not supported by json transport");
@@ -287,6 +300,38 @@ export class JsonTransport {
         this.throwIfDisposed();
         throw new NotSupportedError("TopologyManagerReadService.ListParticipantSynchronizerPermission is not supported by json transport");
     }
+    async authorizeTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.Authorize is not supported by json transport");
+    }
+    async addTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.AddTransactions is not supported by json transport");
+    }
+    async importTopologySnapshotAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.ImportTopologySnapshot is not supported by json transport");
+    }
+    async importTopologySnapshotV2Async(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.ImportTopologySnapshotV2 is not supported by json transport");
+    }
+    async signTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.SignTransactions is not supported by json transport");
+    }
+    async generateTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.GenerateTransactions is not supported by json transport");
+    }
+    async createTemporaryTopologyStoreAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.CreateTemporaryTopologyStore is not supported by json transport");
+    }
+    async dropTemporaryTopologyStoreAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerWriteService.DropTemporaryTopologyStore is not supported by json transport");
+    }
     async listPartyHostingLimitsAsync(_request, _options) {
         this.throwIfDisposed();
         throw new NotSupportedError("TopologyManagerReadService.ListPartyHostingLimits is not supported by json transport");
@@ -345,6 +390,14 @@ export class JsonTransport {
     }
     async getActiveContractsPageAsync(request, options) {
         this.throwIfDisposed();
+        if (request.interfaceId !== undefined
+            || request.includeInterfaceView !== undefined
+            || request.includeCreatedEventBlob === true
+            || request.activeAtOffset !== undefined
+            || request.maxPageSize !== undefined
+            || request.pageToken !== undefined) {
+            throw new NotSupportedError("StateService.GetActiveContractsPage interface filters, event blobs, and page tokens are not supported by json transport");
+        }
         const payload = await this.httpClient.postAsync("/v1/query", {
             templateIds: request.templateId ? [request.templateId] : [],
         }, options);

package/dist/transports/json/mappers/parties-mapper.d.ts

@@ -1,11 +1,22 @@
 import { CreatePartyResponse } from "../../../core/types/responses/create-party-response.js";
+import { AllocatePartyRequest } from "../../../core/types/requests/allocate-party-request.js";
 import { ListPartiesResponse } from "../../../core/types/responses/list-parties-response.js";
 export declare function mapJsonCreateParty(payload: {
     result?: {
-        identifier?: string;
+        partyDetails?: {
+            party?: string;
+        };
+    };
+    partyDetails?: {
+        party?: string;
     };
-    identifier?: string;
 }): CreatePartyResponse;
+export declare function mapJsonAllocatePartyRequest(request: AllocatePartyRequest): {
+    partyIdHint?: string;
+    localMetadata?: {
+        attributes: Record<string, string>;
+    };
+};
 export declare function mapJsonListParties(payload: {
     partyDetails?: Array<{
         party?: string;