@distrohelena/canton-typescript-sdk 0.1.0

package/dist/transports/grpc/generated/canton/com/digitalasset/canton/sequencer/api/v30/sequencer_service.client.d.ts

@@ -0,0 +1,272 @@
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import type { GetTimeResponse } from "./sequencer_service.js";
+import type { GetTimeRequest } from "./sequencer_service.js";
+import type { GetTrafficStateForMemberResponse } from "./sequencer_service.js";
+import type { GetTrafficStateForMemberRequest } from "./sequencer_service.js";
+import type { DownloadTopologyStateForInitHashResponse } from "./sequencer_service.js";
+import type { DownloadTopologyStateForInitHashRequest } from "./sequencer_service.js";
+import type { DownloadTopologyStateForInitResponse } from "./sequencer_service.js";
+import type { DownloadTopologyStateForInitRequest } from "./sequencer_service.js";
+import type { AcknowledgeSignedResponse } from "./sequencer_service.js";
+import type { AcknowledgeSignedRequest } from "./sequencer_service.js";
+import type { SubscriptionResponse } from "./sequencer_service.js";
+import type { SubscriptionRequest } from "./sequencer_service.js";
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { SendAsyncResponse } from "./sequencer_service.js";
+import type { SendAsyncRequest } from "./sequencer_service.js";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * The service that a member can use to send messages to the synchronizer and
+ * receive events from the synchronizer
+ *
+ * @generated from protobuf service com.digitalasset.canton.sequencer.api.v30.SequencerService
+ */
+export interface ISequencerServiceClient {
+    /**
+     * Submit a request to the sequencer.
+     *
+     * A request contains a batch, which is a sequence of envelopes.
+     * Every envelope consists of its content and a set of recipients, arranged in a forest.
+     * A synchronizer member is intended to receive those envelopes of a batch that contain the member as a recipient.
+     * A synchronizer member is supposed to learn about those recipients of an envelope that are
+     * (1) specified at a node that also specifies the member or
+     * (2) at a descendant thereof. (I.e., a node further down in the recipient forest.)
+     *
+     * The sequencer may or may not accept a request.
+     * If an incoming request is valid (i.e., it can be parsed and every field meets its documented validity conditions)
+     * an honest sequencer will accept requests in a best effort manner, provided resource limits are met.
+     *
+     * For every accepted request, the sequencer assigns a unique sequencing timestamp to the request.
+     * All honest sequencers of the synchronizer will deliver an event to the sender and
+     * to those synchronizer members that are intended to receive at least one envelope.
+     *
+     * Honest sequencers may deliver to all sequencers of the synchronizer events that don't correspond to submitted requests.
+     * Sequencer implementations may leverage this mechanism for internal purposes.
+     *
+     * An event for a synchronizer member contains only those envelopes of the batch of the request
+     * that the member is intended to receive and
+     * the recipients of an envelope contains only those that the member is supposed to learn about.
+     * A member will receive the envelopes of the same request within a single event.
+     * A member will receive events ordered by sequencing timestamp.
+     *
+     * If a request is accepted, the sender will receive a corresponding event, called "receipt";
+     * so that the sender is informed that the sequencer has accepted the request.
+     * If the sender is not a recipient of the request, the receipt has an empty batch.
+     *
+     * If the request contains an aggregation rule, the sequencer will process requests in an aggregated fashion.
+     * A set of requests belong to the same aggregation, if they have essentially the same contents (details specified at SubmissionRequest.aggregationId).
+     * The sequencer validates and assigns sequencing timestamps to requests within an aggregation just as for requests without an aggregation rule.
+     * The sequencer emits events and receipts for an accepted request within an aggregation as follows:
+     * - As long as the number of accepted requests is strictly less than AggregationRule.threshold,
+     *   the sequencer only emits a receipt with an empty batch to the sender of the request.
+     *   It does not emit any other events.
+     * - As soon as the number of accepted requests equals AggregationRule.threshold, the sequencer emits
+     *   events to the sender and the recipients of the request.
+     *   The sequencing timestamp of the events is the sequencing timestamp of the last accepted request.
+     * - The sequencer will not accept more than AggregationRule.threshold requests.
+     *   The sequencer will reject any further request that could otherwise be accepted.
+     *   Consequently, events for the request are delivered only once even if the threshold is attained multiple times.
+     *
+     * If the request does not contain an aggregation rule, even honest sequencers may deliver events for the request
+     * more than once (with different sequencing timestamps), as malicious sequencers may replay a request internally.
+     * Clients need to implement appropriate deduplication, if at-most-once delivery is needed.
+     * Once request.max_sequencing_time has elapsed (i.e. an event with an equal or higher timestamp has been emitted),
+     * an honest sequencer will not emit events corresponding to request anymore.
+     *
+     * The sequencer may reject a request, e.g., because the request is invalid or the sequencer is overloaded.
+     * The sequencer will indicate a rejection (independently of whether there is an aggregation rule)
+     * in exactly one of the following ways:
+     * (1) synchronously, by returning an error in the response of this method
+     * (2) asynchronously, by emitting an error in the response to SubscribeVersioned to the sender and
+     *     possibly an empty batch to non-sender recipients
+     * (3) by not emitting a receipt to the sender until request.max_sequencing_time
+     * Note that only (2) and (3) can be trusted. A malicious sequencer may synchronously return an error and
+     * still accept the request internally and therefore emit events later on.
+     *
+     * @generated from protobuf rpc: SendAsync
+     */
+    sendAsync(input: SendAsyncRequest, options?: RpcOptions): UnaryCall<SendAsyncRequest, SendAsyncResponse>;
+    /**
+     * Establishes a stream with the server to receive sequenced events from the synchronizer after the given
+     * counter. The delivered events will have a reference to the previous event (its timestamp)
+     * and a strictly monotonically increasing timestamp.
+     *
+     * The call fails synchronously, if the request is invalid, i.e., some field violates a documented validity condition.
+     * The call fails asynchronously, if the sequencer does not have a key to sign the event; this may occur if
+     * event.topology_timestamp refers to a time before the sequencer has been onboarded.
+     *
+     * @generated from protobuf rpc: Subscribe
+     */
+    subscribe(input: SubscriptionRequest, options?: RpcOptions): ServerStreamingCall<SubscriptionRequest, SubscriptionResponse>;
+    /**
+     * Allows a member to acknowledge that they have read all events up to and including the provided timestamp,
+     * and that they will never re-read these events again. This information is currently only used for informational
+     * purposes and to provide a watermark for which it is safe to prune earlier events from the sequencer data stores.
+     * There is no requirement for every event to be individually acknowledged, and in fact callers are encouraged to
+     * only periodically record acknowledgements (at an interval of minutes is expected to be more than sufficient for
+     * pruning).
+     *
+     * @generated from protobuf rpc: AcknowledgeSigned
+     */
+    acknowledgeSigned(input: AcknowledgeSignedRequest, options?: RpcOptions): UnaryCall<AcknowledgeSignedRequest, AcknowledgeSignedResponse>;
+    /**
+     * Download the topology state for a member up to including the topology transaction that made the member
+     * known on the synchronizer.
+     *
+     * @generated from protobuf rpc: DownloadTopologyStateForInit
+     */
+    downloadTopologyStateForInit(input: DownloadTopologyStateForInitRequest, options?: RpcOptions): ServerStreamingCall<DownloadTopologyStateForInitRequest, DownloadTopologyStateForInitResponse>;
+    /**
+     * Returns a hash of a result equivalent to DownloadTopologyStateForInit call
+     * for a BFT check without transferring the full state.
+     *
+     * @generated from protobuf rpc: DownloadTopologyStateForInitHash
+     */
+    downloadTopologyStateForInitHash(input: DownloadTopologyStateForInitHashRequest, options?: RpcOptions): UnaryCall<DownloadTopologyStateForInitHashRequest, DownloadTopologyStateForInitHashResponse>;
+    /**
+     * Return the currently known traffic state for a member. Callers must be authorized to request the traffic state.
+     *
+     * @generated from protobuf rpc: GetTrafficStateForMember
+     */
+    getTrafficStateForMember(input: GetTrafficStateForMemberRequest, options?: RpcOptions): UnaryCall<GetTrafficStateForMemberRequest, GetTrafficStateForMemberResponse>;
+    /**
+     * Return a "current" sequencing time such that, when a `SendAsync` operation is
+     * subsequently called, if sequenced, the sequencing time of the resulting event is guaranteed to
+     * be later than the sequencing time previously returned by the `GetTime` call.
+     *
+     * @generated from protobuf rpc: GetTime
+     */
+    getTime(input: GetTimeRequest, options?: RpcOptions): UnaryCall<GetTimeRequest, GetTimeResponse>;
+}
+/**
+ * The service that a member can use to send messages to the synchronizer and
+ * receive events from the synchronizer
+ *
+ * @generated from protobuf service com.digitalasset.canton.sequencer.api.v30.SequencerService
+ */
+export declare class SequencerServiceClient implements ISequencerServiceClient, ServiceInfo {
+    private readonly _transport;
+    typeName: string;
+    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
+    options: {
+        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
+    };
+    constructor(_transport: RpcTransport);
+    /**
+     * Submit a request to the sequencer.
+     *
+     * A request contains a batch, which is a sequence of envelopes.
+     * Every envelope consists of its content and a set of recipients, arranged in a forest.
+     * A synchronizer member is intended to receive those envelopes of a batch that contain the member as a recipient.
+     * A synchronizer member is supposed to learn about those recipients of an envelope that are
+     * (1) specified at a node that also specifies the member or
+     * (2) at a descendant thereof. (I.e., a node further down in the recipient forest.)
+     *
+     * The sequencer may or may not accept a request.
+     * If an incoming request is valid (i.e., it can be parsed and every field meets its documented validity conditions)
+     * an honest sequencer will accept requests in a best effort manner, provided resource limits are met.
+     *
+     * For every accepted request, the sequencer assigns a unique sequencing timestamp to the request.
+     * All honest sequencers of the synchronizer will deliver an event to the sender and
+     * to those synchronizer members that are intended to receive at least one envelope.
+     *
+     * Honest sequencers may deliver to all sequencers of the synchronizer events that don't correspond to submitted requests.
+     * Sequencer implementations may leverage this mechanism for internal purposes.
+     *
+     * An event for a synchronizer member contains only those envelopes of the batch of the request
+     * that the member is intended to receive and
+     * the recipients of an envelope contains only those that the member is supposed to learn about.
+     * A member will receive the envelopes of the same request within a single event.
+     * A member will receive events ordered by sequencing timestamp.
+     *
+     * If a request is accepted, the sender will receive a corresponding event, called "receipt";
+     * so that the sender is informed that the sequencer has accepted the request.
+     * If the sender is not a recipient of the request, the receipt has an empty batch.
+     *
+     * If the request contains an aggregation rule, the sequencer will process requests in an aggregated fashion.
+     * A set of requests belong to the same aggregation, if they have essentially the same contents (details specified at SubmissionRequest.aggregationId).
+     * The sequencer validates and assigns sequencing timestamps to requests within an aggregation just as for requests without an aggregation rule.
+     * The sequencer emits events and receipts for an accepted request within an aggregation as follows:
+     * - As long as the number of accepted requests is strictly less than AggregationRule.threshold,
+     *   the sequencer only emits a receipt with an empty batch to the sender of the request.
+     *   It does not emit any other events.
+     * - As soon as the number of accepted requests equals AggregationRule.threshold, the sequencer emits
+     *   events to the sender and the recipients of the request.
+     *   The sequencing timestamp of the events is the sequencing timestamp of the last accepted request.
+     * - The sequencer will not accept more than AggregationRule.threshold requests.
+     *   The sequencer will reject any further request that could otherwise be accepted.
+     *   Consequently, events for the request are delivered only once even if the threshold is attained multiple times.
+     *
+     * If the request does not contain an aggregation rule, even honest sequencers may deliver events for the request
+     * more than once (with different sequencing timestamps), as malicious sequencers may replay a request internally.
+     * Clients need to implement appropriate deduplication, if at-most-once delivery is needed.
+     * Once request.max_sequencing_time has elapsed (i.e. an event with an equal or higher timestamp has been emitted),
+     * an honest sequencer will not emit events corresponding to request anymore.
+     *
+     * The sequencer may reject a request, e.g., because the request is invalid or the sequencer is overloaded.
+     * The sequencer will indicate a rejection (independently of whether there is an aggregation rule)
+     * in exactly one of the following ways:
+     * (1) synchronously, by returning an error in the response of this method
+     * (2) asynchronously, by emitting an error in the response to SubscribeVersioned to the sender and
+     *     possibly an empty batch to non-sender recipients
+     * (3) by not emitting a receipt to the sender until request.max_sequencing_time
+     * Note that only (2) and (3) can be trusted. A malicious sequencer may synchronously return an error and
+     * still accept the request internally and therefore emit events later on.
+     *
+     * @generated from protobuf rpc: SendAsync
+     */
+    sendAsync(input: SendAsyncRequest, options?: RpcOptions): UnaryCall<SendAsyncRequest, SendAsyncResponse>;
+    /**
+     * Establishes a stream with the server to receive sequenced events from the synchronizer after the given
+     * counter. The delivered events will have a reference to the previous event (its timestamp)
+     * and a strictly monotonically increasing timestamp.
+     *
+     * The call fails synchronously, if the request is invalid, i.e., some field violates a documented validity condition.
+     * The call fails asynchronously, if the sequencer does not have a key to sign the event; this may occur if
+     * event.topology_timestamp refers to a time before the sequencer has been onboarded.
+     *
+     * @generated from protobuf rpc: Subscribe
+     */
+    subscribe(input: SubscriptionRequest, options?: RpcOptions): ServerStreamingCall<SubscriptionRequest, SubscriptionResponse>;
+    /**
+     * Allows a member to acknowledge that they have read all events up to and including the provided timestamp,
+     * and that they will never re-read these events again. This information is currently only used for informational
+     * purposes and to provide a watermark for which it is safe to prune earlier events from the sequencer data stores.
+     * There is no requirement for every event to be individually acknowledged, and in fact callers are encouraged to
+     * only periodically record acknowledgements (at an interval of minutes is expected to be more than sufficient for
+     * pruning).
+     *
+     * @generated from protobuf rpc: AcknowledgeSigned
+     */
+    acknowledgeSigned(input: AcknowledgeSignedRequest, options?: RpcOptions): UnaryCall<AcknowledgeSignedRequest, AcknowledgeSignedResponse>;
+    /**
+     * Download the topology state for a member up to including the topology transaction that made the member
+     * known on the synchronizer.
+     *
+     * @generated from protobuf rpc: DownloadTopologyStateForInit
+     */
+    downloadTopologyStateForInit(input: DownloadTopologyStateForInitRequest, options?: RpcOptions): ServerStreamingCall<DownloadTopologyStateForInitRequest, DownloadTopologyStateForInitResponse>;
+    /**
+     * Returns a hash of a result equivalent to DownloadTopologyStateForInit call
+     * for a BFT check without transferring the full state.
+     *
+     * @generated from protobuf rpc: DownloadTopologyStateForInitHash
+     */
+    downloadTopologyStateForInitHash(input: DownloadTopologyStateForInitHashRequest, options?: RpcOptions): UnaryCall<DownloadTopologyStateForInitHashRequest, DownloadTopologyStateForInitHashResponse>;
+    /**
+     * Return the currently known traffic state for a member. Callers must be authorized to request the traffic state.
+     *
+     * @generated from protobuf rpc: GetTrafficStateForMember
+     */
+    getTrafficStateForMember(input: GetTrafficStateForMemberRequest, options?: RpcOptions): UnaryCall<GetTrafficStateForMemberRequest, GetTrafficStateForMemberResponse>;
+    /**
+     * Return a "current" sequencing time such that, when a `SendAsync` operation is
+     * subsequently called, if sequenced, the sequencing time of the resulting event is guaranteed to
+     * be later than the sequencing time previously returned by the `GetTime` call.
+     *
+     * @generated from protobuf rpc: GetTime
+     */
+    getTime(input: GetTimeRequest, options?: RpcOptions): UnaryCall<GetTimeRequest, GetTimeResponse>;
+}

package/dist/transports/grpc/generated/canton/com/digitalasset/canton/sequencer/api/v30/sequencer_service.client.js

@@ -0,0 +1,153 @@
+import { SequencerService } from "./sequencer_service.js";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+/**
+ * The service that a member can use to send messages to the synchronizer and
+ * receive events from the synchronizer
+ *
+ * @generated from protobuf service com.digitalasset.canton.sequencer.api.v30.SequencerService
+ */
+export class SequencerServiceClient {
+    _transport;
+    typeName = SequencerService.typeName;
+    methods = SequencerService.methods;
+    options = SequencerService.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * Submit a request to the sequencer.
+     *
+     * A request contains a batch, which is a sequence of envelopes.
+     * Every envelope consists of its content and a set of recipients, arranged in a forest.
+     * A synchronizer member is intended to receive those envelopes of a batch that contain the member as a recipient.
+     * A synchronizer member is supposed to learn about those recipients of an envelope that are
+     * (1) specified at a node that also specifies the member or
+     * (2) at a descendant thereof. (I.e., a node further down in the recipient forest.)
+     *
+     * The sequencer may or may not accept a request.
+     * If an incoming request is valid (i.e., it can be parsed and every field meets its documented validity conditions)
+     * an honest sequencer will accept requests in a best effort manner, provided resource limits are met.
+     *
+     * For every accepted request, the sequencer assigns a unique sequencing timestamp to the request.
+     * All honest sequencers of the synchronizer will deliver an event to the sender and
+     * to those synchronizer members that are intended to receive at least one envelope.
+     *
+     * Honest sequencers may deliver to all sequencers of the synchronizer events that don't correspond to submitted requests.
+     * Sequencer implementations may leverage this mechanism for internal purposes.
+     *
+     * An event for a synchronizer member contains only those envelopes of the batch of the request
+     * that the member is intended to receive and
+     * the recipients of an envelope contains only those that the member is supposed to learn about.
+     * A member will receive the envelopes of the same request within a single event.
+     * A member will receive events ordered by sequencing timestamp.
+     *
+     * If a request is accepted, the sender will receive a corresponding event, called "receipt";
+     * so that the sender is informed that the sequencer has accepted the request.
+     * If the sender is not a recipient of the request, the receipt has an empty batch.
+     *
+     * If the request contains an aggregation rule, the sequencer will process requests in an aggregated fashion.
+     * A set of requests belong to the same aggregation, if they have essentially the same contents (details specified at SubmissionRequest.aggregationId).
+     * The sequencer validates and assigns sequencing timestamps to requests within an aggregation just as for requests without an aggregation rule.
+     * The sequencer emits events and receipts for an accepted request within an aggregation as follows:
+     * - As long as the number of accepted requests is strictly less than AggregationRule.threshold,
+     *   the sequencer only emits a receipt with an empty batch to the sender of the request.
+     *   It does not emit any other events.
+     * - As soon as the number of accepted requests equals AggregationRule.threshold, the sequencer emits
+     *   events to the sender and the recipients of the request.
+     *   The sequencing timestamp of the events is the sequencing timestamp of the last accepted request.
+     * - The sequencer will not accept more than AggregationRule.threshold requests.
+     *   The sequencer will reject any further request that could otherwise be accepted.
+     *   Consequently, events for the request are delivered only once even if the threshold is attained multiple times.
+     *
+     * If the request does not contain an aggregation rule, even honest sequencers may deliver events for the request
+     * more than once (with different sequencing timestamps), as malicious sequencers may replay a request internally.
+     * Clients need to implement appropriate deduplication, if at-most-once delivery is needed.
+     * Once request.max_sequencing_time has elapsed (i.e. an event with an equal or higher timestamp has been emitted),
+     * an honest sequencer will not emit events corresponding to request anymore.
+     *
+     * The sequencer may reject a request, e.g., because the request is invalid or the sequencer is overloaded.
+     * The sequencer will indicate a rejection (independently of whether there is an aggregation rule)
+     * in exactly one of the following ways:
+     * (1) synchronously, by returning an error in the response of this method
+     * (2) asynchronously, by emitting an error in the response to SubscribeVersioned to the sender and
+     *     possibly an empty batch to non-sender recipients
+     * (3) by not emitting a receipt to the sender until request.max_sequencing_time
+     * Note that only (2) and (3) can be trusted. A malicious sequencer may synchronously return an error and
+     * still accept the request internally and therefore emit events later on.
+     *
+     * @generated from protobuf rpc: SendAsync
+     */
+    sendAsync(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * Establishes a stream with the server to receive sequenced events from the synchronizer after the given
+     * counter. The delivered events will have a reference to the previous event (its timestamp)
+     * and a strictly monotonically increasing timestamp.
+     *
+     * The call fails synchronously, if the request is invalid, i.e., some field violates a documented validity condition.
+     * The call fails asynchronously, if the sequencer does not have a key to sign the event; this may occur if
+     * event.topology_timestamp refers to a time before the sequencer has been onboarded.
+     *
+     * @generated from protobuf rpc: Subscribe
+     */
+    subscribe(input, options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     * Allows a member to acknowledge that they have read all events up to and including the provided timestamp,
+     * and that they will never re-read these events again. This information is currently only used for informational
+     * purposes and to provide a watermark for which it is safe to prune earlier events from the sequencer data stores.
+     * There is no requirement for every event to be individually acknowledged, and in fact callers are encouraged to
+     * only periodically record acknowledgements (at an interval of minutes is expected to be more than sufficient for
+     * pruning).
+     *
+     * @generated from protobuf rpc: AcknowledgeSigned
+     */
+    acknowledgeSigned(input, options) {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * Download the topology state for a member up to including the topology transaction that made the member
+     * known on the synchronizer.
+     *
+     * @generated from protobuf rpc: DownloadTopologyStateForInit
+     */
+    downloadTopologyStateForInit(input, options) {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     * Returns a hash of a result equivalent to DownloadTopologyStateForInit call
+     * for a BFT check without transferring the full state.
+     *
+     * @generated from protobuf rpc: DownloadTopologyStateForInitHash
+     */
+    downloadTopologyStateForInitHash(input, options) {
+        const method = this.methods[4], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * Return the currently known traffic state for a member. Callers must be authorized to request the traffic state.
+     *
+     * @generated from protobuf rpc: GetTrafficStateForMember
+     */
+    getTrafficStateForMember(input, options) {
+        const method = this.methods[5], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * Return a "current" sequencing time such that, when a `SendAsync` operation is
+     * subsequently called, if sequenced, the sequencing time of the resulting event is guaranteed to
+     * be later than the sequencing time previously returned by the `GetTime` call.
+     *
+     * @generated from protobuf rpc: GetTime
+     */
+    getTime(input, options) {
+        const method = this.methods[6], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}