@distrohelena/canton-typescript-sdk 0.1.5 → 0.1.6

package/README.md

@@ -13,10 +13,120 @@ TypeScript SDK for Canton with:
 npm install @distrohelena/canton-typescript-sdk
 ```
 
+## Experimental invariant testing
+
+`@distrohelena/canton-typescript-sdk/testing` is an experimental, opt-in
+Foundry-style fuzzing surface for Canton. It provides semantic parity for
+campaign runs, exact depth, handlers, permissive or strict protocol reverts,
+invariants, shrinking, replay traces, and safe artifacts. It does not attempt
+to reproduce Foundry's EVM, ABI, PRNG, or shrink sequence byte-for-byte.
+
+Define the campaign once, keep ledger I/O in explicit runtime hooks, and use
+safe isolation. Shared or production ledgers must use an explicit external or
+snapshot policy; cleanup policies need contract discovery for ambiguous
+submissions.
+
+```ts
+import * as fc from "fast-check";
+import {
+    defineInvariantCampaign,
+    runInvariantCampaignCheckAsync,
+} from "@distrohelena/canton-typescript-sdk/testing";
+
+const campaign = defineInvariantCampaign<{ total: number }>({
+    runtime: {
+        actors: {
+            issuer: { party: "Issuer", participant: "participant-a" },
+        },
+        isolation: { kind: "external" },
+    },
+    config: { runs: 100, depth: 8, failOnRevert: false, seed: 42 },
+    targets: [{ key: "Main:Iou:Create", actors: ["issuer"] }],
+    invariants: [async ({ model }) => {
+        if (model.total < 0) throw new Error("negative total");
+    }],
+});
+
+await runInvariantCampaignCheckAsync({
+    campaign,
+    arbitrary: fc.constant([{ actor: "issuer", targetKey: "Main:Iou:Create" }]),
+    key: (actions) => JSON.stringify(actions),
+    setupAsync: async () => ({ model: { total: 0 }, ghost: {} }),
+    executeAsync: async () => ({ kind: "accepted", updateId: "update-1" }),
+});
+```
+
+Use `createDamlTestingCatalog`, `targetTemplate`, and
+`resolveDeclarativeTargets` to discover targets. `targetTemplate(id).create()`
+and `.choice(name)` select create and exercise actions; pair the resolved
+targets with `createDeclarativeCampaignArbitrary` for an exact-depth action
+sequence. In `executeAsync`, pass each action to `executeDeclarativeActionAsync`
+with the campaign runtime and an explicit `resolveContractIdAsync` callback for
+choices. The callback is intentional: the SDK will not guess an active contract
+from stale local state. `handler`, `bound`, and handler assumptions support
+custom operations alongside declarative actions. A failed check returns the
+shrunk counterexample trace; `InvariantCampaignFailure` and replay artifacts
+expose only allowlisted diagnostics.
+
+Automatic Party fields require an explicit `valueParties` list. When writing
+commands by hand, use `DamlParty` and `DamlNumeric` for Party and exact decimal
+Numeric values; a plain string is DAML `Text` and a plain JavaScript number is
+not an exact Numeric value.
+
 ## Live Integration Tests
 
 The repository also supports a live SDK validation suite against an already-running CN quickstart localnet.
 
+## Localnet launchers
+
+The published package includes launchers for an existing CN Quickstart checkout.
+Docker Compose must be installed and available. Set `CN_QUICKSTART_DIR` to the
+checkout (or its `quickstart/` directory) when it is not in a supported relative
+location.
+
+After installing the package, run:
+
+```bash
+canton-localnet-start
+canton-localnet-stop
+```
+
+You can also run them without a global install:
+
+```bash
+npm exec --package @distrohelena/canton-typescript-sdk canton-localnet-start
+npm exec --package @distrohelena/canton-typescript-sdk canton-localnet-stop
+```
+
+These commands launch and stop CN Quickstart; they do not provision a
+Quickstart checkout.
+
+### Optional ES256 bearer tokens
+
+Set `LOCALNET_ES256_JWT=1` when starting the localnet to add ES256 JWT
+verification to the primary participants and any `EXTRA_PARTICIPANTS`. The
+existing `AUTH_MODE` stays active for Quickstart's internal services.
+
+By default, the launcher creates reusable P-256 development key material and
+a self-signed certificate in `.generated/localnet-es256` at the package root. Set
+`LOCALNET_ES256_ROTATE=1` to replace generated material, or set both
+`LOCALNET_ES256_PRIVATE_KEY_PATH` and `LOCALNET_ES256_CERTIFICATE_PATH` to
+use your own matching PEM private key and certificate.
+
+The launcher writes a short-lived (ten-minute) token for `ledger-api-user` to
+`ledger-api-user.token` in that runtime directory and prints its path. Use it
+with the live SDK suite:
+
+```bash
+SDK_TEST_LEDGER_BEARER_TOKEN="$(cat .generated/localnet-es256/ledger-api-user.token)" \
+npm run test:live
+```
+
+This is development-only key material. A custom `LOCALNET_ES256_SUBJECT` must
+already be a Ledger API user with the appropriate rights on each participant.
+Extra participants use the existing shared-secret onboarding flow; the current
+OAuth2-plus-extras limitation still applies.
+
 The live suite runs single-worker with an extended timeout because it mutates and reads a shared localnet.
 
 Prerequisites:
@@ -61,6 +171,69 @@ Run:
 npm run test:live
 ```
 
+The opt-in live stateful fuzz campaign uses the two-participant CN quickstart
+`Main:Iou` fixture. It is disabled by default and must be enabled explicitly:
+
+```bash
+SDK_TEST_ENABLE_LIVE_FUZZING=1 \
+FUZZ_NUM_RUNS=20 \
+npm run test:live:fuzz
+```
+
+The campaign requires both gRPC participants, with node 0 using
+`SDK_TEST_LEDGER_ENDPOINT`, `SDK_TEST_LEDGER_ADMIN_ENDPOINT`, and
+`SDK_TEST_PARTICIPANT_ADMIN_ENDPOINT`, and node 1 using the corresponding
+`SDK_TEST_SECONDARY_*` variables. It allocates an issuer on participant A and
+an owner on participant B unless `FUZZ_LIVE_ISSUER_PARTY` and
+`FUZZ_LIVE_OWNER_PARTY` are both supplied. For exact replay, keep those party
+IDs, `FUZZ_LIVE_RUN_ID`, `FUZZ_SEED`, and `FUZZ_PATH` unchanged.
+
+Campaign controls include:
+
+- `FUZZ_LIVE_DEPTH=N` for exact-depth Foundry-style runs. If it is absent,
+  `FUZZ_LIVE_MAX_COMMANDS=N` retains the legacy variable-length behavior;
+  equal values are accepted when both are supplied, while conflicting values
+  fail fast.
+- `FUZZ_LIVE_FAIL_ON_REVERT=true|false` controls protocol reverts. It defaults
+  to `false`; transport errors, timeouts, malformed responses, and ambiguous
+  commit outcomes remain fatal. `FUZZ_LIVE_REQUIRE_ARCHIVE=true|false` also
+  accepts legacy `1|0` and requires strict reverts for archive smoke mode.
+- `FUZZ_LIVE_ACTION_WEIGHTS=query=30,fetch=20,events=20,exercise=10,probe=20`
+  sets non-negative action weights. Exact-depth campaigns always retain a
+  no-contract `probe` fallback and a post-archive read action.
+- `FUZZ_LIVE_ACTORS=issuer,owner` selects eligible actors. `issuer` is
+  mandatory; omitting `owner` removes owner-targeted generated reads while
+  retaining the cross-participant fixture checks.
+- `FUZZ_LIVE_POLL_TIMEOUT_MS`, `FUZZ_LIVE_POLL_INTERVAL_MS`,
+  `FUZZ_LIVE_TEST_TIMEOUT_MS`, and `FUZZ_LIVE_CLEANUP_TIMEOUT_MS` control
+  polling and timeouts.
+- `FUZZ_LIVE_FAILURE_DIR` defaults to `tests/live/.artifacts/failures`.
+  `FUZZ_LIVE_REPLAY_FAILURES=true|false` enables automatic replay of valid
+  artifacts in that directory; stale or corrupt automatic artifacts are
+  reported and skipped. `FUZZ_LIVE_REPLAY_FILE=/path/to/failure.json` performs
+  explicit replay and validates run ID, party IDs, and fingerprints before
+  connecting to participants.
+
+Artifacts contain allowlisted campaign data only: endpoints, credentials,
+headers, and arbitrary error objects are never serialized. They are written
+with restrictive permissions and no-clobber atomic persistence. For a strict
+four-step smoke run, use:
+
+```bash
+SDK_TEST_ENABLE_LIVE_FUZZING=1 \
+FUZZ_NUM_RUNS=1 \
+FUZZ_LIVE_DEPTH=4 \
+FUZZ_LIVE_FAIL_ON_REVERT=true \
+FUZZ_LIVE_REQUIRE_ARCHIVE=1 \
+FUZZ_LIVE_FAILURE_DIR=tests/live/.artifacts/smoke \
+npm run test:live:fuzz
+```
+
+This fixture assumes the CN quickstart already has the `Main:Iou` package on
+both participants. The ledger-only DAML Ops localnet launcher is not a
+substitute: open ports are insufficient without the quickstart Ledger API,
+package, party, and cross-participant visibility checks.
+
 Experimental multi-host external-party coverage is opt-in:
 
 - set `SDK_TEST_ENABLE_MULTI_HOST_EXTERNAL_PARTY=1` to enable the multi-host live spec
@@ -135,8 +308,128 @@ For gRPC, channel security resolves per surface:
 - ledger admin services use `ledgerAdminGrpcChannelSecurity ?? grpcChannelSecurity ?? GrpcChannelSecurity.tls`
 - participant admin services use `participantAdminGrpcChannelSecurity ?? grpcChannelSecurity ?? GrpcChannelSecurity.tls`
 
+### gRPC error handling
+
+gRPC failures reject with `GrpcTransportError`, a `TransportError` subclass
+with the gRPC status code, service/method, copied metadata, and decoded
+`google.rpc.Status` trailer when Canton provides one. Use `onGrpcError` for
+centralized logging or telemetry; it observes the error but cannot replace the
+rejection if the callback itself fails.
+
+```ts
+import { GrpcTransportError } from "@distrohelena/canton-typescript-sdk";
+
+const client = new CantonClient(new CantonClientOptions({
+    // existing gRPC connection options,
+    onGrpcError: (error) => {
+        logger.error({ code: error.grpcCode, status: error.status });
+    },
+}));
+
+try {
+    await client.userManagementService.listUsersAsync(/* request */);
+} catch (error) {
+    if (error instanceof GrpcTransportError) {
+        console.error(error.grpcCode, error.serviceName, error.methodName);
+    }
+}
+```
+
+Application-specific `google.protobuf.Any` values in `error.status.details`
+remain opaque (`typeUrl` and bytes) unless the application knows that type.
+
+### External party lifecycle
+
+For an externally controlled party, provide the public key and a callback that
+delegates signing to your HSM, KMS, wallet, or other key service. The SDK
+generates the Canton topology, requests signatures for each topology
+transaction and its multihash, then allocates the party. It never receives a
+private key.
+
+```ts
+import {
+    CreateExternalPartyRequest,
+    ExternalPartyCryptoKeyFormat,
+    ExternalPartySignatureFormat,
+    ExternalPartySigningAlgorithmSpec,
+    ExternalPartySigningKeySpec,
+    ExternalPartySigningPublicKey,
+} from "@distrohelena/canton-typescript-sdk";
+
+const party = await client.partyManagementService.createExternalPartyAsync(
+    new CreateExternalPartyRequest({
+        synchronizer: "sync::sandbox",
+        partyHint: "alice",
+        publicKey: new ExternalPartySigningPublicKey({
+            format: ExternalPartyCryptoKeyFormat.raw,
+            keyData: ed25519PublicKeyBytes,
+            keySpec: ExternalPartySigningKeySpec.ecCurve25519,
+        }),
+        sign: async ({ payload }) => ({
+            signature: await keyService.sign(payload),
+            format: ExternalPartySignatureFormat.raw,
+            signingAlgorithmSpec: ExternalPartySigningAlgorithmSpec.ed25519,
+        }),
+    }),
+);
+```
+
+Use the same flow for secp256k1 by supplying
+`ExternalPartySigningKeySpec.ecSecp256k1` and the signer’s compatible Canton
+signature format and algorithm. This convenience operation is gRPC-only.
+
 ## Service Map
 
+## Canton Manager queries
+
+`CantonManager` keeps gRPC as the write path and selects a single query source
+at initialization. PQS exposes the complete PQS relation surface; gRPC exposes
+an all-hosted-party active-contract snapshot.
+
+```ts
+import {
+    CantonManager,
+    MemoryQueryCache,
+    QuerySource,
+    TransportKind,
+} from "@distrohelena/canton-typescript-sdk";
+
+const manager = new CantonManager({
+    grpc: { transportKind: TransportKind.grpc, ledgerEndpoint: "localhost:6865" },
+    querySource: QuerySource.pqs,
+    pqs: { connectionString: process.env.PQS_URL!, schema: "public" },
+    cache: { store: new MemoryQueryCache(), ttlMs: 5_000 },
+});
+
+const contracts = await manager.query.contracts.findMany({
+    where: { templateId: { equals: "packageId:Module:Template" }, active: true },
+    take: 50,
+});
+
+await manager.grpc.commandService.submitAndWaitAsync(/* existing command request */);
+await manager.disposeAsync();
+```
+
+With `QuerySource.grpc`, omit `pqs`; contract queries fetch the participant's
+active-contract snapshot using the Ledger API wildcard for all hosted parties.
+PQS-only relation delegates and raw SQL then reject with `QueryCapabilityError`.
+
+PQS managers expose `contracts`, `contractTypes`, `events`, `exercises`,
+`exerciseTypes`, `packages`, `transactions`, and `watermark`. Raw SQL is
+available through `manager.query.$queryRaw(...)` when the selected client is
+PQS-specific. It accepts one read-only statement with positional parameters;
+use a read-only PostgreSQL role as defense in depth.
+
+The PQS relation delegates use a Prisma-like surface: `findMany({ where,
+select, orderBy, skip, take })`, `findUnique({ where, select })`, `count`, and
+`aggregate({ count, min, max, sum })`. Filters support `equals`, `in`,
+`{ is: null }`, `{ isNot: null }`, and `{ has: party }` on array fields.
+Ordering accepts one field. `exercises` intentionally has no `findUnique`
+because the v1 PQS profile does not declare a stable key. The manager validates
+the selected PQS schema profile before its first query. In gRPC mode, only the
+active-contract `findMany`, `findUnique`, and `count` subset is available;
+unsupported query features reject with `QueryCapabilityError`.
+
 - Ledger endpoint:
 - `versionService.getLedgerApiVersionAsync(...)`: `json`, `grpc`
 - `healthService.checkAsync(...)`: `grpc` only
@@ -160,6 +453,7 @@ For gRPC, channel security resolves per surface:
 - `partyManagementService.getPartiesAsync(...)`: `grpc` only
 - `partyManagementService.generateExternalPartyTopologyAsync(...)`: `grpc` only
 - `partyManagementService.allocateExternalPartyAsync(...)`: `grpc` only
+- `partyManagementService.createExternalPartyAsync(...)`: `grpc` only
 - `userManagementService.grantUserRightsAsync(...)`: `json`, `grpc`
 - `packageManagementService.uploadDarFileAsync(...)`: `json`, `grpc`
 
@@ -189,6 +483,7 @@ Subpath exports are available when you want to construct directly over a transpo
 - `@distrohelena/canton-typescript-sdk/grpc`
 - `@distrohelena/canton-typescript-sdk/json`
 - `@distrohelena/canton-typescript-sdk/daml-lf`
+- `@distrohelena/canton-typescript-sdk/debugger`
 - `@distrohelena/canton-typescript-sdk/daml-interface`
 
 `GrpcLedgerClient` and `JsonLedgerClient` expose the same service properties as `CantonClient`.
@@ -208,7 +503,8 @@ Current scope:
 - 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
+- evaluator core and trace-sink contracts
+- replay-effect tracing for debugger-owned sessions
 
 Example:
 
@@ -230,6 +526,42 @@ const compilation = DamlLfCompilation.createOrThrow(workspace);
 const semanticModel = compilation.createSemanticModel();
 ```
 
+## Replay Debugger
+
+The package also exposes an experimental replay debugger at `@distrohelena/canton-typescript-sdk/debugger`.
+
+Current scope:
+
+- load a replay session from a committed update offset
+- hydrate referenced contracts through the gRPC contract and event-query services
+- precompute a stepwise LF trace and expose stepping/session APIs
+- replay LF update bodies for the supported evaluator subset, including nested exercise-driven effects
+- validate replay determinism against the observed update payload
+
+Current limits:
+
+- replay depends on gRPC-visible create/exercise payloads
+- source-aware replay expects DAR provenance with debugger source-map metadata
+- unsupported LF constructs still fail fast with `ReplayUnsupportedLfConstructException`
+- source locations currently map to executable definition spans from the DAR source map
+
+Example:
+
+```ts
+import {
+    LedgerReplayDebuggerClient,
+    ReplaySessionRequest,
+} from "@distrohelena/canton-typescript-sdk/debugger";
+
+const debuggerClient = new LedgerReplayDebuggerClient({
+    sessionLoader,
+});
+
+const session = await debuggerClient.loadSessionAsync(
+    new ReplaySessionRequest({ offset: "42" }),
+);
+```
+
 ## 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.

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

@@ -2,6 +2,7 @@ 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";
+import type { GrpcTransportError } from "../core/errors/grpc-transport-error.js";
 export declare class CantonClientOptions {
     readonly transportKind: TransportKind;
     readonly ledgerEndpoint?: string;
@@ -17,6 +18,7 @@ export declare class CantonClientOptions {
     readonly ledgerAdminAuthProvider?: IAuthProvider;
     readonly participantAdminAuthProvider?: IAuthProvider;
     readonly commandSigner?: ICommandSigner;
+    readonly onGrpcError?: (error: GrpcTransportError) => void;
     constructor(init: {
         transportKind: TransportKind;
         ledgerEndpoint?: string;
@@ -32,5 +34,6 @@ export declare class CantonClientOptions {
         ledgerAdminAuthProvider?: IAuthProvider;
         participantAdminAuthProvider?: IAuthProvider;
         commandSigner?: ICommandSigner;
+        onGrpcError?: (error: GrpcTransportError) => void;
     });
 }

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

@@ -14,6 +14,7 @@ export class CantonClientOptions {
     ledgerAdminAuthProvider;
     participantAdminAuthProvider;
     commandSigner;
+    onGrpcError;
     constructor(init) {
         this.transportKind = init.transportKind;
         this.ledgerEndpoint = init.ledgerEndpoint;
@@ -33,5 +34,6 @@ export class CantonClientOptions {
         this.participantAdminAuthProvider =
             init.participantAdminAuthProvider;
         this.commandSigner = init.commandSigner;
+        this.onGrpcError = init.onGrpcError;
     }
 }

package/dist/client/service-registry.js

@@ -1119,11 +1119,12 @@ export function createServiceRegistry(options) {
         ledgerAdminTransport,
         participantAdminTransport,
     ].filter((item) => item !== undefined));
+    const topologyManagerWriteService = new TopologyManagerWriteServiceClient(topologyManagerWriteTransport);
     return {
         transport,
         versionService: new VersionServiceClient(versionTransport),
         healthService: new HealthServiceClient(healthTransport),
-        partyManagementService: new PartyManagementServiceClient(partyManagementTransport),
+        partyManagementService: new PartyManagementServiceClient(partyManagementTransport, topologyManagerWriteService),
         userManagementService: new UserManagementServiceClient(userManagementTransport),
         commandInspectionService: new CommandInspectionServiceClient(commandInspectionTransport),
         identityProviderConfigService: new IdentityProviderConfigServiceClient(identityProviderConfigTransport),
@@ -1139,7 +1140,7 @@ export function createServiceRegistry(options) {
         identityInitializationService: new IdentityInitializationServiceClient(identityInitializationTransport),
         synchronizerConnectivityService: new SynchronizerConnectivityServiceClient(synchronizerConnectivityTransport),
         topologyManagerReadService: new TopologyManagerReadServiceClient(topologyManagerReadTransport),
-        topologyManagerWriteService: new TopologyManagerWriteServiceClient(topologyManagerWriteTransport),
+        topologyManagerWriteService,
         trafficControlService: new TrafficControlServiceClient(trafficControlTransport),
         topologyAggregationService: new TopologyAggregationServiceClient(topologyAggregationTransport),
         commandService: new CommandServiceClient(commandTransport, options.commandSigner),

package/dist/core/errors/grpc-transport-error.d.ts

@@ -0,0 +1,14 @@
+import type { Status as GrpcStatusDetails } from "../../transports/grpc/generated/canton/google/rpc/status.js";
+import { TransportError } from "./transport-error.js";
+export type GrpcErrorMetadata = Readonly<Record<string, readonly string[]>>;
+export type { GrpcStatusDetails };
+export declare class GrpcTransportError extends TransportError {
+    readonly grpcCode: string;
+    readonly serviceName?: string;
+    readonly methodName?: string;
+    readonly metadata: GrpcErrorMetadata;
+    readonly status?: GrpcStatusDetails;
+    readonly cause: Error;
+    private constructor();
+    static fromUnknown(error: unknown): GrpcTransportError | undefined;
+}

package/dist/core/errors/grpc-transport-error.js

@@ -0,0 +1,76 @@
+import { Status } from "../../transports/grpc/generated/canton/google/rpc/status.js";
+import { TransportError } from "./transport-error.js";
+export class GrpcTransportError extends TransportError {
+    grpcCode;
+    serviceName;
+    methodName;
+    metadata;
+    status;
+    cause;
+    constructor(message, rawError, metadata, status) {
+        super(message);
+        this.grpcCode = rawError.code;
+        this.serviceName = rawError.serviceName;
+        this.methodName = rawError.methodName;
+        this.metadata = metadata;
+        this.status = status;
+        this.cause = rawError;
+    }
+    static fromUnknown(error) {
+        if (!isRpcErrorLike(error)) {
+            return undefined;
+        }
+        const metadata = copyMetadata(error.meta);
+        const status = decodeStatusDetails(error.meta);
+        return new GrpcTransportError(formatMessage(error), error, metadata, status);
+    }
+}
+function isRpcErrorLike(error) {
+    if (!(error instanceof Error) || error.name !== "RpcError") {
+        return false;
+    }
+    const candidate = error;
+    return typeof candidate.code === "string";
+}
+function copyMetadata(metadata) {
+    const copied = Object.create(null);
+    for (const [key, value] of Object.entries(metadata ?? {})) {
+        const strings = asArray(value).filter((metadataValue) => typeof metadataValue === "string");
+        if (strings.length > 0) {
+            copied[key] = Object.freeze([...strings]);
+        }
+    }
+    return Object.freeze(copied);
+}
+function decodeStatusDetails(metadata) {
+    const values = asArray(metadata?.["grpc-status-details-bin"]);
+    for (const value of values) {
+        const bytes = toBinary(value);
+        if (bytes === undefined) {
+            continue;
+        }
+        try {
+            return Status.fromBinary(bytes);
+        }
+        catch {
+            // Try another trailer value without masking the original RPC failure.
+        }
+    }
+    return undefined;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : value === undefined ? [] : [value];
+}
+function toBinary(value) {
+    if (typeof value === "string") {
+        return Buffer.from(value, "base64");
+    }
+    return value instanceof Uint8Array ? value : undefined;
+}
+function formatMessage(error) {
+    const operation = [error.serviceName, error.methodName]
+        .filter((part) => part !== undefined)
+        .join(".");
+    const location = operation.length > 0 ? ` from ${operation}` : "";
+    return `gRPC ${error.code}${location}: ${error.message}`;
+}

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

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

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

@@ -2,4 +2,5 @@ export var CantonHashPurpose;
 (function (CantonHashPurpose) {
     CantonHashPurpose[CantonHashPurpose["topologyTransactionSignature"] = 11] = "topologyTransactionSignature";
     CantonHashPurpose[CantonHashPurpose["publicKeyFingerprint"] = 12] = "publicKeyFingerprint";
+    CantonHashPurpose[CantonHashPurpose["decentralizedNamespace"] = 37] = "decentralizedNamespace";
 })(CantonHashPurpose || (CantonHashPurpose = {}));

package/dist/core/types/daml-numeric.d.ts

@@ -0,0 +1,6 @@
+/** Exact decimal DAML Numeric value, encoded without floating-point rounding. */
+export declare class DamlNumeric {
+    readonly value: string;
+    constructor(value: string);
+    toJSON(): string;
+}

package/dist/core/types/daml-numeric.js

@@ -0,0 +1,14 @@
+import { ValidationError } from "../errors/validation-error.js";
+/** Exact decimal DAML Numeric value, encoded without floating-point rounding. */
+export class DamlNumeric {
+    value;
+    constructor(value) {
+        if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) {
+            throw new ValidationError("DAML numeric values must be exact decimal strings");
+        }
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/core/types/daml-party.d.ts

@@ -0,0 +1,6 @@
+/** Explicit DAML Party value for commands whose field type is Party, not Text. */
+export declare class DamlParty {
+    readonly value: string;
+    constructor(value: string);
+    toJSON(): string;
+}

package/dist/core/types/daml-party.js

@@ -0,0 +1,14 @@
+import { ValidationError } from "../errors/validation-error.js";
+/** Explicit DAML Party value for commands whose field type is Party, not Text. */
+export class DamlParty {
+    value;
+    constructor(value) {
+        if (value.length === 0) {
+            throw new ValidationError("DAML party values must not be empty");
+        }
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/core/types/requests/create-decentralized-party-request.d.ts

@@ -0,0 +1,41 @@
+import { ExternalPartySigningPublicKey } from "../external-party/external-party-signing-public-key.js";
+import { ExternalPartySigningRequest, ExternalPartySigningResult } from "./create-external-party-request.js";
+export interface DecentralizedPartyKey {
+    readonly publicKey: ExternalPartySigningPublicKey;
+    readonly sign?: DecentralizedPartySigner;
+}
+export interface DecentralizedPartySigningRequest extends ExternalPartySigningRequest {
+    readonly role: "owner" | "partySigningKey";
+    readonly transactionHash: Uint8Array;
+}
+export type DecentralizedPartySigner = (request: DecentralizedPartySigningRequest) => Promise<ExternalPartySigningResult>;
+export declare class CreateDecentralizedPartyRequest {
+    readonly synchronizer: string;
+    readonly partyHint: string;
+    readonly owners: readonly DecentralizedPartyKey[];
+    readonly ownerThreshold: number;
+    readonly partySigningKeys: readonly DecentralizedPartyKey[];
+    readonly partySigningThreshold: number;
+    readonly localParticipantObservationOnly: boolean;
+    readonly otherConfirmingParticipantUids: readonly string[];
+    readonly confirmationThreshold: number;
+    readonly observingParticipantUids: readonly string[];
+    readonly identityProviderId?: string;
+    readonly waitForAllocation?: boolean;
+    readonly userId?: string;
+    constructor(init: {
+        synchronizer?: string;
+        partyHint?: string;
+        owners?: readonly DecentralizedPartyKey[];
+        ownerThreshold?: number;
+        partySigningKeys?: readonly DecentralizedPartyKey[];
+        partySigningThreshold?: number;
+        localParticipantObservationOnly?: boolean;
+        otherConfirmingParticipantUids?: readonly string[];
+        confirmationThreshold?: number;
+        observingParticipantUids?: readonly string[];
+        identityProviderId?: string;
+        waitForAllocation?: boolean;
+        userId?: string;
+    });
+}