@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/services/identity-initialization/identity-initialization-service-client.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityInitializationServiceClient = void 0;
+class IdentityInitializationServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads the topology identity initialization id. Supported on gRPC; JSON rejects it. */
+    getIdAsync(request, options) {
+        return this.transport.getIdAsync(request, options);
+    }
+    /** Reads the topology identity initialization current time. Supported on gRPC; JSON rejects it. */
+    currentTimeAsync(request, options) {
+        return this.transport.currentTimeAsync(request, options);
+    }
+}
+exports.IdentityInitializationServiceClient = IdentityInitializationServiceClient;

package/dist/cjs/services/identity-provider-config/identity-provider-config-service-client.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityProviderConfigServiceClient = void 0;
+class IdentityProviderConfigServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads one ledger-admin identity provider config. Supported on gRPC; JSON rejects it. */
+    getIdentityProviderConfigAsync(request, options) {
+        return this.transport.getIdentityProviderConfigAsync(request, options);
+    }
+    /** Lists ledger-admin identity provider configs. Supported on gRPC; JSON rejects it. */
+    listIdentityProviderConfigsAsync(request, options) {
+        return this.transport.listIdentityProviderConfigsAsync(request, options);
+    }
+}
+exports.IdentityProviderConfigServiceClient = IdentityProviderConfigServiceClient;

package/dist/cjs/services/package/package-service-client.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageServiceClient = void 0;
+class PackageServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Lists ledger-visible packages. Shared SDK surface; JSON may reject it. */
+    listPackagesAsync(request, options) {
+        return this.transport.listPackagesAsync(request, options);
+    }
+    /** Reads a ledger package archive. Shared SDK surface; JSON may reject it. */
+    getPackageAsync(request, options) {
+        return this.transport.getPackageAsync(request, options);
+    }
+    /** Reads ledger package registration status. Shared SDK surface; JSON may reject it. */
+    getPackageStatusAsync(request, options) {
+        return this.transport.getPackageStatusAsync(request, options);
+    }
+    /** Lists vetted ledger packages. Shared SDK surface; JSON may reject it. */
+    listVettedPackagesAsync(request, options) {
+        return this.transport.listVettedPackagesAsync(request, options);
+    }
+}
+exports.PackageServiceClient = PackageServiceClient;

package/dist/cjs/services/package-management/package-management-service-client.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManagementServiceClient = void 0;
+class PackageManagementServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Uploads a DAR file. Supported on JSON and gRPC. */
+    uploadDarFileAsync(request, options) {
+        return this.transport.uploadDarFileAsync(request, options);
+    }
+    /** Lists participant-known package metadata. Supported on gRPC; JSON rejects it. */
+    listKnownPackagesAsync(request, options) {
+        return this.transport.listKnownPackagesAsync(request, options);
+    }
+}
+exports.PackageManagementServiceClient = PackageManagementServiceClient;

package/dist/cjs/services/participant-inspection/commitment-chunk-observer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/services/participant-inspection/participant-inspection-service-client.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantInspectionServiceClient = void 0;
+class ParticipantInspectionServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads the participant ledger offset for a timestamp. Supported on gRPC; JSON rejects it. */
+    lookupOffsetByTimeAsync(request, options) {
+        return this.transport.lookupOffsetByTimeAsync(request, options);
+    }
+    /** Reads participant in-flight submission and transaction counts. Supported on gRPC; JSON rejects it. */
+    countInFlightAsync(request, options) {
+        return this.transport.countInFlightAsync(request, options);
+    }
+    /** Reads slow counter-participant monitoring config. Supported on gRPC; JSON rejects it. */
+    getConfigForSlowCounterParticipantsAsync(request, options) {
+        return this.transport.getConfigForSlowCounterParticipantsAsync(request, options);
+    }
+    /** Reads counter-participant lag information. Supported on gRPC; JSON rejects it. */
+    getIntervalsBehindForCounterParticipantsAsync(request, options) {
+        return this.transport.getIntervalsBehindForCounterParticipantsAsync(request, options);
+    }
+    /** Reads commitments sent to counter-participants. Supported on gRPC; JSON rejects it. */
+    lookupSentAcsCommitmentsAsync(request, options) {
+        return this.transport.lookupSentAcsCommitmentsAsync(request, options);
+    }
+    /** Reads commitments received from counter-participants. Supported on gRPC; JSON rejects it. */
+    lookupReceivedAcsCommitmentsAsync(request, options) {
+        return this.transport.lookupReceivedAcsCommitmentsAsync(request, options);
+    }
+    /** Opens a serialized ACS commitment chunk. Supported on gRPC; JSON rejects it. */
+    openCommitmentAsync(request, observer, options) {
+        return this.transport.openCommitmentAsync(request, observer, options);
+    }
+    /** Reads commitment contract payload chunks. Supported on gRPC; JSON rejects it. */
+    inspectCommitmentContractsAsync(request, observer, options) {
+        return this.transport.inspectCommitmentContractsAsync(request, observer, options);
+    }
+}
+exports.ParticipantInspectionServiceClient = ParticipantInspectionServiceClient;

package/dist/cjs/services/participant-package/participant-package-service-client.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantPackageServiceClient = void 0;
+class ParticipantPackageServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Lists participant-local packages. Shared SDK surface; JSON may reject it. */
+    listPackagesAsync(request, options) {
+        return this.transport.listParticipantPackagesAsync(request, options);
+    }
+    /** Reads participant-local package contents. Shared SDK surface; JSON may reject it. */
+    getPackageContentsAsync(request, options) {
+        return this.transport.getParticipantPackageContentsAsync(request, options);
+    }
+    /** Reads participant package references. Shared SDK surface; JSON may reject it. */
+    getPackageReferencesAsync(request, options) {
+        return this.transport.getParticipantPackageReferencesAsync(request, options);
+    }
+    /** Reads a participant-local DAR archive. Supported on gRPC; JSON rejects it. */
+    getDarAsync(request, options) {
+        return this.transport.getParticipantDarAsync(request, options);
+    }
+    /** Lists participant-local DAR archives. Supported on gRPC; JSON rejects it. */
+    listDarsAsync(request, options) {
+        return this.transport.listParticipantDarsAsync(request, options);
+    }
+    /** Reads participant-local DAR contents. Supported on gRPC; JSON rejects it. */
+    getDarContentsAsync(request, options) {
+        return this.transport.getParticipantDarContentsAsync(request, options);
+    }
+}
+exports.ParticipantPackageServiceClient = ParticipantPackageServiceClient;

package/dist/cjs/services/participant-party-management/participant-party-management-service-client.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantPartyManagementServiceClient = void 0;
+class ParticipantPartyManagementServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Starts online party replication on the target participant. Supported on gRPC; JSON rejects it. */
+    addPartyAsync(request, options) {
+        return this.transport.addPartyAsync(request, options);
+    }
+    /** Clears an onboarding flag on the target participant. Supported on gRPC; JSON rejects it. */
+    clearPartyOnboardingFlagAsync(request, options) {
+        return this.transport.clearPartyOnboardingFlagAsync(request, options);
+    }
+    /** Reads the highest participant ledger offset before or at a timestamp. Supported on gRPC; JSON rejects it. */
+    getHighestOffsetByTimestampAsync(request, options) {
+        return this.transport.getHighestOffsetByTimestampAsync(request, options);
+    }
+}
+exports.ParticipantPartyManagementServiceClient = ParticipantPartyManagementServiceClient;

package/dist/cjs/services/participant-repair/participant-repair-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantRepairServiceClient = void 0;
+class ParticipantRepairServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Lists participant repair pending operations. Supported on gRPC; JSON rejects it. */
+    listPendingOperationsAsync(request, options) {
+        return this.transport.listPendingOperationsAsync(request, options);
+    }
+}
+exports.ParticipantRepairServiceClient = ParticipantRepairServiceClient;

package/dist/cjs/services/participant-status/participant-status-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantStatusServiceClient = void 0;
+class ParticipantStatusServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads participant admin status. Supported on gRPC; JSON rejects it. */
+    getParticipantStatusAsync(request, options) {
+        return this.transport.getParticipantStatusAsync(request, options);
+    }
+}
+exports.ParticipantStatusServiceClient = ParticipantStatusServiceClient;

package/dist/cjs/services/party-management/decentralized-party-lifecycle.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareDecentralizedPartyAsync = prepareDecentralizedPartyAsync;
+const canton_hash_js_1 = require("../../core/hashing/canton-hash.js");
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+const canton_hash_purpose_js_1 = require("../../core/types/canton-hash-purpose.js");
+const finalize_decentralized_party_request_js_1 = require("../../core/types/requests/finalize-decentralized-party-request.js");
+const prepared_topology_transaction_js_1 = require("../../core/types/topology/prepared-topology-transaction.js");
+const crypto_js_1 = require("../../transports/grpc/generated/canton/com/digitalasset/canton/crypto/v30/crypto.js");
+const topology_js_1 = require("../../transports/grpc/generated/canton/com/digitalasset/canton/protocol/v30/topology.js");
+const topology_manager_write_service_js_1 = require("../../transports/grpc/generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_write_service.js");
+async function prepareDecentralizedPartyAsync(request, localParticipant, topologyWriter, options) {
+    const ownerFingerprints = request.owners.map(fingerprintFor);
+    const decentralizedNamespace = deriveNamespace(ownerFingerprints);
+    const partyId = `${request.partyHint}::${decentralizedNamespace}`;
+    const owners = request.owners.map(toTopologyKey);
+    const partyKeys = request.partySigningKeys.map(toTopologyKey);
+    const participants = [
+        {
+            participantUid: localParticipant.participantId,
+            permission: request.localParticipantObservationOnly
+                ? topology_js_1.Enums_ParticipantPermission.OBSERVATION
+                : topology_js_1.Enums_ParticipantPermission.CONFIRMATION,
+        },
+        ...request.otherConfirmingParticipantUids.map((participantUid) => ({ participantUid, permission: topology_js_1.Enums_ParticipantPermission.CONFIRMATION })),
+        ...request.observingParticipantUids.map((participantUid) => ({ participantUid, permission: topology_js_1.Enums_ParticipantPermission.OBSERVATION })),
+    ];
+    const generated = await topologyWriter.generateTransactionsAsync(topology_manager_write_service_js_1.GenerateTransactionsRequest.create({
+        proposals: [
+            {
+                operation: topology_js_1.Enums_TopologyChangeOp.ADD_REPLACE,
+                serial: 1,
+                mapping: {
+                    mapping: {
+                        oneofKind: "decentralizedNamespaceDefinition",
+                        decentralizedNamespaceDefinition: {
+                            decentralizedNamespace,
+                            threshold: request.ownerThreshold,
+                            owners: ownerFingerprints,
+                        },
+                    },
+                },
+            },
+            ...owners.map((targetKey) => ({
+                operation: topology_js_1.Enums_TopologyChangeOp.ADD_REPLACE,
+                serial: 1,
+                mapping: {
+                    mapping: {
+                        oneofKind: "namespaceDelegation",
+                        namespaceDelegation: {
+                            namespace: decentralizedNamespace,
+                            targetKey,
+                            isRootDelegation: true,
+                            restriction: { oneofKind: undefined },
+                        },
+                    },
+                },
+            })),
+            {
+                operation: topology_js_1.Enums_TopologyChangeOp.ADD_REPLACE,
+                serial: 1,
+                mapping: {
+                    mapping: {
+                        oneofKind: "partyToParticipant",
+                        partyToParticipant: {
+                            party: partyId,
+                            threshold: request.confirmationThreshold,
+                            participants,
+                            partySigningKeys: {
+                                threshold: request.partySigningThreshold,
+                                keys: partyKeys,
+                            },
+                        },
+                    },
+                },
+            },
+        ],
+    }), options);
+    if (generated.generatedTransactions.length !== owners.length + 2) {
+        throw new validation_error_js_1.ValidationError("decentralized party generated transaction count does not match proposals");
+    }
+    const transactions = generated.generatedTransactions.map((transaction) => new prepared_topology_transaction_js_1.PreparedTopologyTransaction({
+        serializedTransaction: transaction.serializedTransaction,
+        transactionHash: transaction.transactionHash,
+    }));
+    const signingRequests = transactions.flatMap((transaction, index) => {
+        const ownerRequests = ownerFingerprints.map((publicKeyFingerprint) => ({
+            id: `${index}:owner:${publicKeyFingerprint}`,
+            transactionHash: transaction.transactionHash,
+            payload: transaction.transactionHash,
+            publicKeyFingerprint,
+            role: "owner",
+        }));
+        return index === transactions.length - 1
+            ? [...ownerRequests, ...request.partySigningKeys.map((key) => ({
+                    id: `${index}:partySigningKey:${fingerprintFor(key)}`,
+                    transactionHash: transaction.transactionHash,
+                    payload: transaction.transactionHash,
+                    publicKeyFingerprint: fingerprintFor(key),
+                    role: "partySigningKey",
+                }))]
+            : ownerRequests;
+    });
+    return new finalize_decentralized_party_request_js_1.PreparedDecentralizedParty({ synchronizer: request.synchronizer, partyId, decentralizedNamespace, ownerThreshold: request.ownerThreshold, partySigningThreshold: request.partySigningThreshold, transactions, signingRequests });
+}
+function fingerprintFor(value) {
+    const fingerprint = (0, canton_hash_js_1.computeCantonPublicKeyFingerprint)(value.publicKey.keyData, value.publicKey.format);
+    if (fingerprint === undefined) {
+        throw new validation_error_js_1.ValidationError("decentralized party key requires public key material");
+    }
+    return fingerprint;
+}
+function deriveNamespace(ownerFingerprints) {
+    const encoder = new TextEncoder();
+    const chunks = [...ownerFingerprints].sort().flatMap((fingerprint) => {
+        const bytes = encoder.encode(fingerprint);
+        const length = new Uint8Array(4);
+        new DataView(length.buffer).setUint32(0, bytes.length);
+        return [...length, ...bytes];
+    });
+    return (0, canton_hash_js_1.computeCantonHashHex)(new Uint8Array(chunks), canton_hash_purpose_js_1.CantonHashPurpose.decentralizedNamespace);
+}
+function toTopologyKey(value) {
+    return {
+        format: mapCryptoKeyFormat(value.publicKey.format),
+        publicKey: new Uint8Array(value.publicKey.keyData),
+        scheme: mapSigningKeyScheme(value.publicKey.keySpec),
+        usage: [
+            crypto_js_1.SigningKeyUsage.NAMESPACE,
+            crypto_js_1.SigningKeyUsage.PROTOCOL,
+            crypto_js_1.SigningKeyUsage.PROOF_OF_OWNERSHIP,
+        ],
+        keySpec: mapSigningKeySpec(value.publicKey.keySpec),
+    };
+}
+function mapCryptoKeyFormat(value) {
+    switch (value) {
+        case "der": return crypto_js_1.CryptoKeyFormat.DER;
+        case "raw": return crypto_js_1.CryptoKeyFormat.RAW;
+        case "derX509SubjectPublicKeyInfo": return crypto_js_1.CryptoKeyFormat.DER_X509_SUBJECT_PUBLIC_KEY_INFO;
+        case "derPkcs8PrivateKeyInfo": return crypto_js_1.CryptoKeyFormat.DER_PKCS8_PRIVATE_KEY_INFO;
+        case "symbolic": return crypto_js_1.CryptoKeyFormat.SYMBOLIC;
+        default: return crypto_js_1.CryptoKeyFormat.UNSPECIFIED;
+    }
+}
+function mapSigningKeySpec(value) {
+    switch (value) {
+        case "ecCurve25519": return crypto_js_1.SigningKeySpec.EC_CURVE25519;
+        case "ecP256": return crypto_js_1.SigningKeySpec.EC_P256;
+        case "ecP384": return crypto_js_1.SigningKeySpec.EC_P384;
+        case "ecSecp256k1": return crypto_js_1.SigningKeySpec.EC_SECP256K1;
+        case "mlDsa65": return crypto_js_1.SigningKeySpec.ML_DSA_65;
+        default: return crypto_js_1.SigningKeySpec.UNSPECIFIED;
+    }
+}
+function mapSigningKeyScheme(keySpec) {
+    switch (keySpec) {
+        case "ecCurve25519": return crypto_js_1.SigningKeyScheme.ED25519;
+        case "ecP256": return crypto_js_1.SigningKeyScheme.EC_DSA_P256;
+        case "ecP384": return crypto_js_1.SigningKeyScheme.EC_DSA_P384;
+        default: return crypto_js_1.SigningKeyScheme.UNSPECIFIED;
+    }
+}

package/dist/cjs/services/party-management/party-management-service-client.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartyManagementServiceClient = void 0;
+const external_party_onboarding_transaction_js_1 = require("../../core/types/external-party/external-party-onboarding-transaction.js");
+const external_party_signature_js_1 = require("../../core/types/external-party/external-party-signature.js");
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+const decentralized_party_lifecycle_js_1 = require("./decentralized-party-lifecycle.js");
+const not_supported_error_js_1 = require("../../core/errors/not-supported-error.js");
+const canton_hash_js_1 = require("../../core/hashing/canton-hash.js");
+const party_management_service_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/admin/party_management_service.js");
+const crypto_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/crypto.js");
+class PartyManagementServiceClient {
+    transport;
+    topologyWriter;
+    constructor(transport, topologyWriter) {
+        this.transport = transport;
+        this.topologyWriter = topologyWriter;
+        void this.transport;
+    }
+    /** Prepares canonical decentralized-party topology for caller-owned signing. Supported on gRPC with participant-admin configuration. */
+    async prepareDecentralizedPartyAsync(request, options) {
+        if (this.topologyWriter === undefined) {
+            throw new not_supported_error_js_1.NotSupportedError("decentralized party preparation requires a topology manager write service");
+        }
+        const participant = await this.getParticipantIdAsync(party_management_service_js_1.GetParticipantIdRequest.create(), options);
+        return (0, decentralized_party_lifecycle_js_1.prepareDecentralizedPartyAsync)(request, participant, this.topologyWriter, options);
+    }
+    /** Validates detached decentralized-party signatures before allocation. */
+    async finalizeDecentralizedPartyAsync(prepared, signatures, _options) {
+        if (prepared.signingRequests.length === 0) {
+            throw new validation_error_js_1.ValidationError("decentralized party finalization is missing prepared signing requests");
+        }
+        const expected = new Map(prepared.signingRequests.map((request) => [request.id, request]));
+        const seen = new Set();
+        const signaturesByHash = new Map();
+        for (const detached of signatures) {
+            const signingRequest = expected.get(detached.signingRequestId);
+            if (signingRequest === undefined || seen.has(detached.signingRequestId)) {
+                throw new validation_error_js_1.ValidationError("decentralized party finalization has unexpected or duplicate signatures");
+            }
+            else if (detached.result.signature.length === 0) {
+                throw new validation_error_js_1.ValidationError("decentralized party finalization has malformed signatures");
+            }
+            seen.add(detached.signingRequestId);
+            const key = toHex(signingRequest.transactionHash);
+            const transactionSignatures = signaturesByHash.get(key) ?? [];
+            transactionSignatures.push(new external_party_signature_js_1.ExternalPartySignature({
+                format: detached.result.format,
+                signature: detached.result.signature,
+                signedByFingerprint: signingRequest.publicKeyFingerprint,
+                signingAlgorithmSpec: detached.result.signingAlgorithmSpec,
+            }));
+            signaturesByHash.set(key, transactionSignatures);
+        }
+        for (const [index, transaction] of prepared.transactions.entries()) {
+            const requests = prepared.signingRequests.filter((request) => toHex(request.transactionHash) === toHex(transaction.transactionHash));
+            const ownerRequired = index === 0
+                ? requests.filter((request) => request.role === "owner").length
+                : prepared.ownerThreshold;
+            const ownerProvided = requests.filter((request) => request.role === "owner" && seen.has(request.id)).length;
+            const partyRequests = requests.filter((request) => request.role === "partySigningKey");
+            const partyProvided = partyRequests.filter((request) => seen.has(request.id)).length;
+            if (ownerProvided < ownerRequired || partyProvided < partyRequests.length) {
+                throw new validation_error_js_1.ValidationError("decentralized party finalization has missing signatures");
+            }
+        }
+        return this.allocateExternalPartyAsync(party_management_service_js_1.AllocateExternalPartyRequest.create({
+            synchronizer: prepared.synchronizer,
+            onboardingTransactions: prepared.transactions.map((transaction) => ({
+                transaction: transaction.serializedTransaction,
+                signatures: (signaturesByHash.get(toHex(transaction.transactionHash)) ?? []).map(toGeneratedSignature),
+            })),
+            multiHashSignatures: [],
+        }), _options);
+    }
+    /** Creates a decentralized party using the per-key callbacks in the request. */
+    async createDecentralizedPartyAsync(request, options) {
+        const prepared = await this.prepareDecentralizedPartyAsync(request, options);
+        const keys = [...request.owners, ...request.partySigningKeys];
+        const signatures = [];
+        for (const signingRequest of prepared.signingRequests) {
+            const key = keys.find((candidate) => computeFingerprint(candidate) === signingRequest.publicKeyFingerprint);
+            if (key?.sign === undefined) {
+                throw new validation_error_js_1.ValidationError("decentralized party creation requires a signer for every key");
+            }
+            signatures.push({
+                signingRequestId: signingRequest.id,
+                result: await key.sign({
+                    payload: new Uint8Array(signingRequest.payload),
+                    kind: "topology-transaction",
+                    partyId: prepared.partyId,
+                    publicKeyFingerprint: signingRequest.publicKeyFingerprint,
+                    role: signingRequest.role,
+                    transactionHash: new Uint8Array(signingRequest.transactionHash),
+                }),
+            });
+        }
+        return this.finalizeDecentralizedPartyAsync(prepared, signatures, options);
+    }
+    /** Lists known parties. Supported on JSON and gRPC. */
+    listKnownPartiesAsync(request, options) {
+        return this.transport.listKnownPartiesAsync(request, options);
+    }
+    /** Reads the host participant identifier. Supported on gRPC; JSON rejects it. */
+    getParticipantIdAsync(request, options) {
+        return this.transport.getParticipantIdAsync(request, options);
+    }
+    /** Reads party details for specific parties. Supported on gRPC; JSON rejects it. */
+    getPartiesAsync(request, options) {
+        return this.transport.getPartiesAsync(request, options);
+    }
+    /** Allocates a party. Supported on JSON and gRPC. */
+    allocatePartyAsync(request, options) {
+        return this.transport.allocatePartyAsync(request, options);
+    }
+    /** Generates external-party topology through the ledger-admin API. Supported on gRPC; JSON rejects it. */
+    generateExternalPartyTopologyAsync(request, options) {
+        return this.transport.generateExternalPartyTopologyAsync(request, options);
+    }
+    /** Allocates an external party through the ledger-admin API. Supported on gRPC; JSON rejects it. */
+    allocateExternalPartyAsync(request, options) {
+        return this.transport.allocateExternalPartyAsync(request, options);
+    }
+    /** Creates an externally controlled party using caller-provided signing. Supported on gRPC. */
+    async createExternalPartyAsync(request, options) {
+        const generated = await this.generateExternalPartyTopologyAsync(party_management_service_js_1.GenerateExternalPartyTopologyRequest.create({
+            synchronizer: request.synchronizer,
+            partyHint: request.partyHint,
+            publicKey: toGeneratedPublicKey(request.publicKey),
+            localParticipantObservationOnly: request.localParticipantObservationOnly,
+            otherConfirmingParticipantUids: [...request.otherConfirmingParticipantUids],
+            confirmationThreshold: request.confirmationThreshold,
+            observingParticipantUids: [...request.observingParticipantUids],
+        }), options);
+        const onboardingTransactions = [];
+        for (const transaction of generated.topologyTransactions) {
+            onboardingTransactions.push(new external_party_onboarding_transaction_js_1.ExternalPartyOnboardingTransaction({
+                transaction,
+                signatures: [
+                    await this.signExternalPartyPayloadAsync(request, transaction, "topology-transaction", generated.partyId, generated.publicKeyFingerprint),
+                ],
+            }));
+        }
+        const multiHashSignature = await this.signExternalPartyPayloadAsync(request, generated.multiHash, "multi-hash", generated.partyId, generated.publicKeyFingerprint);
+        return this.allocateExternalPartyAsync(party_management_service_js_1.AllocateExternalPartyRequest.create({
+            synchronizer: request.synchronizer,
+            onboardingTransactions: onboardingTransactions.map((transaction) => ({
+                transaction: transaction.transaction,
+                signatures: transaction.signatures.map(toGeneratedSignature),
+            })),
+            multiHashSignatures: [toGeneratedSignature(multiHashSignature)],
+            identityProviderId: request.identityProviderId,
+            waitForAllocation: request.waitForAllocation,
+            userId: request.userId,
+        }), options);
+    }
+    async signExternalPartyPayloadAsync(request, payload, kind, partyId, publicKeyFingerprint) {
+        const result = await request.sign({
+            payload: new Uint8Array(payload),
+            kind,
+            partyId,
+            publicKeyFingerprint,
+        });
+        return new external_party_signature_js_1.ExternalPartySignature({
+            format: result.format,
+            signature: result.signature,
+            signedByFingerprint: publicKeyFingerprint,
+            signingAlgorithmSpec: result.signingAlgorithmSpec,
+        });
+    }
+}
+exports.PartyManagementServiceClient = PartyManagementServiceClient;
+function toGeneratedPublicKey(value) {
+    if (value === undefined)
+        return undefined;
+    return {
+        format: mapCryptoKeyFormat(value.format),
+        keyData: new Uint8Array(value.keyData),
+        keySpec: mapSigningKeySpec(value.keySpec),
+    };
+}
+function toGeneratedSignature(value) {
+    return {
+        format: mapSignatureFormat(value.format),
+        signature: new Uint8Array(value.signature),
+        signedBy: value.signedByFingerprint,
+        signingAlgorithmSpec: mapSigningAlgorithm(value.signingAlgorithmSpec),
+    };
+}
+function mapCryptoKeyFormat(value) { return value === "der" ? crypto_js_1.CryptoKeyFormat.DER : value === "raw" ? crypto_js_1.CryptoKeyFormat.RAW : value === "derX509SubjectPublicKeyInfo" ? crypto_js_1.CryptoKeyFormat.DER_X509_SUBJECT_PUBLIC_KEY_INFO : crypto_js_1.CryptoKeyFormat.UNSPECIFIED; }
+function mapSigningKeySpec(value) { return value === "ecCurve25519" ? crypto_js_1.SigningKeySpec.EC_CURVE25519 : value === "ecP256" ? crypto_js_1.SigningKeySpec.EC_P256 : value === "ecP384" ? crypto_js_1.SigningKeySpec.EC_P384 : value === "ecSecp256k1" ? crypto_js_1.SigningKeySpec.EC_SECP256K1 : value === "mlDsa65" ? crypto_js_1.SigningKeySpec.ML_DSA_65 : crypto_js_1.SigningKeySpec.UNSPECIFIED; }
+function mapSignatureFormat(value) { return value === "raw" ? crypto_js_1.SignatureFormat.RAW : value === "der" ? crypto_js_1.SignatureFormat.DER : value === "concat" ? crypto_js_1.SignatureFormat.CONCAT : value === "symbolic" ? crypto_js_1.SignatureFormat.SYMBOLIC : crypto_js_1.SignatureFormat.UNSPECIFIED; }
+function mapSigningAlgorithm(value) { return value === "ed25519" ? crypto_js_1.SigningAlgorithmSpec.ED25519 : value === "ecDsaSha256" ? crypto_js_1.SigningAlgorithmSpec.EC_DSA_SHA_256 : value === "ecDsaSha384" ? crypto_js_1.SigningAlgorithmSpec.EC_DSA_SHA_384 : value === "mlDsa65" ? crypto_js_1.SigningAlgorithmSpec.ML_DSA_65 : crypto_js_1.SigningAlgorithmSpec.UNSPECIFIED; }
+function toHex(bytes) {
+    return [...bytes].map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+function computeFingerprint(key) {
+    return (0, canton_hash_js_1.computeCantonPublicKeyFingerprint)(key.publicKey.keyData, key.publicKey.format);
+}

package/dist/cjs/services/pruning/pruning-service-client.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PruningServiceClient = void 0;
+class PruningServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads the safe participant pruning offset. Supported on gRPC; JSON rejects it. */
+    getSafePruningOffsetAsync(request, options) {
+        return this.transport.getSafePruningOffsetAsync(request, options);
+    }
+    /** Reads the automatic pruning schedule. Supported on gRPC; JSON rejects it. */
+    getScheduleAsync(request, options) {
+        return this.transport.getPruningScheduleAsync(request, options);
+    }
+    /** Reads the participant-specific automatic pruning schedule. Supported on gRPC; JSON rejects it. */
+    getParticipantScheduleAsync(request, options) {
+        return this.transport.getParticipantPruningScheduleAsync(request, options);
+    }
+    /** Reads no-wait commitments configuration. Supported on gRPC; JSON rejects it. */
+    getNoWaitCommitmentsFromAsync(request, options) {
+        return this.transport.getNoWaitCommitmentsFromAsync(request, options);
+    }
+}
+exports.PruningServiceClient = PruningServiceClient;

package/dist/cjs/services/resource-management/resource-management-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceManagementServiceClient = void 0;
+class ResourceManagementServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads participant-admin resource limits. Supported on gRPC; JSON rejects it. */
+    getResourceLimitsAsync(request, options) {
+        return this.transport.getResourceLimitsAsync(request, options);
+    }
+}
+exports.ResourceManagementServiceClient = ResourceManagementServiceClient;