@distrohelena/canton-typescript-sdk 0.1.5 → 0.1.6

package/dist/testing/runtime/declarative-action-executor.js

@@ -0,0 +1,41 @@
+import { CreateCommand } from "../../core/types/commands/create-command.js";
+import { ExerciseCommand } from "../../core/types/commands/exercise-command.js";
+import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
+import { TestingConfigurationError } from "../errors/testing-configuration-error.js";
+import { toCampaignMetricOutcome, } from "./canton-test-runtime.js";
+/**
+ * Converts a generated declarative action into SDK command types and submits
+ * it over the actor's configured Canton route. Choice actions deliberately
+ * require an explicit contract resolver: the testing SDK never guesses an
+ * active contract ID from stale local state.
+ */
+export async function executeDeclarativeActionAsync(init) {
+    const route = init.runtime.resolveRoute(init.action.actor);
+    const command = "choice" in init.action
+        ? await createExerciseCommandAsync(init.action, init.resolveContractIdAsync)
+        : new CreateCommand({
+            templateId: init.action.templateId,
+            payload: { ...init.action.payload },
+        });
+    return toCampaignMetricOutcome(await init.runtime.submitAndWaitAsync(init.action.actor, new SubmitCommandRequest({
+        applicationId: init.applicationId,
+        actAs: route.actAs,
+        readAs: route.readAs,
+        command,
+    })));
+}
+async function createExerciseCommandAsync(action, resolveContractIdAsync) {
+    if (resolveContractIdAsync === undefined) {
+        throw new TestingConfigurationError(`Declarative choice target '${action.targetKey}' requires resolveContractIdAsync.`);
+    }
+    const contractId = await resolveContractIdAsync(action);
+    if (contractId.length === 0) {
+        throw new TestingConfigurationError(`Declarative choice target '${action.targetKey}' resolved an empty contract ID.`);
+    }
+    return new ExerciseCommand({
+        templateId: action.templateId,
+        contractId,
+        choice: action.choice,
+        argument: action.argument,
+    });
+}

package/dist/testing/targets/target.d.ts

@@ -0,0 +1,49 @@
+import { DamlTestingCatalog } from "../daml/daml-testing-catalog.js";
+export interface TemplateTarget {
+    readonly allChoices?: true;
+    readonly actors: readonly string[];
+    readonly choices: readonly string[];
+    readonly kind: "template";
+    readonly templateId: string;
+}
+export interface TemplateCreateTarget {
+    readonly actors: readonly string[];
+    readonly kind: "template-create";
+    readonly templateId: string;
+}
+export interface ExcludedChoiceTarget {
+    readonly choice: string;
+    readonly kind: "exclude-choice";
+    readonly templateId: string;
+}
+export interface ExcludedTemplateTarget {
+    readonly kind: "exclude-template";
+    readonly templateId: string;
+}
+export interface TemplateTargetBuilder {
+    allChoices(): TemplateTarget;
+    actors(actors: readonly string[]): TemplateTargetBuilder;
+    choice(choice: string): TemplateTarget;
+    create(): TemplateCreateTarget;
+}
+export interface ResolvedDeclarativeChoiceTarget {
+    readonly actors: readonly string[];
+    readonly choice: string;
+    readonly key: string;
+    readonly templateId: string;
+}
+export interface ResolvedDeclarativeCreateTarget {
+    readonly actors: readonly string[];
+    readonly key: string;
+    readonly kind: "create";
+    readonly templateId: string;
+}
+export type ResolvedDeclarativeTarget = ResolvedDeclarativeChoiceTarget | ResolvedDeclarativeCreateTarget;
+export declare function targetTemplate(templateId: string): TemplateTargetBuilder;
+/** Builds one immutable declarative template-choice target without a builder chain. */
+export declare function targetChoice(templateId: string, choice: string, actors: readonly string[]): TemplateTarget;
+/** Builds one immutable declarative contract-create target without a builder chain. */
+export declare function targetCreate(templateId: string, actors: readonly string[]): TemplateCreateTarget;
+export declare function excludeChoice(templateId: string, choice: string): ExcludedChoiceTarget;
+export declare function excludeTemplate(templateId: string): ExcludedTemplateTarget;
+export declare function resolveDeclarativeTargets(catalog: DamlTestingCatalog, descriptors: readonly (TemplateTarget | TemplateCreateTarget | ExcludedChoiceTarget | ExcludedTemplateTarget)[]): readonly ResolvedDeclarativeTarget[];

package/dist/testing/targets/target.js

@@ -0,0 +1,121 @@
+import { TestingConfigurationError } from "../errors/testing-configuration-error.js";
+export function targetTemplate(templateId) {
+    let actors = [];
+    return Object.freeze({
+        allChoices() {
+            return Object.freeze({
+                kind: "template",
+                templateId,
+                actors,
+                choices: Object.freeze([]),
+                allChoices: true,
+            });
+        },
+        actors(value) {
+            actors = Object.freeze([...value]);
+            return this;
+        },
+        choice(choice) {
+            return Object.freeze({
+                kind: "template",
+                templateId,
+                actors,
+                choices: Object.freeze([choice]),
+            });
+        },
+        create() {
+            return Object.freeze({
+                kind: "template-create",
+                templateId,
+                actors,
+            });
+        },
+    });
+}
+/** Builds one immutable declarative template-choice target without a builder chain. */
+export function targetChoice(templateId, choice, actors) {
+    return Object.freeze({
+        kind: "template",
+        templateId,
+        actors: Object.freeze([...actors]),
+        choices: Object.freeze([choice]),
+    });
+}
+/** Builds one immutable declarative contract-create target without a builder chain. */
+export function targetCreate(templateId, actors) {
+    return Object.freeze({
+        kind: "template-create",
+        templateId,
+        actors: Object.freeze([...actors]),
+    });
+}
+export function excludeChoice(templateId, choice) {
+    return Object.freeze({
+        kind: "exclude-choice",
+        templateId,
+        choice,
+    });
+}
+export function excludeTemplate(templateId) {
+    return Object.freeze({
+        kind: "exclude-template",
+        templateId,
+    });
+}
+export function resolveDeclarativeTargets(catalog, descriptors) {
+    for (const descriptor of descriptors) {
+        if (descriptor.kind === "template") {
+            continue;
+        }
+        const template = catalog.getTemplate(descriptor.templateId);
+        if (template === undefined) {
+            throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}' is absent from the DAML catalog.`);
+        }
+        else if (descriptor.kind === "exclude-choice"
+            && !template.choices.includes(descriptor.choice)) {
+            throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}:${descriptor.choice}' is absent from the DAML catalog.`);
+        }
+    }
+    const excludedTemplates = new Set(descriptors
+        .filter((descriptor) => descriptor.kind === "exclude-template")
+        .map((descriptor) => descriptor.templateId));
+    const excluded = new Set(descriptors
+        .filter((descriptor) => descriptor.kind === "exclude-choice")
+        .map((descriptor) => `${descriptor.templateId}:${descriptor.choice}`));
+    return descriptors
+        .filter((descriptor) => descriptor.kind === "template" || descriptor.kind === "template-create")
+        .flatMap((descriptor) => {
+        const template = catalog.getTemplate(descriptor.templateId);
+        if (template === undefined) {
+            throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}' is absent from the DAML catalog.`);
+        }
+        else if (descriptor.kind === "template-create") {
+            return [Object.freeze({
+                    key: `${descriptor.templateId}:create`,
+                    templateId: descriptor.templateId,
+                    actors: descriptor.actors,
+                    kind: "create",
+                })];
+        }
+        else {
+            if (descriptor.allChoices === true && excludedTemplates.has(descriptor.templateId)) {
+                return [];
+            }
+            const choices = (descriptor.allChoices === true
+                ? template.choices.filter((choice) => !excluded.has(`${descriptor.templateId}:${choice}`))
+                : descriptor.choices);
+            const missingChoice = choices.find((choice) => !template.choices.includes(choice));
+            if (missingChoice !== undefined) {
+                throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}:${missingChoice}' is absent from the DAML catalog.`);
+            }
+            return choices
+                .map((choice) => Object.freeze({
+                key: `${descriptor.templateId}:${choice}`,
+                templateId: descriptor.templateId,
+                choice,
+                actors: descriptor.actors,
+            }));
+        }
+    })
+        .sort((left, right) => left.key.localeCompare(right.key));
+}

package/dist/transports/grpc/grpc-channel-factory.js

@@ -1,4 +1,5 @@
 import { GrpcTransport as ProtobufGrpcTransport } from "@protobuf-ts/grpc-transport";
+import { GrpcTransportError } from "../../core/errors/grpc-transport-error.js";
 import { PackageServiceClient as ParticipantPackageServiceClient, } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/package_service.client.js";
 import { PartyManagementServiceClient as ParticipantPartyManagementServiceClient, } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/party_management_service.client.js";
 import { ParticipantInspectionServiceClient, } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_inspection_service.client.js";
@@ -90,7 +91,7 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
         ?? new InteractiveSubmissionServiceClient(rpcTransport);
     const commandServiceClient = dependencies.commandServiceClient
         ?? new CommandServiceClient(rpcTransport);
-    return {
+    const operations = {
         async disposeAsync() {
             rpcTransport.close();
         },
@@ -471,6 +472,7 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             return await unwrapUnaryResponse(interactiveSubmissionServiceClient.executeSubmissionAndWait(request, callOptions));
         },
     };
+    return wrapGrpcOperations(operations, options.onGrpcError);
 }
 async function buildCallOptionsForLedgerSurfaceAsync(options, requestOptions) {
     return buildGrpcCallOptionsAsync(options.ledgerAuthProvider, options.defaultRequestTimeoutMs, requestOptions);
@@ -487,6 +489,34 @@ function normalizeGrpcHost(endpoint) {
     }
     return endpoint;
 }
+function wrapGrpcOperations(operations, onGrpcError) {
+    return new Proxy(operations, {
+        get(target, property, receiver) {
+            const operation = Reflect.get(target, property, receiver);
+            if (typeof operation !== "function") {
+                return operation;
+            }
+            return async (...args) => {
+                try {
+                    return await operation.apply(target, args);
+                }
+                catch (error) {
+                    const parsedError = GrpcTransportError.fromUnknown(error);
+                    if (parsedError === undefined) {
+                        throw error;
+                    }
+                    try {
+                        onGrpcError?.(parsedError);
+                    }
+                    catch {
+                        // Error observers must not replace the RPC failure.
+                    }
+                    throw parsedError;
+                }
+            };
+        },
+    });
+}
 async function unwrapUnaryResponse(call) {
     return await call.response;
 }

package/dist/transports/grpc/grpc-transport.js

@@ -500,6 +500,8 @@ export class GrpcTransport {
         this.throwIfDisposed();
         const payload = await this.operations.queryContractsAsync(mapGrpcQueryContractsRequest({
             party: request.party,
+            parties: request.parties,
+            allParties: request.allParties,
             templateId: request.templateId,
             interfaceId: request.interfaceId,
             includeInterfaceView: request.includeInterfaceView,
@@ -581,13 +583,13 @@ export class GrpcTransport {
             const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandRequest(request), options);
             return mapGrpcSubmitCommand(payload);
         }
-        if (request.actAs.length !== 1) {
+        else if (request.actAs.length !== 1) {
             throw new ValidationError("interactive gRPC command signing currently requires exactly one actAs party");
         }
-        if (!this.operations.prepareSubmissionAsync) {
+        else if (!this.operations.prepareSubmissionAsync) {
             throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
         }
-        if (!this.operations.executeSubmissionAndWaitAsync) {
+        else if (!this.operations.executeSubmissionAndWaitAsync) {
             throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
         }
         const commandId = randomUUID();

package/dist/transports/grpc/mappers/commands-mapper.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { ValidationError } from "../../../core/errors/validation-error.js";
 import { CreateAndExerciseCommand } from "../../../core/types/commands/create-and-exercise-command.js";
 import { CreateCommand } from "../../../core/types/commands/create-command.js";
+import { DamlNumeric } from "../../../core/types/daml-numeric.js";
+import { DamlParty } from "../../../core/types/daml-party.js";
 import { ExerciseByKeyCommand } from "../../../core/types/commands/exercise-by-key-command.js";
 import { ExerciseCommand } from "../../../core/types/commands/exercise-command.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
@@ -106,6 +108,22 @@ export function mapValue(value) {
             },
         };
     }
+    else if (value instanceof DamlParty) {
+        return {
+            sum: {
+                oneofKind: "party",
+                party: value.value,
+            },
+        };
+    }
+    else if (value instanceof DamlNumeric) {
+        return {
+            sum: {
+                oneofKind: "numeric",
+                numeric: value.value,
+            },
+        };
+    }
     else if (typeof value === "string") {
         return {
             sum: {

package/dist/transports/grpc/mappers/contracts-mapper.d.ts

@@ -5,7 +5,9 @@ import { GetContractRequest as GrpcGetContractRequest } from "../generated/canto
 import { GetContractResponse as GrpcGetContractResponse } from "../generated/canton/com/daml/ledger/api/v2/contract_service.js";
 import { GetActiveContractsPageRequest } from "../generated/canton/com/daml/ledger/api/v2/state_service.js";
 export declare function mapGrpcQueryContractsRequest(request: {
-    party: string;
+    party?: string;
+    parties?: readonly string[];
+    allParties?: boolean;
     templateId?: string;
     interfaceId?: string;
     includeInterfaceView?: boolean;

package/dist/transports/grpc/mappers/contracts-mapper.js

@@ -30,10 +30,23 @@ export function mapGrpcGetContract(payload) {
     });
 }
 function createEventFormat(request) {
+    const filters = createFilters(request);
+    const parties = request.parties ?? (request.party === undefined ? [] : [request.party]);
+    if (request.allParties === true) {
+        if (parties.length > 0) {
+            throw new ValidationError("allParties cannot be combined with party filters");
+        }
+        return {
+            filtersByParty: {},
+            filtersForAnyParty: filters,
+            verbose: true,
+        };
+    }
+    else if (parties.length === 0) {
+        throw new ValidationError("A party filter or allParties is required");
+    }
     return {
-        filtersByParty: {
-            [request.party]: createFilters(request),
-        },
+        filtersByParty: Object.fromEntries(parties.map((party) => [party, filters])),
         verbose: true,
     };
 }

package/dist/transports/grpc/mappers/topology-manager-write-mapper.js

@@ -8,7 +8,9 @@ import { ImportTopologySnapshotResponse } from "../../../core/types/responses/im
 import { ImportTopologySnapshotV2Response } from "../../../core/types/responses/import-topology-snapshot-v2-response.js";
 import { SignTopologyTransactionsResponse } from "../../../core/types/responses/sign-topology-transactions-response.js";
 import { GeneratedTopologyTransaction } from "../../../core/types/topology/generated-topology-transaction.js";
+import { DecentralizedNamespaceDefinition } from "../../../core/types/topology/decentralized-namespace-definition.js";
 import { MultiTopologyTransactionSignature } from "../../../core/types/topology/multi-topology-transaction-signature.js";
+import { NamespaceDelegation, NamespaceDelegationRestrictionKind, } from "../../../core/types/topology/namespace-delegation.js";
 import { PartyToParticipant, PartyToParticipantOnboarding, } from "../../../core/types/topology/party-to-participant.js";
 import { SignedTopologyTransaction } from "../../../core/types/topology/signed-topology-transaction.js";
 import { TopologyForceFlag } from "../../../core/types/topology/topology-force-flag.js";
@@ -18,7 +20,7 @@ import { TopologyTransactionSignature } from "../../../core/types/topology/topol
 import { CryptoKeyFormat, SignatureFormat as GrpcSignatureFormat, SigningAlgorithmSpec, SigningKeyScheme, SigningKeySpec, SigningKeyUsage, } from "../generated/canton/com/digitalasset/canton/crypto/v30/crypto.js";
 import { ForceFlag, } from "../generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_write_service.js";
 import { Enums_ParticipantPermission, } from "../generated/canton/com/digitalasset/canton/protocol/v30/topology.js";
-import { mapGrpcTopologyChangeOp, mapGrpcTopologyStoreId, } from "./topology-common-mapper.js";
+import { mapGrpcTopologyChangeOp, mapGrpcTopologyMappingCode, mapGrpcTopologyStoreId, } from "./topology-common-mapper.js";
 export function mapGrpcGenerateTopologyTransactionsRequest(request) {
     return {
         proposals: request.proposals.map(mapGrpcGenerateTopologyTransactionsProposal),
@@ -155,8 +157,64 @@ function mapGrpcTopologyMapping(mapping) {
             },
         };
     }
+    else if (mapping instanceof DecentralizedNamespaceDefinition) {
+        return {
+            mapping: {
+                oneofKind: "decentralizedNamespaceDefinition",
+                decentralizedNamespaceDefinition: mapGrpcDecentralizedNamespaceDefinition(mapping),
+            },
+        };
+    }
+    else if (mapping instanceof NamespaceDelegation) {
+        return {
+            mapping: {
+                oneofKind: "namespaceDelegation",
+                namespaceDelegation: mapGrpcNamespaceDelegation(mapping),
+            },
+        };
+    }
     throw new ValidationError(`Unsupported topology write mapping type: ${mapping.constructor.name}.`);
 }
+function mapGrpcDecentralizedNamespaceDefinition(value) {
+    return {
+        decentralizedNamespace: value.decentralizedNamespace,
+        threshold: value.threshold,
+        owners: [...value.owners],
+    };
+}
+function mapGrpcNamespaceDelegation(value) {
+    return {
+        namespace: value.namespace,
+        targetKey: value.targetKey === undefined
+            ? undefined
+            : mapGrpcSigningPublicKey(value.targetKey),
+        isRootDelegation: value.isRootDelegation,
+        restriction: mapGrpcNamespaceDelegationRestriction(value),
+    };
+}
+function mapGrpcNamespaceDelegationRestriction(value) {
+    switch (value.restriction?.kind) {
+        case NamespaceDelegationRestrictionKind.canSignAllMappings:
+            return {
+                oneofKind: "canSignAllMappings",
+                canSignAllMappings: {},
+            };
+        case NamespaceDelegationRestrictionKind.canSignAllButNamespaceDelegations:
+            return {
+                oneofKind: "canSignAllButNamespaceDelegations",
+                canSignAllButNamespaceDelegations: {},
+            };
+        case NamespaceDelegationRestrictionKind.canSignSpecificMappings:
+            return {
+                oneofKind: "canSignSpecificMapings",
+                canSignSpecificMapings: {
+                    mappings: value.restriction.mappings.map(mapGrpcTopologyMappingCode),
+                },
+            };
+        default:
+            return { oneofKind: undefined };
+    }
+}
 function mapGrpcPartyToParticipant(value) {
     return {
         party: value.party,

package/dist/transports/json/mappers/commands-mapper.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { ValidationError } from "../../../core/errors/validation-error.js";
 import { CreateAndExerciseCommand } from "../../../core/types/commands/create-and-exercise-command.js";
 import { CreateCommand } from "../../../core/types/commands/create-command.js";
+import { DamlNumeric } from "../../../core/types/daml-numeric.js";
+import { DamlParty } from "../../../core/types/daml-party.js";
 import { ExerciseByKeyCommand } from "../../../core/types/commands/exercise-by-key-command.js";
 import { ExerciseCommand } from "../../../core/types/commands/exercise-command.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
@@ -28,7 +30,7 @@ function mapJsonCommand(command) {
         return {
             CreateCommand: {
                 templateId: command.templateId,
-                createArguments: command.payload,
+                createArguments: mapJsonValue(command.payload),
             },
         };
     }
@@ -38,7 +40,7 @@ function mapJsonCommand(command) {
                 templateId: command.templateId,
                 contractId: command.contractId,
                 choice: command.choice,
-                choiceArgument: command.argument,
+                choiceArgument: mapJsonValue(command.argument),
             },
         };
     }
@@ -46,9 +48,9 @@ function mapJsonCommand(command) {
         return {
             ExerciseByKeyCommand: {
                 templateId: command.templateId,
-                contractKey: command.contractKey,
+                contractKey: mapJsonValue(command.contractKey),
                 choice: command.choice,
-                choiceArgument: command.argument,
+                choiceArgument: mapJsonValue(command.argument),
             },
         };
     }
@@ -56,11 +58,23 @@ function mapJsonCommand(command) {
         return {
             CreateAndExerciseCommand: {
                 templateId: command.templateId,
-                createArguments: command.payload,
+                createArguments: mapJsonValue(command.payload),
                 choice: command.choice,
-                choiceArgument: command.argument,
+                choiceArgument: mapJsonValue(command.argument),
             },
         };
     }
     throw new ValidationError("unsupported submit command type");
 }
+function mapJsonValue(value) {
+    if (value instanceof DamlParty || value instanceof DamlNumeric) {
+        return value.value;
+    }
+    else if (Array.isArray(value)) {
+        return value.map(mapJsonValue);
+    }
+    else if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, mapJsonValue(item)]));
+    }
+    return value;
+}

package/node/.generated/start-local/additional-config.extra-participants.conf

@@ -0,0 +1,37 @@
+canton.participants.extra-1 = $${_participant} {
+  storage.config.properties.databaseName = "participant-extra-1"
+  init {
+    generate-topology-transactions-and-keys = true
+    identity.type = auto
+  }
+  monitoring {
+    http-health-server.port = ${EXTRA_PARTICIPANT_1_HTTP_HEALTHCHECK_PORT}
+    grpc-health-server.port = ${EXTRA_PARTICIPANT_1_GRPC_HEALTHCHECK_PORT}
+  }
+  http-ledger-api.port = ${EXTRA_PARTICIPANT_1_JSON_API_PORT}
+  admin-api.port = ${EXTRA_PARTICIPANT_1_ADMIN_API_PORT}
+  ledger-api.port = ${EXTRA_PARTICIPANT_1_LEDGER_API_PORT}
+  ledger-api {
+    auth-services = [{
+      type = unsafe-jwt-hmac-256
+      target-audience = "${EXTRA_VALIDATOR_1_AUTH_AUDIENCE}"
+      secret = "unsafe"
+    }]
+
+    user-management-service.additional-admin-user-id = "${EXTRA_VALIDATOR_1_USER_NAME}"
+  }
+}
+
+canton.participants.extra-1.ledger-api.auth-services = [
+  {
+    type = unsafe-jwt-hmac-256
+    target-audience = "https://canton.network.global"
+    secret = "unsafe"
+  },
+  {
+    type = jwt-es-256-crt
+    certificate = "/app/es256-certificate.pem"
+    target-audience = "https://canton.network.global/es256"
+  }
+]
+

package/node/.generated/start-local/additional-config.extra-validators.conf

@@ -0,0 +1,35 @@
+canton.validator-apps.extra-1-validator_backend = $${_validator_backend} {
+  onboarding.secret = "${EXTRA_VALIDATOR_1_ONBOARDING_SECRET}"
+  domain-migration-dump-path = "/domain-upgrade-dump/domain_migration_dump-extra-1.json"
+  storage.config.properties.databaseName = "${EXTRA_VALIDATOR_1_DB}"
+  admin-api.port = ${EXTRA_VALIDATOR_1_ADMIN_API_PORT}
+  canton-identifier-config.participant = extra-1
+  participant-client {
+    admin-api.port = ${EXTRA_PARTICIPANT_1_ADMIN_API_PORT}
+    ledger-api {
+      client-config.port = ${EXTRA_PARTICIPANT_1_LEDGER_API_PORT}
+      auth-config = {
+        type = "self-signed"
+        user = "${EXTRA_VALIDATOR_1_USER_NAME}"
+        audience = "${EXTRA_VALIDATOR_1_AUTH_AUDIENCE}"
+        secret = "unsafe"
+      }
+    }
+  }
+  auth = {
+    algorithm = "hs-256-unsafe"
+    audience = "${EXTRA_VALIDATOR_1_AUTH_AUDIENCE}"
+    secret = "unsafe"
+  }
+  ledger-api-user = "${EXTRA_VALIDATOR_1_USER_NAME}"
+  validator-wallet-users.0 = "${EXTRA_VALIDATOR_1_WALLET_ADMIN_USER_NAME}"
+  validator-party-hint = "${EXTRA_VALIDATOR_1_PARTY_HINT}"
+
+  domains.global.buy-extra-traffic {
+    min-topup-interval = ${?MIN_TRAFFIC_TOPUP_INTERVAL}
+    target-throughput = ${?TARGET_TRAFFIC_THROUGHPUT}
+  }
+}
+
+canton.sv-apps.sv.expected-validator-onboardings += { secret = "${EXTRA_VALIDATOR_1_ONBOARDING_SECRET}" }
+