@distrohelena/canton-typescript-sdk 0.1.29 → 0.1.30

package/dist/cjs/client/canton-client-options.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CantonClientOptions = void 0;
+const grpc_channel_security_js_1 = require("../core/types/grpc-channel-security.js");
+class CantonClientOptions {
+    transportKind;
+    ledgerEndpoint;
+    ledgerAdminEndpoint;
+    participantAdminEndpoint;
+    grpcChannelSecurity;
+    grpcTlsRootCertificates;
+    ledgerGrpcChannelSecurity;
+    ledgerAdminGrpcChannelSecurity;
+    participantAdminGrpcChannelSecurity;
+    defaultRequestTimeoutMs;
+    grpcConnectTimeoutMs;
+    ledgerAuthProvider;
+    ledgerAdminAuthProvider;
+    participantAdminAuthProvider;
+    commandSigner;
+    onGrpcError;
+    constructor(init) {
+        this.transportKind = init.transportKind;
+        this.ledgerEndpoint = init.ledgerEndpoint;
+        this.ledgerAdminEndpoint = init.ledgerAdminEndpoint;
+        this.participantAdminEndpoint = init.participantAdminEndpoint;
+        this.grpcChannelSecurity =
+            init.grpcChannelSecurity ?? grpc_channel_security_js_1.GrpcChannelSecurity.tls;
+        this.grpcTlsRootCertificates = init.grpcTlsRootCertificates;
+        this.ledgerGrpcChannelSecurity = init.ledgerGrpcChannelSecurity;
+        this.ledgerAdminGrpcChannelSecurity =
+            init.ledgerAdminGrpcChannelSecurity;
+        this.participantAdminGrpcChannelSecurity =
+            init.participantAdminGrpcChannelSecurity;
+        this.defaultRequestTimeoutMs = init.defaultRequestTimeoutMs;
+        this.grpcConnectTimeoutMs = init.grpcConnectTimeoutMs;
+        this.ledgerAuthProvider = init.ledgerAuthProvider;
+        this.ledgerAdminAuthProvider = init.ledgerAdminAuthProvider;
+        this.participantAdminAuthProvider =
+            init.participantAdminAuthProvider;
+        this.commandSigner = init.commandSigner;
+        this.onGrpcError = init.onGrpcError;
+    }
+}
+exports.CantonClientOptions = CantonClientOptions;

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CantonClient = void 0;
+const not_supported_error_js_1 = require("../core/errors/not-supported-error.js");
+const transport_kind_js_1 = require("../core/types/transport-kind.js");
+const canton_hashing_client_js_1 = require("./canton-hashing-client.js");
+const service_registry_js_1 = require("./service-registry.js");
+class CantonClient {
+    options;
+    transport;
+    disposed = false;
+    versionService;
+    healthService;
+    partyManagementService;
+    userManagementService;
+    commandInspectionService;
+    identityProviderConfigService;
+    packageService;
+    packageManagementService;
+    participantPackageService;
+    participantInspectionService;
+    participantPartyManagementService;
+    participantRepairService;
+    participantStatusService;
+    pruningService;
+    resourceManagementService;
+    identityInitializationService;
+    synchronizerConnectivityService;
+    topologyManagerReadService;
+    topologyManagerWriteService;
+    trafficControlService;
+    topologyAggregationService;
+    commandService;
+    commandSubmissionService;
+    commandCompletionService;
+    stateService;
+    updateService;
+    eventQueryService;
+    contractService;
+    hashing;
+    constructor(options) {
+        this.options = options;
+        if (options.transportKind === transport_kind_js_1.TransportKind.json &&
+            options.commandSigner) {
+            throw new not_supported_error_js_1.NotSupportedError("commandSigner is only supported with grpc transport");
+        }
+        const services = (0, service_registry_js_1.createServiceRegistry)(options);
+        this.transport = services.transport;
+        this.versionService = services.versionService;
+        this.healthService = services.healthService;
+        this.partyManagementService = services.partyManagementService;
+        this.userManagementService = services.userManagementService;
+        this.commandInspectionService = services.commandInspectionService;
+        this.identityProviderConfigService = services.identityProviderConfigService;
+        this.packageService = services.packageService;
+        this.packageManagementService = services.packageManagementService;
+        this.participantPackageService = services.participantPackageService;
+        this.participantInspectionService = services.participantInspectionService;
+        this.participantPartyManagementService =
+            services.participantPartyManagementService;
+        this.participantRepairService = services.participantRepairService;
+        this.participantStatusService = services.participantStatusService;
+        this.pruningService = services.pruningService;
+        this.resourceManagementService = services.resourceManagementService;
+        this.identityInitializationService =
+            services.identityInitializationService;
+        this.synchronizerConnectivityService =
+            services.synchronizerConnectivityService;
+        this.topologyManagerReadService = services.topologyManagerReadService;
+        this.topologyManagerWriteService = services.topologyManagerWriteService;
+        this.trafficControlService = services.trafficControlService;
+        this.topologyAggregationService = services.topologyAggregationService;
+        this.commandService = services.commandService;
+        this.commandSubmissionService = services.commandSubmissionService;
+        this.commandCompletionService = services.commandCompletionService;
+        this.stateService = services.stateService;
+        this.updateService = services.updateService;
+        this.eventQueryService = services.eventQueryService;
+        this.contractService = services.contractService;
+        this.hashing = new canton_hashing_client_js_1.CantonHashingClient();
+    }
+    /** Disposes transport-owned resources for this client instance. */
+    async disposeAsync() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        await this.transport.disposeAsync();
+    }
+}
+exports.CantonClient = CantonClient;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CantonHashingClient = void 0;
+const canton_hash_js_1 = require("../core/hashing/canton-hash.js");
+class CantonHashingClient {
+    /** Computes a Canton multihash for the provided content and hash purpose. */
+    computeHash(content, purpose) {
+        return (0, canton_hash_js_1.computeCantonHash)(content, purpose);
+    }
+    /** Computes a Canton multihash as lowercase hexadecimal for the provided content and hash purpose. */
+    computeHashHex(content, purpose) {
+        return (0, canton_hash_js_1.computeCantonHashHex)(content, purpose);
+    }
+    /** Computes the canonical Canton public-key fingerprint from serialized public key bytes. */
+    computePublicKeyFingerprint(publicKey, format) {
+        return (0, canton_hash_js_1.computeCantonPublicKeyFingerprint)(publicKey, format) ?? "";
+    }
+}
+exports.CantonHashingClient = CantonHashingClient;

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalPartyActivationClient = void 0;
+const topology_store_id_js_1 = require("../core/types/topology/topology-store-id.js");
+const topology_js_1 = require("../transports/grpc/generated/canton/com/digitalasset/canton/protocol/v30/topology.js");
+const external_party_activation_response_js_1 = require("./external-party-activation-response.js");
+/** Coordinates multi-host external-party activation across participant-admin topology reads and writes. gRPC only. */
+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 = {
+            type: { oneofKind: "transactionHash", transactionHash },
+            mustFullyAuthorize: false,
+            forceChanges: [],
+            signedBy: [],
+            store: createSynchronizerQuery(request.synchronizerId, false).store,
+        };
+        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({
+                baseQuery: createSynchronizerQuery(request.synchronizerId, false),
+                filterParty: request.partyId,
+                filterParticipant: "",
+            }, options),
+            this.sourceClient.topologyManagerReadService.listPartyToParticipantAsync({
+                baseQuery: createSynchronizerQuery(request.synchronizerId, true),
+                filterParty: request.partyId,
+                filterParticipant: "",
+            }, 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 || active.item === undefined
+                ? undefined
+                : {
+                    context: active.context,
+                    mapping: active.item,
+                },
+            proposal: proposal === undefined || proposal.context === undefined || proposal.item === undefined
+                ? undefined
+                : {
+                    context: proposal.context,
+                    mapping: proposal.item,
+                },
+        };
+    }
+    createActivationResponse(request, context, mapping) {
+        return new external_party_activation_response_js_1.ExternalPartyActivationResponse({
+            partyId: request.partyId,
+            synchronizerId: request.synchronizerId,
+            transactionHash: convertBytesToHex(context.transactionHash),
+            mapping,
+        });
+    }
+}
+exports.ExternalPartyActivationClient = ExternalPartyActivationClient;
+function createSynchronizerStoreId(synchronizerId) {
+    return new topology_store_id_js_1.TopologyStoreId({
+        kind: topology_store_id_js_1.TopologyStoreKind.synchronizer,
+        synchronizer: new topology_store_id_js_1.TopologyStoreSynchronizer({
+            id: synchronizerId,
+        }),
+    });
+}
+function createSynchronizerQuery(synchronizerId, includeProposals) {
+    return {
+        store: {
+            store: {
+                oneofKind: "synchronizer",
+                synchronizer: {
+                    kind: {
+                        oneofKind: "id",
+                        id: synchronizerId,
+                    },
+                },
+            },
+        },
+        proposals: includeProposals,
+        operation: topology_js_1.Enums_TopologyChangeOp.UNSPECIFIED,
+        timeQuery: { oneofKind: "headState", headState: {} },
+        filterSignedKey: "",
+    };
+}
+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/cjs/client/external-party-activation-request.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalPartyActivationRequest = void 0;
+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;
+    }
+}
+exports.ExternalPartyActivationRequest = ExternalPartyActivationRequest;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalPartyActivationResponse = void 0;
+class ExternalPartyActivationResponse {
+    partyId;
+    synchronizerId;
+    transactionHash;
+    mapping;
+    constructor(init) {
+        this.partyId = init.partyId;
+        this.synchronizerId = init.synchronizerId;
+        this.transactionHash = init.transactionHash;
+        this.mapping = init.mapping;
+    }
+}
+exports.ExternalPartyActivationResponse = ExternalPartyActivationResponse;