@distrohelena/canton-typescript-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,232 @@
+# Canton TypeScript SDK
+
+TypeScript SDK for Canton with:
+
+- a shared `CantonClient`
+- `grpc` and `json` transports
+- `grpc`-only external signing
+- gRPC Ledger API service boundaries as the public SDK shape
+
+## Install
+
+```bash
+npm install @distrohelena/canton-typescript-sdk
+```
+
+## Shared Client
+
+```ts
+import {
+    AllocatePartyRequest,
+    BearerTokenAuthProvider,
+    CantonClient,
+    CantonClientOptions,
+    GetActiveContractsPageRequest,
+    HealthCheckRequest,
+    GetLedgerApiVersionRequest,
+    TransportKind,
+} from "@distrohelena/canton-typescript-sdk";
+
+const client = new CantonClient(
+    new CantonClientOptions({
+        transportKind: TransportKind.json,
+        ledgerEndpoint: "https://ledger.example.com",
+        ledgerAdminEndpoint: "https://ledger-admin.example.com",
+        participantAdminEndpoint: "https://participant-admin.example.com",
+        ledgerAuthProvider: new BearerTokenAuthProvider("ledger-token"),
+        ledgerAdminAuthProvider: new BearerTokenAuthProvider(
+            "ledger-admin-token",
+        ),
+        participantAdminAuthProvider: new BearerTokenAuthProvider(
+            "participant-admin-token",
+        ),
+    }),
+);
+
+const version = await client.versionService.getLedgerApiVersionAsync(
+    new GetLedgerApiVersionRequest(),
+);
+const health = await client.healthService.checkAsync(
+    new HealthCheckRequest({
+        service: "grpc.health.v1.Health",
+    }),
+);
+const party = await client.partyManagementService.allocatePartyAsync(
+    new AllocatePartyRequest({
+        partyIdHint: "Alice",
+        displayName: "Alice",
+    }),
+);
+const contracts = await client.stateService.getActiveContractsPageAsync(
+    new GetActiveContractsPageRequest({
+        party: "Alice",
+        templateId: "Main:Iou",
+    }),
+);
+```
+
+`CantonClient` now splits its public surface across the real API boundaries:
+
+- ledger services use `ledgerEndpoint`
+- ledger admin services use `ledgerAdminEndpoint`
+- participant admin services use `participantAdminEndpoint`
+
+For gRPC, channel security resolves per surface:
+
+- ledger services use `ledgerGrpcChannelSecurity ?? grpcChannelSecurity ?? GrpcChannelSecurity.tls`
+- ledger admin services use `ledgerAdminGrpcChannelSecurity ?? grpcChannelSecurity ?? GrpcChannelSecurity.tls`
+- participant admin services use `participantAdminGrpcChannelSecurity ?? grpcChannelSecurity ?? GrpcChannelSecurity.tls`
+
+## Service Map
+
+- Ledger endpoint:
+- `versionService.getLedgerApiVersionAsync(...)`: `json`, `grpc`
+- `healthService.checkAsync(...)`: `grpc` only
+- `packageService.listPackagesAsync(...)`: `grpc` only
+- `packageService.getPackageAsync(...)`: `grpc` only
+- `packageService.getPackageStatusAsync(...)`: `grpc` only
+- `packageService.listVettedPackagesAsync(...)`: `grpc` only
+- `commandService.submitAndWaitAsync(...)`: `json`, `grpc`
+- `commandSubmissionService.submitAsync(...)`: reserved, currently unsupported
+- `stateService.getActiveContractsPageAsync(...)`: `json`, `grpc`
+- `stateService.getActiveContractsAsync(...)`: `json` only
+- `updateService.getUpdatesAsync(...)`: `grpc` only
+- `commandCompletionService`: placeholder, no methods yet
+- `eventQueryService`: placeholder, no methods yet
+- `contractService`: placeholder, no methods yet
+
+- Ledger Admin endpoint:
+- `partyManagementService.allocatePartyAsync(...)`: `json`, `grpc`
+- `partyManagementService.listKnownPartiesAsync(...)`: `json`, `grpc`
+- `userManagementService.grantUserRightsAsync(...)`: `json`, `grpc`
+- `packageManagementService.uploadDarFileAsync(...)`: `json`, `grpc`
+
+- Participant Admin endpoint:
+- `participantPackageService.listPackagesAsync(...)`: `grpc` only
+- `participantPackageService.getPackageContentsAsync(...)`: `grpc` only
+- `participantPackageService.getPackageReferencesAsync(...)`: `grpc` only
+- `participantStatusService.getParticipantStatusAsync(...)`: `grpc` only
+
+## Protocol-Specific Clients
+
+Subpath exports are available when you want to construct directly over a transport adapter:
+
+- `@distrohelena/canton-typescript-sdk/grpc`
+- `@distrohelena/canton-typescript-sdk/json`
+- `@distrohelena/canton-typescript-sdk/daml-lf`
+- `@distrohelena/canton-typescript-sdk/daml-interface`
+
+`GrpcLedgerClient` and `JsonLedgerClient` expose the same service properties as `CantonClient`.
+
+JSON does not provide a `grpc.health.v1.Health.Check` equivalent. The shared SDK still exposes `healthService`, but JSON rejects calls with `NotSupportedError`.
+JSON also does not provide a participant-admin status equivalent, so `participantStatusService` is currently `grpc` only.
+
+## DAML-LF Parser
+
+The package also exposes a separate DAML-LF front-end at `@distrohelena/canton-typescript-sdk/daml-lf`.
+
+Current scope:
+
+- artifact-centric `DAR` and `DALF` loading
+- LF `2.x` decoding
+- immutable package/module/definition model
+- workspace, compilation, and symbol resolution
+- semantic queries over the compiled model
+- interpreter scaffold contracts only, no real LF execution yet
+
+Example:
+
+```ts
+import {
+    DarArchiveLoader,
+    DamlLfCompilation,
+    DamlLfPackageLoader,
+    DamlLfWorkspace,
+} from "@distrohelena/canton-typescript-sdk/daml-lf";
+
+const archive = await new DarArchiveLoader().loadDarOrThrowAsync(darBytes);
+const packageLoader = new DamlLfPackageLoader();
+const packageModel = packageLoader.loadPackageOrThrow(
+    archive.mainPackageEntry.bytes,
+);
+const workspace = new DamlLfWorkspace([packageModel]);
+const compilation = DamlLfCompilation.createOrThrow(workspace);
+const semanticModel = compilation.createSemanticModel();
+```
+
+## DAML Interface Generator
+
+The `@distrohelena/canton-typescript-sdk/daml-interface` subpath exposes a generator that turns compiled `DAR` or `DALF` artifacts into an in-memory TypeScript binding project.
+
+Current generated output shape:
+
+- one file per template
+- shared support files
+- a registry file
+- an index file
+
+Example:
+
+```ts
+import { DamlInterfaceGenerator } from "@distrohelena/canton-typescript-sdk/daml-interface";
+
+const project = await new DamlInterfaceGenerator().generateFromDalfOrThrowAsync(
+    dalfBytes,
+);
+
+console.log(project.templateFiles[0].path);
+console.log(project.registryFile?.path);
+console.log(project.indexFile?.path);
+```
+
+You can also write the generated project to disk:
+
+```ts
+import {
+    DamlInterfaceGenerator,
+    DamlInterfaceWriter,
+} from "@distrohelena/canton-typescript-sdk/daml-interface";
+
+const generator = new DamlInterfaceGenerator();
+const writer = new DamlInterfaceWriter();
+const project = await generator.generateFromDarOrThrowAsync(darBytes);
+
+await writer.writeProjectAsync(project, "./artifacts");
+```
+
+CLI:
+
+```bash
+npm run generate:daml-interface -- --input ./sample.dalf --output ./artifacts
+```
+
+Current limits:
+
+- generation is strict and throws when a template shape is not supported yet
+- milestone 1 supports the current `daml-lf` text-based analyzer surface only
+- the generator works from compiled artifacts, not `.daml` source files
+
+## External Signing
+
+External signing is supported on `grpc` only through `ICommandSigner`.
+
+```ts
+import {
+    ICommandSigner,
+    SignCommandRequest,
+    SignCommandResult,
+} from "@distrohelena/canton-typescript-sdk";
+
+class ExampleSigner implements ICommandSigner {
+    public async signAsync(
+        request: SignCommandRequest,
+    ): Promise<SignCommandResult> {
+        return new SignCommandResult({
+            algorithm: "ed25519",
+            signature: request.payload,
+        });
+    }
+}
+```
+
+See [DOCUMENTATION.md](./DOCUMENTATION.md) for the full function-by-function reference.

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

@@ -0,0 +1,36 @@
+import { TransportKind } from "../core/types/transport-kind.js";
+import { GrpcChannelSecurity } from "../core/types/grpc-channel-security.js";
+import { IAuthProvider } from "../core/auth/auth-provider.interface.js";
+import { ICommandSigner } from "../core/signing/command-signer.interface.js";
+export declare class CantonClientOptions {
+    readonly transportKind: TransportKind;
+    readonly ledgerEndpoint?: string;
+    readonly ledgerAdminEndpoint?: string;
+    readonly participantAdminEndpoint?: string;
+    readonly grpcChannelSecurity: GrpcChannelSecurity;
+    readonly ledgerGrpcChannelSecurity?: GrpcChannelSecurity;
+    readonly ledgerAdminGrpcChannelSecurity?: GrpcChannelSecurity;
+    readonly participantAdminGrpcChannelSecurity?: GrpcChannelSecurity;
+    readonly defaultRequestTimeoutMs?: number;
+    readonly grpcConnectTimeoutMs?: number;
+    readonly ledgerAuthProvider?: IAuthProvider;
+    readonly ledgerAdminAuthProvider?: IAuthProvider;
+    readonly participantAdminAuthProvider?: IAuthProvider;
+    readonly commandSigner?: ICommandSigner;
+    constructor(init: {
+        transportKind: TransportKind;
+        ledgerEndpoint?: string;
+        ledgerAdminEndpoint?: string;
+        participantAdminEndpoint?: string;
+        grpcChannelSecurity?: GrpcChannelSecurity;
+        ledgerGrpcChannelSecurity?: GrpcChannelSecurity;
+        ledgerAdminGrpcChannelSecurity?: GrpcChannelSecurity;
+        participantAdminGrpcChannelSecurity?: GrpcChannelSecurity;
+        defaultRequestTimeoutMs?: number;
+        grpcConnectTimeoutMs?: number;
+        ledgerAuthProvider?: IAuthProvider;
+        ledgerAdminAuthProvider?: IAuthProvider;
+        participantAdminAuthProvider?: IAuthProvider;
+        commandSigner?: ICommandSigner;
+    });
+}

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

@@ -0,0 +1,37 @@
+import { GrpcChannelSecurity } from "../core/types/grpc-channel-security.js";
+export class CantonClientOptions {
+    transportKind;
+    ledgerEndpoint;
+    ledgerAdminEndpoint;
+    participantAdminEndpoint;
+    grpcChannelSecurity;
+    ledgerGrpcChannelSecurity;
+    ledgerAdminGrpcChannelSecurity;
+    participantAdminGrpcChannelSecurity;
+    defaultRequestTimeoutMs;
+    grpcConnectTimeoutMs;
+    ledgerAuthProvider;
+    ledgerAdminAuthProvider;
+    participantAdminAuthProvider;
+    commandSigner;
+    constructor(init) {
+        this.transportKind = init.transportKind;
+        this.ledgerEndpoint = init.ledgerEndpoint;
+        this.ledgerAdminEndpoint = init.ledgerAdminEndpoint;
+        this.participantAdminEndpoint = init.participantAdminEndpoint;
+        this.grpcChannelSecurity =
+            init.grpcChannelSecurity ?? GrpcChannelSecurity.tls;
+        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;
+    }
+}

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

@@ -0,0 +1,63 @@
+import { CommandCompletionServiceClient } from "../services/command-completion/command-completion-service-client.js";
+import { CommandInspectionServiceClient } from "../services/command-inspection/command-inspection-service-client.js";
+import { CommandServiceClient } from "../services/command/command-service-client.js";
+import { CommandSubmissionServiceClient } from "../services/command-submission/command-submission-service-client.js";
+import { ContractServiceClient } from "../services/contract/contract-service-client.js";
+import { EventQueryServiceClient } from "../services/event-query/event-query-service-client.js";
+import { HealthServiceClient } from "../services/health/health-service-client.js";
+import { IdentityInitializationServiceClient } from "../services/identity-initialization/identity-initialization-service-client.js";
+import { IdentityProviderConfigServiceClient } from "../services/identity-provider-config/identity-provider-config-service-client.js";
+import { PackageManagementServiceClient } from "../services/package-management/package-management-service-client.js";
+import { PackageServiceClient } from "../services/package/package-service-client.js";
+import { ParticipantInspectionServiceClient } from "../services/participant-inspection/participant-inspection-service-client.js";
+import { ParticipantPartyManagementServiceClient } from "../services/participant-party-management/participant-party-management-service-client.js";
+import { ParticipantPackageServiceClient } from "../services/participant-package/participant-package-service-client.js";
+import { ParticipantRepairServiceClient } from "../services/participant-repair/participant-repair-service-client.js";
+import { ParticipantStatusServiceClient } from "../services/participant-status/participant-status-service-client.js";
+import { PartyManagementServiceClient } from "../services/party-management/party-management-service-client.js";
+import { PruningServiceClient } from "../services/pruning/pruning-service-client.js";
+import { ResourceManagementServiceClient } from "../services/resource-management/resource-management-service-client.js";
+import { StateServiceClient } from "../services/state/state-service-client.js";
+import { TopologyAggregationServiceClient } from "../services/topology-aggregation/topology-aggregation-service-client.js";
+import { TopologyManagerReadServiceClient } from "../services/topology-manager-read/topology-manager-read-service-client.js";
+import { TrafficControlServiceClient } from "../services/traffic-control/traffic-control-service-client.js";
+import { UpdateServiceClient } from "../services/update/update-service-client.js";
+import { UserManagementServiceClient } from "../services/user-management/user-management-service-client.js";
+import { VersionServiceClient } from "../services/version/version-service-client.js";
+import { SynchronizerConnectivityServiceClient } from "../services/synchronizer-connectivity/synchronizer-connectivity-service-client.js";
+import { CantonClientOptions } from "./canton-client-options.js";
+export declare class CantonClient {
+    private readonly options;
+    private readonly transport;
+    private disposed;
+    readonly versionService: VersionServiceClient;
+    readonly healthService: HealthServiceClient;
+    readonly partyManagementService: PartyManagementServiceClient;
+    readonly userManagementService: UserManagementServiceClient;
+    readonly commandInspectionService: CommandInspectionServiceClient;
+    readonly identityProviderConfigService: IdentityProviderConfigServiceClient;
+    readonly packageService: PackageServiceClient;
+    readonly packageManagementService: PackageManagementServiceClient;
+    readonly participantPackageService: ParticipantPackageServiceClient;
+    readonly participantInspectionService: ParticipantInspectionServiceClient;
+    readonly participantPartyManagementService: ParticipantPartyManagementServiceClient;
+    readonly participantRepairService: ParticipantRepairServiceClient;
+    readonly participantStatusService: ParticipantStatusServiceClient;
+    readonly pruningService: PruningServiceClient;
+    readonly resourceManagementService: ResourceManagementServiceClient;
+    readonly identityInitializationService: IdentityInitializationServiceClient;
+    readonly synchronizerConnectivityService: SynchronizerConnectivityServiceClient;
+    readonly topologyManagerReadService: TopologyManagerReadServiceClient;
+    readonly trafficControlService: TrafficControlServiceClient;
+    readonly topologyAggregationService: TopologyAggregationServiceClient;
+    readonly commandService: CommandServiceClient;
+    readonly commandSubmissionService: CommandSubmissionServiceClient;
+    readonly commandCompletionService: CommandCompletionServiceClient;
+    readonly stateService: StateServiceClient;
+    readonly updateService: UpdateServiceClient;
+    readonly eventQueryService: EventQueryServiceClient;
+    readonly contractService: ContractServiceClient;
+    constructor(options: CantonClientOptions);
+    /** Disposes transport-owned resources for this client instance. */
+    disposeAsync(): Promise<void>;
+}

package/dist/client/canton-client.js

@@ -0,0 +1,82 @@
+import { NotSupportedError } from "../core/errors/not-supported-error.js";
+import { TransportKind } from "../core/types/transport-kind.js";
+import { createServiceRegistry } from "./service-registry.js";
+export class CantonClient {
+    options;
+    transport;
+    disposed = false;
+    versionService;
+    healthService;
+    partyManagementService;
+    userManagementService;
+    commandInspectionService;
+    identityProviderConfigService;
+    packageService;
+    packageManagementService;
+    participantPackageService;
+    participantInspectionService;
+    participantPartyManagementService;
+    participantRepairService;
+    participantStatusService;
+    pruningService;
+    resourceManagementService;
+    identityInitializationService;
+    synchronizerConnectivityService;
+    topologyManagerReadService;
+    trafficControlService;
+    topologyAggregationService;
+    commandService;
+    commandSubmissionService;
+    commandCompletionService;
+    stateService;
+    updateService;
+    eventQueryService;
+    contractService;
+    constructor(options) {
+        this.options = options;
+        if (options.transportKind === TransportKind.json &&
+            options.commandSigner) {
+            throw new NotSupportedError("commandSigner is only supported with grpc transport");
+        }
+        const services = 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.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;
+    }
+    /** Disposes transport-owned resources for this client instance. */
+    async disposeAsync() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        await this.transport.disposeAsync();
+    }
+}