@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/com/digitalasset/canton/protocol/v30/sequencing_parameters.d.ts

@@ -0,0 +1,30 @@
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * @generated from protobuf message com.digitalasset.canton.protocol.v30.DynamicSequencingParameters
+ */
+export interface DynamicSequencingParameters {
+    /**
+     * Sequencing dynamic synchronizer parameters can only be interpreted by a sequencer implementation
+     *  and are opaque to the rest of the synchronizer.
+     *
+     * @generated from protobuf field: bytes payload = 1
+     */
+    payload: Uint8Array;
+}
+declare class DynamicSequencingParameters$Type extends MessageType<DynamicSequencingParameters> {
+    constructor();
+    create(value?: PartialMessage<DynamicSequencingParameters>): DynamicSequencingParameters;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DynamicSequencingParameters): DynamicSequencingParameters;
+    internalBinaryWrite(message: DynamicSequencingParameters, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.DynamicSequencingParameters
+ */
+export declare const DynamicSequencingParameters: DynamicSequencingParameters$Type;
+export {};
+//# sourceMappingURL=sequencing_parameters.d.ts.map

package/dist/_proto/com/digitalasset/canton/protocol/v30/sequencing_parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencing_parameters.d.ts","sourceRoot":"","sources":["../../../../../../../src/_proto/com/digitalasset/canton/protocol/v30/sequencing_parameters.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD;;GAEG;AACH,MAAM,WAAW,2BAA2B;IACxC;;;;;OAKG;IACH,OAAO,EAAE,UAAU,CAAA;CACtB;AAED,cAAM,gCAAiC,SAAQ,WAAW,CAAC,2BAA2B,CAAC;;IAqBnF,MAAM,CACF,KAAK,CAAC,EAAE,cAAc,CAAC,2BAA2B,CAAC,GACpD,2BAA2B;IAW9B,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,2BAA2B,GACrC,2BAA2B;IA4B9B,mBAAmB,CACf,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CAanB;AACD;;GAEG;AACH,eAAO,MAAM,2BAA2B,kCACE,CAAA"}

package/dist/_proto/com/digitalasset/canton/protocol/v30/sequencing_parameters.js

@@ -0,0 +1,62 @@
+import { WireType } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+// @generated message type with reflection information, may provide speed optimized methods
+class DynamicSequencingParameters$Type extends MessageType {
+    constructor() {
+        super('com.digitalasset.canton.protocol.v30.DynamicSequencingParameters', [
+            {
+                no: 1,
+                name: 'payload',
+                kind: 'scalar',
+                T: 12 /*ScalarType.BYTES*/,
+            },
+        ], {
+            'scalapb.message': {
+                companionExtends: [
+                    'com.digitalasset.canton.version.StableProtoVersion',
+                ],
+            },
+        });
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.payload = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes payload */ 1:
+                    message.payload = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bytes payload = 1; */
+        if (message.payload.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.payload);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.DynamicSequencingParameters
+ */
+export const DynamicSequencingParameters = new DynamicSequencingParameters$Type();

package/dist/_proto/com/digitalasset/canton/protocol/v30/synchronizer_parameters.d.ts

@@ -0,0 +1,168 @@
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+import { TrafficControlParameters } from './traffic_control_parameters.js';
+import { Duration } from '../../../../../google/protobuf/duration.js';
+/**
+ * catch-up configuration parameters
+ *
+ * @generated from protobuf message com.digitalasset.canton.protocol.v30.AcsCommitmentsCatchUpConfig
+ */
+export interface AcsCommitmentsCatchUpConfig {
+    /**
+     * @generated from protobuf field: uint32 catchup_interval_skip = 1
+     */
+    catchupIntervalSkip: number;
+    /**
+     * @generated from protobuf field: uint32 nr_intervals_to_trigger_catchup = 2
+     */
+    nrIntervalsToTriggerCatchup: number;
+}
+/**
+ * individual per participant limits
+ *
+ * @generated from protobuf message com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits
+ */
+export interface ParticipantSynchronizerLimits {
+    /**
+     * @generated from protobuf field: uint32 confirmation_requests_max_rate = 1
+     */
+    confirmationRequestsMaxRate: number;
+}
+/**
+ * @generated from protobuf message com.digitalasset.canton.protocol.v30.DynamicSynchronizerParameters
+ */
+export interface DynamicSynchronizerParameters {
+    /**
+     * @generated from protobuf field: google.protobuf.Duration confirmation_response_timeout = 1
+     */
+    confirmationResponseTimeout?: Duration;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration mediator_reaction_timeout = 2
+     */
+    mediatorReactionTimeout?: Duration;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration assignment_exclusivity_timeout = 3
+     */
+    assignmentExclusivityTimeout?: Duration;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration topology_change_delay = 4
+     */
+    topologyChangeDelay?: Duration;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration ledger_time_record_time_tolerance = 5
+     */
+    ledgerTimeRecordTimeTolerance?: Duration;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration reconciliation_interval = 6
+     */
+    reconciliationInterval?: Duration;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration mediator_deduplication_timeout = 7
+     */
+    mediatorDeduplicationTimeout?: Duration;
+    /**
+     * @generated from protobuf field: uint32 max_request_size = 8
+     */
+    maxRequestSize: number;
+    /**
+     * topology related validation parameters
+     * permissioned synchronizer: if true, only participants which have been explicitly
+     * put on the allow list can onboard to the synchronizer
+     *
+     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.OnboardingRestriction onboarding_restriction = 9
+     */
+    onboardingRestriction: OnboardingRestriction;
+    /**
+     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits participant_synchronizer_limits = 13
+     */
+    participantSynchronizerLimits?: ParticipantSynchronizerLimits;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration sequencer_aggregate_submission_timeout = 15
+     */
+    sequencerAggregateSubmissionTimeout?: Duration;
+    /**
+     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.TrafficControlParameters traffic_control = 16
+     */
+    trafficControl?: TrafficControlParameters;
+    /**
+     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.AcsCommitmentsCatchUpConfig acs_commitments_catchup = 17
+     */
+    acsCommitmentsCatchup?: AcsCommitmentsCatchUpConfig;
+    /**
+     * @generated from protobuf field: google.protobuf.Duration preparation_time_record_time_tolerance = 18
+     */
+    preparationTimeRecordTimeTolerance?: Duration;
+}
+/**
+ * Controls how participants can join the synchronizer
+ * Note that currently, only transitions from restricted to unrestricted are supported, but not
+ * the other way around.
+ *
+ * @generated from protobuf enum com.digitalasset.canton.protocol.v30.OnboardingRestriction
+ */
+export declare enum OnboardingRestriction {
+    /**
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Any participant can join the synchronizer
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_UNRESTRICTED_OPEN = 1;
+     */
+    UNRESTRICTED_OPEN = 1,
+    /**
+     * No participant can currently join the synchronizer
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_UNRESTRICTED_LOCKED = 2;
+     */
+    UNRESTRICTED_LOCKED = 2,
+    /**
+     * Only participants with a valid participant synchronizer permission are allowed to join the synchronizer (allowlisting)
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_RESTRICTED_OPEN = 3;
+     */
+    RESTRICTED_OPEN = 3,
+    /**
+     * No participant can currently join the restricted synchronizer
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_RESTRICTED_LOCKED = 4;
+     */
+    RESTRICTED_LOCKED = 4
+}
+declare class AcsCommitmentsCatchUpConfig$Type extends MessageType<AcsCommitmentsCatchUpConfig> {
+    constructor();
+    create(value?: PartialMessage<AcsCommitmentsCatchUpConfig>): AcsCommitmentsCatchUpConfig;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AcsCommitmentsCatchUpConfig): AcsCommitmentsCatchUpConfig;
+    internalBinaryWrite(message: AcsCommitmentsCatchUpConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.AcsCommitmentsCatchUpConfig
+ */
+export declare const AcsCommitmentsCatchUpConfig: AcsCommitmentsCatchUpConfig$Type;
+declare class ParticipantSynchronizerLimits$Type extends MessageType<ParticipantSynchronizerLimits> {
+    constructor();
+    create(value?: PartialMessage<ParticipantSynchronizerLimits>): ParticipantSynchronizerLimits;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParticipantSynchronizerLimits): ParticipantSynchronizerLimits;
+    internalBinaryWrite(message: ParticipantSynchronizerLimits, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits
+ */
+export declare const ParticipantSynchronizerLimits: ParticipantSynchronizerLimits$Type;
+declare class DynamicSynchronizerParameters$Type extends MessageType<DynamicSynchronizerParameters> {
+    constructor();
+    create(value?: PartialMessage<DynamicSynchronizerParameters>): DynamicSynchronizerParameters;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DynamicSynchronizerParameters): DynamicSynchronizerParameters;
+    internalBinaryWrite(message: DynamicSynchronizerParameters, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.DynamicSynchronizerParameters
+ */
+export declare const DynamicSynchronizerParameters: DynamicSynchronizerParameters$Type;
+export {};
+//# sourceMappingURL=synchronizer_parameters.d.ts.map

package/dist/_proto/com/digitalasset/canton/protocol/v30/synchronizer_parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer_parameters.d.ts","sourceRoot":"","sources":["../../../../../../../src/_proto/com/digitalasset/canton/protocol/v30/synchronizer_parameters.ts"],"names":[],"mappings":"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"}

package/dist/_proto/com/digitalasset/canton/protocol/v30/synchronizer_parameters.js

@@ -0,0 +1,395 @@
+import { WireType } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+import { TrafficControlParameters } from './traffic_control_parameters.js';
+import { Duration } from '../../../../../google/protobuf/duration.js';
+/**
+ * Controls how participants can join the synchronizer
+ * Note that currently, only transitions from restricted to unrestricted are supported, but not
+ * the other way around.
+ *
+ * @generated from protobuf enum com.digitalasset.canton.protocol.v30.OnboardingRestriction
+ */
+export var OnboardingRestriction;
+(function (OnboardingRestriction) {
+    /**
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_UNSPECIFIED = 0;
+     */
+    OnboardingRestriction[OnboardingRestriction["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * Any participant can join the synchronizer
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_UNRESTRICTED_OPEN = 1;
+     */
+    OnboardingRestriction[OnboardingRestriction["UNRESTRICTED_OPEN"] = 1] = "UNRESTRICTED_OPEN";
+    /**
+     * No participant can currently join the synchronizer
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_UNRESTRICTED_LOCKED = 2;
+     */
+    OnboardingRestriction[OnboardingRestriction["UNRESTRICTED_LOCKED"] = 2] = "UNRESTRICTED_LOCKED";
+    /**
+     * Only participants with a valid participant synchronizer permission are allowed to join the synchronizer (allowlisting)
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_RESTRICTED_OPEN = 3;
+     */
+    OnboardingRestriction[OnboardingRestriction["RESTRICTED_OPEN"] = 3] = "RESTRICTED_OPEN";
+    /**
+     * No participant can currently join the restricted synchronizer
+     *
+     * @generated from protobuf enum value: ONBOARDING_RESTRICTION_RESTRICTED_LOCKED = 4;
+     */
+    OnboardingRestriction[OnboardingRestriction["RESTRICTED_LOCKED"] = 4] = "RESTRICTED_LOCKED";
+})(OnboardingRestriction || (OnboardingRestriction = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class AcsCommitmentsCatchUpConfig$Type extends MessageType {
+    constructor() {
+        super('com.digitalasset.canton.protocol.v30.AcsCommitmentsCatchUpConfig', [
+            {
+                no: 1,
+                name: 'catchup_interval_skip',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+            {
+                no: 2,
+                name: 'nr_intervals_to_trigger_catchup',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.catchupIntervalSkip = 0;
+        message.nrIntervalsToTriggerCatchup = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 catchup_interval_skip */ 1:
+                    message.catchupIntervalSkip = reader.uint32();
+                    break;
+                case /* uint32 nr_intervals_to_trigger_catchup */ 2:
+                    message.nrIntervalsToTriggerCatchup = reader.uint32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint32 catchup_interval_skip = 1; */
+        if (message.catchupIntervalSkip !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.catchupIntervalSkip);
+        /* uint32 nr_intervals_to_trigger_catchup = 2; */
+        if (message.nrIntervalsToTriggerCatchup !== 0)
+            writer
+                .tag(2, WireType.Varint)
+                .uint32(message.nrIntervalsToTriggerCatchup);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.AcsCommitmentsCatchUpConfig
+ */
+export const AcsCommitmentsCatchUpConfig = new AcsCommitmentsCatchUpConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ParticipantSynchronizerLimits$Type extends MessageType {
+    constructor() {
+        super('com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits', [
+            {
+                no: 1,
+                name: 'confirmation_requests_max_rate',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.confirmationRequestsMaxRate = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 confirmation_requests_max_rate */ 1:
+                    message.confirmationRequestsMaxRate = reader.uint32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint32 confirmation_requests_max_rate = 1; */
+        if (message.confirmationRequestsMaxRate !== 0)
+            writer
+                .tag(1, WireType.Varint)
+                .uint32(message.confirmationRequestsMaxRate);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits
+ */
+export const ParticipantSynchronizerLimits = new ParticipantSynchronizerLimits$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DynamicSynchronizerParameters$Type extends MessageType {
+    constructor() {
+        super('com.digitalasset.canton.protocol.v30.DynamicSynchronizerParameters', [
+            {
+                no: 1,
+                name: 'confirmation_response_timeout',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 2,
+                name: 'mediator_reaction_timeout',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 3,
+                name: 'assignment_exclusivity_timeout',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 4,
+                name: 'topology_change_delay',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 5,
+                name: 'ledger_time_record_time_tolerance',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 6,
+                name: 'reconciliation_interval',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 7,
+                name: 'mediator_deduplication_timeout',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 8,
+                name: 'max_request_size',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+            {
+                no: 9,
+                name: 'onboarding_restriction',
+                kind: 'enum',
+                T: () => [
+                    'com.digitalasset.canton.protocol.v30.OnboardingRestriction',
+                    OnboardingRestriction,
+                    'ONBOARDING_RESTRICTION_',
+                ],
+            },
+            {
+                no: 13,
+                name: 'participant_synchronizer_limits',
+                kind: 'message',
+                T: () => ParticipantSynchronizerLimits,
+            },
+            {
+                no: 15,
+                name: 'sequencer_aggregate_submission_timeout',
+                kind: 'message',
+                T: () => Duration,
+            },
+            {
+                no: 16,
+                name: 'traffic_control',
+                kind: 'message',
+                T: () => TrafficControlParameters,
+            },
+            {
+                no: 17,
+                name: 'acs_commitments_catchup',
+                kind: 'message',
+                T: () => AcsCommitmentsCatchUpConfig,
+            },
+            {
+                no: 18,
+                name: 'preparation_time_record_time_tolerance',
+                kind: 'message',
+                T: () => Duration,
+            },
+        ], {
+            'scalapb.message': {
+                companionExtends: [
+                    'com.digitalasset.canton.version.StableProtoVersion',
+                ],
+            },
+        });
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.maxRequestSize = 0;
+        message.onboardingRestriction = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.Duration confirmation_response_timeout */ 1:
+                    message.confirmationResponseTimeout =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.confirmationResponseTimeout);
+                    break;
+                case /* google.protobuf.Duration mediator_reaction_timeout */ 2:
+                    message.mediatorReactionTimeout =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.mediatorReactionTimeout);
+                    break;
+                case /* google.protobuf.Duration assignment_exclusivity_timeout */ 3:
+                    message.assignmentExclusivityTimeout =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.assignmentExclusivityTimeout);
+                    break;
+                case /* google.protobuf.Duration topology_change_delay */ 4:
+                    message.topologyChangeDelay = Duration.internalBinaryRead(reader, reader.uint32(), options, message.topologyChangeDelay);
+                    break;
+                case /* google.protobuf.Duration ledger_time_record_time_tolerance */ 5:
+                    message.ledgerTimeRecordTimeTolerance =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.ledgerTimeRecordTimeTolerance);
+                    break;
+                case /* google.protobuf.Duration reconciliation_interval */ 6:
+                    message.reconciliationInterval =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.reconciliationInterval);
+                    break;
+                case /* google.protobuf.Duration mediator_deduplication_timeout */ 7:
+                    message.mediatorDeduplicationTimeout =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.mediatorDeduplicationTimeout);
+                    break;
+                case /* uint32 max_request_size */ 8:
+                    message.maxRequestSize = reader.uint32();
+                    break;
+                case /* com.digitalasset.canton.protocol.v30.OnboardingRestriction onboarding_restriction */ 9:
+                    message.onboardingRestriction = reader.int32();
+                    break;
+                case /* com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits participant_synchronizer_limits */ 13:
+                    message.participantSynchronizerLimits =
+                        ParticipantSynchronizerLimits.internalBinaryRead(reader, reader.uint32(), options, message.participantSynchronizerLimits);
+                    break;
+                case /* google.protobuf.Duration sequencer_aggregate_submission_timeout */ 15:
+                    message.sequencerAggregateSubmissionTimeout =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.sequencerAggregateSubmissionTimeout);
+                    break;
+                case /* com.digitalasset.canton.protocol.v30.TrafficControlParameters traffic_control */ 16:
+                    message.trafficControl =
+                        TrafficControlParameters.internalBinaryRead(reader, reader.uint32(), options, message.trafficControl);
+                    break;
+                case /* com.digitalasset.canton.protocol.v30.AcsCommitmentsCatchUpConfig acs_commitments_catchup */ 17:
+                    message.acsCommitmentsCatchup =
+                        AcsCommitmentsCatchUpConfig.internalBinaryRead(reader, reader.uint32(), options, message.acsCommitmentsCatchup);
+                    break;
+                case /* google.protobuf.Duration preparation_time_record_time_tolerance */ 18:
+                    message.preparationTimeRecordTimeTolerance =
+                        Duration.internalBinaryRead(reader, reader.uint32(), options, message.preparationTimeRecordTimeTolerance);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* google.protobuf.Duration confirmation_response_timeout = 1; */
+        if (message.confirmationResponseTimeout)
+            Duration.internalBinaryWrite(message.confirmationResponseTimeout, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration mediator_reaction_timeout = 2; */
+        if (message.mediatorReactionTimeout)
+            Duration.internalBinaryWrite(message.mediatorReactionTimeout, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration assignment_exclusivity_timeout = 3; */
+        if (message.assignmentExclusivityTimeout)
+            Duration.internalBinaryWrite(message.assignmentExclusivityTimeout, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration topology_change_delay = 4; */
+        if (message.topologyChangeDelay)
+            Duration.internalBinaryWrite(message.topologyChangeDelay, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration ledger_time_record_time_tolerance = 5; */
+        if (message.ledgerTimeRecordTimeTolerance)
+            Duration.internalBinaryWrite(message.ledgerTimeRecordTimeTolerance, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration reconciliation_interval = 6; */
+        if (message.reconciliationInterval)
+            Duration.internalBinaryWrite(message.reconciliationInterval, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration mediator_deduplication_timeout = 7; */
+        if (message.mediatorDeduplicationTimeout)
+            Duration.internalBinaryWrite(message.mediatorDeduplicationTimeout, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* uint32 max_request_size = 8; */
+        if (message.maxRequestSize !== 0)
+            writer.tag(8, WireType.Varint).uint32(message.maxRequestSize);
+        /* com.digitalasset.canton.protocol.v30.OnboardingRestriction onboarding_restriction = 9; */
+        if (message.onboardingRestriction !== 0)
+            writer.tag(9, WireType.Varint).int32(message.onboardingRestriction);
+        /* com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits participant_synchronizer_limits = 13; */
+        if (message.participantSynchronizerLimits)
+            ParticipantSynchronizerLimits.internalBinaryWrite(message.participantSynchronizerLimits, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration sequencer_aggregate_submission_timeout = 15; */
+        if (message.sequencerAggregateSubmissionTimeout)
+            Duration.internalBinaryWrite(message.sequencerAggregateSubmissionTimeout, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
+        /* com.digitalasset.canton.protocol.v30.TrafficControlParameters traffic_control = 16; */
+        if (message.trafficControl)
+            TrafficControlParameters.internalBinaryWrite(message.trafficControl, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
+        /* com.digitalasset.canton.protocol.v30.AcsCommitmentsCatchUpConfig acs_commitments_catchup = 17; */
+        if (message.acsCommitmentsCatchup)
+            AcsCommitmentsCatchUpConfig.internalBinaryWrite(message.acsCommitmentsCatchup, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Duration preparation_time_record_time_tolerance = 18; */
+        if (message.preparationTimeRecordTimeTolerance)
+            Duration.internalBinaryWrite(message.preparationTimeRecordTimeTolerance, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.DynamicSynchronizerParameters
+ */
+export const DynamicSynchronizerParameters = new DynamicSynchronizerParameters$Type();