@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

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

@@ -0,0 +1,61 @@
+import { QuerySource } from "./query-source.js";
+import { ContractTypeOrderBy, ContractTypeRow, ContractTypeSelect, ContractTypeUnique, ContractTypeWhere, ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractRow, EventOrderBy, EventRow, EventSelect, EventUnique, EventWhere, ExerciseOrderBy, ExerciseRow, ExerciseSelect, ExerciseTypeOrderBy, ExerciseTypeRow, ExerciseTypeSelect, ExerciseTypeUnique, ExerciseTypeWhere, ExerciseWhere, PackageOrderBy, PackageRow, PackageSelect, PackageUnique, PackageWhere, TransactionOrderBy, TransactionRow, TransactionSelect, TransactionUnique, TransactionWhere, WatermarkOrderBy, WatermarkRow, WatermarkSelect, WatermarkUnique, WatermarkWhere } from "./model-types.js";
+export interface FindManyArgs<TWhere, TSelect, TOrderBy> {
+    readonly where?: TWhere;
+    readonly select?: TSelect;
+    readonly orderBy?: TOrderBy;
+    readonly skip?: number;
+    readonly take?: number;
+}
+export interface QueryDelegate<TRow, TWhere, TSelect, TOrderBy, TUnique> {
+    findMany(args?: FindManyArgs<TWhere, TSelect, TOrderBy>): Promise<readonly TRow[]>;
+    findUnique(args: {
+        readonly where: TUnique;
+        readonly select?: TSelect;
+    }): Promise<TRow | undefined>;
+    count(args?: {
+        readonly where?: TWhere;
+    }): Promise<number>;
+    aggregate(args: {
+        readonly where?: TWhere;
+        readonly count?: true;
+        readonly min?: readonly (keyof TRow)[];
+        readonly max?: readonly (keyof TRow)[];
+        readonly sum?: readonly (keyof TRow)[];
+    }): Promise<{
+        readonly count?: number;
+        readonly min?: Readonly<Record<string, string | null>>;
+        readonly max?: Readonly<Record<string, string | null>>;
+        readonly sum?: Readonly<Record<string, string | null>>;
+    }>;
+}
+export type QueryCollectionDelegate<TRow, TWhere, TSelect, TOrderBy> = Omit<QueryDelegate<TRow, TWhere, TSelect, TOrderBy, never>, "findUnique">;
+export interface QueryClient {
+    readonly source: QuerySource;
+    $queryRaw<TRow>(sql: string, values?: readonly unknown[]): Promise<readonly TRow[]>;
+    readonly contracts: {
+        findMany(args?: ContractFindManyArgs): Promise<readonly ContractRow[]>;
+        findUnique(args: ContractFindUniqueArgs): Promise<ContractRow | undefined>;
+        count(args?: ContractCountArgs): Promise<number>;
+        aggregate(args: {
+            readonly where?: ContractCountArgs["where"];
+            readonly count?: true;
+            readonly min?: readonly ContractNumericField[];
+            readonly max?: readonly ContractNumericField[];
+            readonly sum?: readonly ContractNumericField[];
+        }): Promise<{
+            readonly count?: number;
+            readonly min?: Readonly<Partial<Record<ContractNumericField, string | null>>>;
+            readonly max?: Readonly<Partial<Record<ContractNumericField, string | null>>>;
+            readonly sum?: Readonly<Partial<Record<ContractNumericField, string | null>>>;
+        }>;
+    };
+    readonly contractTypes: QueryDelegate<ContractTypeRow, ContractTypeWhere, ContractTypeSelect, ContractTypeOrderBy, ContractTypeUnique>;
+    readonly events: QueryDelegate<EventRow, EventWhere, EventSelect, EventOrderBy, EventUnique>;
+    readonly exercises: QueryCollectionDelegate<ExerciseRow, ExerciseWhere, ExerciseSelect, ExerciseOrderBy>;
+    readonly exerciseTypes: QueryDelegate<ExerciseTypeRow, ExerciseTypeWhere, ExerciseTypeSelect, ExerciseTypeOrderBy, ExerciseTypeUnique>;
+    readonly packages: QueryDelegate<PackageRow, PackageWhere, PackageSelect, PackageOrderBy, PackageUnique>;
+    readonly transactions: QueryDelegate<TransactionRow, TransactionWhere, TransactionSelect, TransactionOrderBy, TransactionUnique>;
+    readonly watermark: QueryDelegate<WatermarkRow, WatermarkWhere, WatermarkSelect, WatermarkOrderBy, WatermarkUnique>;
+}
+export type ContractNumericField = "createdEventOffset" | "archivedEventOffset";

package/dist/query/query-client.js

@@ -0,0 +1 @@
+export {};

package/dist/query/query-source.d.ts

@@ -0,0 +1,4 @@
+export declare enum QuerySource {
+    grpc = "grpc",
+    pqs = "pqs"
+}

package/dist/query/query-source.js

@@ -0,0 +1,5 @@
+export var QuerySource;
+(function (QuerySource) {
+    QuerySource["grpc"] = "grpc";
+    QuerySource["pqs"] = "pqs";
+})(QuerySource || (QuerySource = {}));

package/dist/services/commands/command-payload-builder.js

@@ -18,7 +18,7 @@ function mapCanonicalCommand(command) {
             payload: command.payload,
         };
     }
-    if (command instanceof ExerciseCommand) {
+    else if (command instanceof ExerciseCommand) {
         return {
             kind: "exercise",
             templateId: command.templateId,
@@ -27,7 +27,7 @@ function mapCanonicalCommand(command) {
             argument: command.argument,
         };
     }
-    if (command instanceof ExerciseByKeyCommand) {
+    else if (command instanceof ExerciseByKeyCommand) {
         return {
             kind: "exerciseByKey",
             templateId: command.templateId,
@@ -36,7 +36,7 @@ function mapCanonicalCommand(command) {
             argument: command.argument,
         };
     }
-    if (command instanceof CreateAndExerciseCommand) {
+    else if (command instanceof CreateAndExerciseCommand) {
         return {
             kind: "createAndExercise",
             templateId: command.templateId,

package/dist/services/commands/command-submission-pipeline.js

@@ -1,21 +1,15 @@
 import { NotSupportedError } from "../../core/errors/not-supported-error.js";
-import { SignCommandRequest } from "../../core/signing/sign-command-request.js";
-import { buildCanonicalCommandPayload } from "./command-payload-builder.js";
 export class CommandSubmissionPipeline {
     dependencies;
     constructor(dependencies) {
         this.dependencies = dependencies;
     }
     async submitAsync(request, options) {
-        let signed;
         if (this.dependencies.signer) {
             if (!this.dependencies.transport.features.supportsCommandSigning) {
                 throw new NotSupportedError("command signing is not supported by the selected transport");
             }
-            signed = await this.dependencies.signer.signAsync(new SignCommandRequest({
-                payload: buildCanonicalCommandPayload(request),
-            }));
         }
-        return this.dependencies.transport.submitCommandAsync(request, signed, options);
+        return this.dependencies.transport.submitCommandAsync(request, this.dependencies.signer, options);
     }
 }

package/dist/services/party-management/decentralized-party-lifecycle.d.ts

@@ -0,0 +1,6 @@
+import { CreateDecentralizedPartyRequest } from "../../core/types/requests/create-decentralized-party-request.js";
+import { PreparedDecentralizedParty } from "../../core/types/requests/finalize-decentralized-party-request.js";
+import { GetParticipantIdResponse } from "../../core/types/responses/get-participant-id-response.js";
+import { RequestOptions } from "../../core/types/request-options.js";
+import { TopologyManagerWriteServiceClient } from "../topology-manager-write/topology-manager-write-service-client.js";
+export declare function prepareDecentralizedPartyAsync(request: CreateDecentralizedPartyRequest, localParticipant: GetParticipantIdResponse, topologyWriter: TopologyManagerWriteServiceClient, options?: RequestOptions): Promise<PreparedDecentralizedParty>;

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

@@ -0,0 +1,82 @@
+import { computeCantonHashHex, computeCantonPublicKeyFingerprint } from "../../core/hashing/canton-hash.js";
+import { ValidationError } from "../../core/errors/validation-error.js";
+import { CantonHashPurpose } from "../../core/types/canton-hash-purpose.js";
+import { PreparedDecentralizedParty } from "../../core/types/requests/finalize-decentralized-party-request.js";
+import { PreparedTopologyTransaction } from "../../core/types/topology/prepared-topology-transaction.js";
+import { GenerateTopologyTransactionsRequest } from "../../core/types/requests/generate-topology-transactions-request.js";
+import { DecentralizedNamespaceDefinition } from "../../core/types/topology/decentralized-namespace-definition.js";
+import { NamespaceDelegation } from "../../core/types/topology/namespace-delegation.js";
+import { PartyToParticipant, PartyToParticipantParticipant } from "../../core/types/topology/party-to-participant.js";
+import { ParticipantPermission } from "../../core/types/topology/participant-permission.js";
+import { TopologyMappingOperation } from "../../core/types/topology/topology-mapping-operation.js";
+import { TopologySigningKeysWithThreshold, TopologySigningPublicKey } from "../../core/types/topology/topology-public-key.js";
+export 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 = [
+        new PartyToParticipantParticipant({
+            participantUid: localParticipant.participantId,
+            permission: request.localParticipantObservationOnly
+                ? ParticipantPermission.observation
+                : ParticipantPermission.confirmation,
+        }),
+        ...request.otherConfirmingParticipantUids.map((participantUid) => new PartyToParticipantParticipant({ participantUid, permission: ParticipantPermission.confirmation })),
+        ...request.observingParticipantUids.map((participantUid) => new PartyToParticipantParticipant({ participantUid, permission: ParticipantPermission.observation })),
+    ];
+    const generated = await topologyWriter.generateTransactionsAsync(new GenerateTopologyTransactionsRequest({
+        proposals: [
+            { operation: TopologyMappingOperation.addReplace, serial: 1, mapping: new DecentralizedNamespaceDefinition({ decentralizedNamespace, threshold: request.ownerThreshold, owners: ownerFingerprints }) },
+            ...owners.map((targetKey) => ({ operation: TopologyMappingOperation.addReplace, serial: 1, mapping: new NamespaceDelegation({ namespace: decentralizedNamespace, targetKey, isRootDelegation: true }) })),
+            { operation: TopologyMappingOperation.addReplace, serial: 1, mapping: new PartyToParticipant({ party: partyId, threshold: request.confirmationThreshold, participants, partySigningKeys: new TopologySigningKeysWithThreshold({ threshold: request.partySigningThreshold, keys: partyKeys }) }) },
+        ],
+    }), options);
+    if (generated.generatedTransactions.length !== owners.length + 2) {
+        throw new ValidationError("decentralized party generated transaction count does not match proposals");
+    }
+    const transactions = generated.generatedTransactions.map((transaction) => new 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 PreparedDecentralizedParty({ synchronizer: request.synchronizer, partyId, decentralizedNamespace, ownerThreshold: request.ownerThreshold, partySigningThreshold: request.partySigningThreshold, transactions, signingRequests });
+}
+function fingerprintFor(value) {
+    const fingerprint = computeCantonPublicKeyFingerprint(value.publicKey.keyData, value.publicKey.format);
+    if (fingerprint === undefined) {
+        throw new 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 computeCantonHashHex(new Uint8Array(chunks), CantonHashPurpose.decentralizedNamespace);
+}
+function toTopologyKey(value) {
+    return new TopologySigningPublicKey({ format: value.publicKey.format, publicKey: value.publicKey.keyData, keySpec: value.publicKey.keySpec, usage: ["namespace", "protocol", "proofOfOwnership"] });
+}

package/dist/services/party-management/party-management-service-client.d.ts

@@ -2,6 +2,8 @@ import { ITransport } from "../../core/transports/transport.interface.js";
 import { RequestOptions } from "../../core/types/request-options.js";
 import { AllocateExternalPartyRequest } from "../../core/types/requests/allocate-external-party-request.js";
 import { AllocatePartyRequest } from "../../core/types/requests/allocate-party-request.js";
+import { CreateExternalPartyRequest } from "../../core/types/requests/create-external-party-request.js";
+import { CreateDecentralizedPartyRequest } from "../../core/types/requests/create-decentralized-party-request.js";
 import { GenerateExternalPartyTopologyRequest } from "../../core/types/requests/generate-external-party-topology-request.js";
 import { AllocateExternalPartyResponse } from "../../core/types/responses/allocate-external-party-response.js";
 import { GetParticipantIdRequest } from "../../core/types/requests/get-participant-id-request.js";
@@ -12,9 +14,19 @@ import { GenerateExternalPartyTopologyResponse } from "../../core/types/response
 import { GetParticipantIdResponse } from "../../core/types/responses/get-participant-id-response.js";
 import { GetPartiesResponse } from "../../core/types/responses/get-parties-response.js";
 import { ListKnownPartiesResponse } from "../../core/types/responses/list-known-parties-response.js";
+import { PreparedDecentralizedParty } from "../../core/types/requests/finalize-decentralized-party-request.js";
+import { DecentralizedPartyDetachedSignature } from "../../core/types/requests/finalize-decentralized-party-request.js";
+import { TopologyManagerWriteServiceClient } from "../topology-manager-write/topology-manager-write-service-client.js";
 export declare class PartyManagementServiceClient {
     private readonly transport;
-    constructor(transport: ITransport);
+    private readonly topologyWriter?;
+    constructor(transport: ITransport, topologyWriter?: TopologyManagerWriteServiceClient | undefined);
+    /** Prepares canonical decentralized-party topology for caller-owned signing. Supported on gRPC with participant-admin configuration. */
+    prepareDecentralizedPartyAsync(request: CreateDecentralizedPartyRequest, options?: RequestOptions): Promise<PreparedDecentralizedParty>;
+    /** Validates detached decentralized-party signatures before allocation. */
+    finalizeDecentralizedPartyAsync(prepared: PreparedDecentralizedParty, signatures: readonly DecentralizedPartyDetachedSignature[], _options?: RequestOptions): Promise<AllocateExternalPartyResponse>;
+    /** Creates a decentralized party using the per-key callbacks in the request. */
+    createDecentralizedPartyAsync(request: CreateDecentralizedPartyRequest, options?: RequestOptions): Promise<AllocateExternalPartyResponse>;
     /** Lists known parties. Supported on JSON and gRPC. */
     listKnownPartiesAsync(request: ListKnownPartiesRequest, options?: RequestOptions): Promise<ListKnownPartiesResponse>;
     /** Reads the host participant identifier. Supported on gRPC; JSON rejects it. */
@@ -27,4 +39,7 @@ export declare class PartyManagementServiceClient {
     generateExternalPartyTopologyAsync(request: GenerateExternalPartyTopologyRequest, options?: RequestOptions): Promise<GenerateExternalPartyTopologyResponse>;
     /** Allocates an external party through the ledger-admin API. Supported on gRPC; JSON rejects it. */
     allocateExternalPartyAsync(request: AllocateExternalPartyRequest, options?: RequestOptions): Promise<AllocateExternalPartyResponse>;
+    /** Creates an externally controlled party using caller-provided signing. Supported on gRPC. */
+    createExternalPartyAsync(request: CreateExternalPartyRequest, options?: RequestOptions): Promise<AllocateExternalPartyResponse>;
+    private signExternalPartyPayloadAsync;
 }

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

@@ -1,9 +1,100 @@
+import { AllocateExternalPartyRequest } from "../../core/types/requests/allocate-external-party-request.js";
+import { GenerateExternalPartyTopologyRequest } from "../../core/types/requests/generate-external-party-topology-request.js";
+import { ExternalPartyOnboardingTransaction } from "../../core/types/external-party/external-party-onboarding-transaction.js";
+import { ExternalPartySignature } from "../../core/types/external-party/external-party-signature.js";
+import { GetParticipantIdRequest } from "../../core/types/requests/get-participant-id-request.js";
+import { ValidationError } from "../../core/errors/validation-error.js";
+import { prepareDecentralizedPartyAsync } from "./decentralized-party-lifecycle.js";
+import { NotSupportedError } from "../../core/errors/not-supported-error.js";
+import { computeCantonPublicKeyFingerprint } from "../../core/hashing/canton-hash.js";
 export class PartyManagementServiceClient {
     transport;
-    constructor(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 NotSupportedError("decentralized party preparation requires a topology manager write service");
+        }
+        const participant = await this.getParticipantIdAsync(new GetParticipantIdRequest(), options);
+        return 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 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 ValidationError("decentralized party finalization has unexpected or duplicate signatures");
+            }
+            else if (detached.result.signature.length === 0) {
+                throw new ValidationError("decentralized party finalization has malformed signatures");
+            }
+            seen.add(detached.signingRequestId);
+            const key = toHex(signingRequest.transactionHash);
+            const transactionSignatures = signaturesByHash.get(key) ?? [];
+            transactionSignatures.push(new 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 ValidationError("decentralized party finalization has missing signatures");
+            }
+        }
+        return this.allocateExternalPartyAsync(new AllocateExternalPartyRequest({
+            synchronizer: prepared.synchronizer,
+            onboardingTransactions: prepared.transactions.map((transaction) => new ExternalPartyOnboardingTransaction({
+                transaction: transaction.serializedTransaction,
+                signatures: signaturesByHash.get(toHex(transaction.transactionHash)) ?? [],
+            })),
+            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 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);
@@ -28,4 +119,54 @@ export class PartyManagementServiceClient {
     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(new GenerateExternalPartyTopologyRequest({
+            synchronizer: request.synchronizer,
+            partyHint: request.partyHint,
+            publicKey: 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 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(new AllocateExternalPartyRequest({
+            synchronizer: request.synchronizer,
+            onboardingTransactions,
+            multiHashSignatures: [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 ExternalPartySignature({
+            format: result.format,
+            signature: result.signature,
+            signedByFingerprint: publicKeyFingerprint,
+            signingAlgorithmSpec: result.signingAlgorithmSpec,
+        });
+    }
+}
+function toHex(bytes) {
+    return [...bytes].map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+function computeFingerprint(key) {
+    return computeCantonPublicKeyFingerprint(key.publicKey.keyData, key.publicKey.format);
 }

package/dist/services/topology-manager-write/topology-signed-transaction-assembler.js

@@ -59,6 +59,8 @@ function mapExternalSignatureFormatToRawFormat(signatureFormat) {
     switch (signatureFormat) {
         case TopologySignatureFormat.ed25519:
             return "concat";
+        case TopologySignatureFormat.ecDsaSha256:
+            return "der";
         default:
             return "unspecified";
     }
@@ -67,6 +69,8 @@ function mapExternalSignatureFormatToAlgorithmSpec(signatureFormat) {
     switch (signatureFormat) {
         case TopologySignatureFormat.ed25519:
             return "ed25519";
+        case TopologySignatureFormat.ecDsaSha256:
+            return "ecDsaSha256";
         default:
             return "unspecified";
     }

package/dist/testing/campaign/campaign-artifact.d.ts

@@ -0,0 +1,20 @@
+import { CampaignMetrics } from "./campaign-metrics.js";
+export interface CampaignReplayArtifact {
+    readonly actions: readonly Readonly<Record<string, unknown>>[];
+    readonly fingerprint: string;
+    readonly metrics: CampaignMetrics;
+    readonly numRuns: number;
+    readonly numShrinks: number;
+    readonly schemaVersion: 1;
+    readonly seed?: number;
+    readonly counterexamplePath?: string;
+    readonly [key: string]: unknown;
+}
+export declare function createCampaignFingerprint(value: unknown): string;
+export declare function serializeCampaignReplayArtifact(artifact: CampaignReplayArtifact): string;
+export declare function selectCampaignCounterexampleTrace<T>(details: {
+    readonly failed: boolean;
+    readonly counterexampleKey?: string;
+}, traces: ReadonlyMap<string, T>): T;
+export declare function writeCampaignReplayArtifactAsync(filename: string, artifact: CampaignReplayArtifact): Promise<void>;
+export declare function loadCampaignReplayArtifactAsync(filename: string, fingerprint: string): Promise<CampaignReplayArtifact>;

package/dist/testing/campaign/campaign-artifact.js

@@ -0,0 +1,147 @@
+import { createHash } from "node:crypto";
+import { chmod, lstat, mkdir, open, readFile } from "node:fs/promises";
+import { dirname, parse, relative, resolve, sep } from "node:path";
+export function createCampaignFingerprint(value) {
+    return createHash("sha256")
+        .update(canonicalCampaignJson(value))
+        .digest("hex");
+}
+export function serializeCampaignReplayArtifact(artifact) {
+    return `${JSON.stringify({
+        schemaVersion: artifact.schemaVersion,
+        fingerprint: artifact.fingerprint,
+        actions: artifact.actions.map((action) => ({
+            ...(typeof action.targetKey === "string"
+                ? { targetKey: action.targetKey }
+                : {}),
+            ...(typeof action.actor === "string" ? { actor: action.actor } : {}),
+            ...(typeof action.outcome === "string"
+                ? { outcome: action.outcome }
+                : {}),
+        })),
+        metrics: artifact.metrics,
+        numRuns: artifact.numRuns,
+        numShrinks: artifact.numShrinks,
+        ...(artifact.seed === undefined ? {} : { seed: artifact.seed }),
+        ...(artifact.counterexamplePath === undefined
+            ? {}
+            : { counterexamplePath: artifact.counterexamplePath }),
+    })}\n`;
+}
+export function selectCampaignCounterexampleTrace(details, traces) {
+    if (!details.failed || details.counterexampleKey === undefined) {
+        throw new Error("Invariant campaign did not produce a counterexample.");
+    }
+    const trace = traces.get(details.counterexampleKey);
+    if (trace === undefined) {
+        throw new Error("Final invariant campaign counterexample has no trace.");
+    }
+    return trace;
+}
+export async function writeCampaignReplayArtifactAsync(filename, artifact) {
+    const destination = resolve(filename);
+    await ensureSecureDirectoryAsync(dirname(destination));
+    const handle = await open(destination, "wx", 0o600);
+    try {
+        await handle.writeFile(serializeCampaignReplayArtifact(artifact), "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function loadCampaignReplayArtifactAsync(filename, fingerprint) {
+    const artifact = JSON.parse(await readFile(resolve(filename), "utf8"));
+    if (!isCampaignReplayArtifact(artifact)) {
+        throw new Error("Invariant campaign replay artifact has an invalid schema.");
+    }
+    else if (artifact.fingerprint !== fingerprint) {
+        throw new Error("Invariant campaign replay artifact fingerprint does not match.");
+    }
+    return artifact;
+}
+function canonicalCampaignJson(value) {
+    return JSON.stringify(sortJsonValue(value));
+}
+function sortJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJsonValue);
+    }
+    else if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, nested]) => [key, sortJsonValue(nested)]));
+    }
+    return value;
+}
+function isCampaignReplayArtifact(value) {
+    return value !== null
+        && typeof value === "object"
+        && value.schemaVersion === 1
+        && typeof value.fingerprint === "string"
+        && Array.isArray(value.actions)
+        && value.actions.every(isReplayAction)
+        && isCampaignMetrics(value.metrics)
+        && isPositiveSafeInteger(value.numRuns)
+        && isNonNegativeSafeInteger(value.numShrinks);
+}
+function isReplayAction(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const action = value;
+    const allowedKeys = new Set(["actor", "outcome", "targetKey"]);
+    return Object.entries(action).every(([key, field]) => allowedKeys.has(key) && typeof field === "string");
+}
+function isPositiveSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isCampaignMetrics(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return isMetricGroup(candidate.byActor) && isMetricGroup(candidate.byTarget);
+}
+function isMetricGroup(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).every((outcomes) => outcomes !== null
+        && typeof outcomes === "object"
+        && !Array.isArray(outcomes)
+        && Object.values(outcomes).every((count) => typeof count === "number" && Number.isSafeInteger(count) && count >= 0));
+}
+async function ensureSecureDirectoryAsync(directory) {
+    const absoluteDirectory = resolve(directory);
+    const root = parse(absoluteDirectory).root;
+    const segments = relative(root, absoluteDirectory).split(sep).filter(Boolean);
+    let current = root;
+    for (const segment of segments) {
+        current = resolve(current, segment);
+        try {
+            const entry = await lstat(current);
+            if (entry.isSymbolicLink()) {
+                throw new Error(`Invariant campaign artifact parent is a symlink: ${current}`);
+            }
+            else if (!entry.isDirectory()) {
+                throw new Error(`Invariant campaign artifact parent is not a directory: ${current}`);
+            }
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+            await mkdir(current, { mode: 0o700 });
+        }
+    }
+    await chmod(absoluteDirectory, 0o700);
+}
+function isNotFoundError(error) {
+    return typeof error === "object"
+        && error !== null
+        && error.code === "ENOENT";
+}

package/dist/testing/campaign/campaign-definition.d.ts

@@ -0,0 +1,9 @@
+import { CampaignHandler } from "../handlers/handler.js";
+import { CampaignInvariant, CampaignRuntime, CampaignTarget, InvariantCampaign, InvariantCampaignConfig } from "./campaign-types.js";
+export declare function defineInvariantCampaign<Model = unknown, Ghost = unknown>(init: {
+    readonly runtime: CampaignRuntime;
+    readonly config: InvariantCampaignConfig;
+    readonly handlers?: readonly CampaignHandler[];
+    readonly targets: readonly CampaignTarget[];
+    readonly invariants: readonly CampaignInvariant<Model, Ghost>[];
+}): InvariantCampaign<Model, Ghost>;