@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/com/daml/ledger/api/v2/completion.d.ts

@@ -0,0 +1,149 @@
+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 { SynchronizerTime } from './offset_checkpoint.js';
+import { TraceContext } from './trace_context.js';
+import { Duration } from '../../../../../google/protobuf/duration.js';
+import { Status } from '../../../../../google/rpc/status.js';
+/**
+ * A completion represents the status of a submitted command on the ledger: it can be successful or failed.
+ *
+ * @generated from protobuf message com.daml.ledger.api.v2.Completion
+ */
+export interface Completion {
+    /**
+     * The ID of the succeeded or failed command.
+     * Must be a valid LedgerString (as described in ``value.proto``).
+     * Required
+     *
+     * @generated from protobuf field: string command_id = 1
+     */
+    commandId: string;
+    /**
+     * Identifies the exact type of the error.
+     * It uses the same format of conveying error details as it is used for the RPC responses of the APIs.
+     * Optional
+     *
+     * @generated from protobuf field: google.rpc.Status status = 2
+     */
+    status?: Status;
+    /**
+     * The update_id of the transaction or reassignment that resulted from the command with command_id.
+     * Only set for successfully executed commands.
+     * Must be a valid LedgerString (as described in ``value.proto``).
+     *
+     * @generated from protobuf field: string update_id = 3
+     */
+    updateId: string;
+    /**
+     * The user-id that was used for the submission, as described in ``commands.proto``.
+     * Must be a valid UserIdString (as described in ``value.proto``).
+     * Optional for historic completions where this data is not available.
+     *
+     * @generated from protobuf field: string user_id = 4
+     */
+    userId: string;
+    /**
+     * The set of parties on whose behalf the commands were executed.
+     * Contains the ``act_as`` parties from ``commands.proto``
+     * filtered to the requesting parties in CompletionStreamRequest.
+     * The order of the parties need not be the same as in the submission.
+     * Each element must be a valid PartyIdString (as described in ``value.proto``).
+     * Optional for historic completions where this data is not available.
+     *
+     * @generated from protobuf field: repeated string act_as = 5
+     */
+    actAs: string[];
+    /**
+     * The submission ID this completion refers to, as described in ``commands.proto``.
+     * Must be a valid LedgerString (as described in ``value.proto``).
+     * Optional
+     *
+     * @generated from protobuf field: string submission_id = 6
+     */
+    submissionId: string;
+    /**
+     * The actual deduplication window used for the submission, which is derived from
+     * ``Commands.deduplication_period``. The ledger may convert the deduplication period into other
+     * descriptions and extend the period in implementation-specified ways.
+     *
+     * Used to audit the deduplication guarantee described in ``commands.proto``.
+     *
+     * Optional; the deduplication guarantee applies even if the completion omits this field.
+     *
+     * @generated from protobuf oneof: deduplication_period
+     */
+    deduplicationPeriod: {
+        oneofKind: 'deduplicationOffset';
+        /**
+         * Specifies the start of the deduplication period by a completion stream offset (exclusive).
+         *
+         * Must be a valid absolute offset (positive integer) or participant begin (zero).
+         *
+         * @generated from protobuf field: int64 deduplication_offset = 7
+         */
+        deduplicationOffset: bigint;
+    } | {
+        oneofKind: 'deduplicationDuration';
+        /**
+         * Specifies the length of the deduplication period.
+         * It is measured in record time of completions.
+         *
+         * Must be non-negative.
+         *
+         * @generated from protobuf field: google.protobuf.Duration deduplication_duration = 8
+         */
+        deduplicationDuration: Duration;
+    } | {
+        oneofKind: undefined;
+    };
+    /**
+     * Optional; ledger API trace context
+     *
+     * The trace context transported in this message corresponds to the trace context supplied
+     * by the client application in a HTTP2 header of the original command submission.
+     * We typically use a header to transfer this type of information. Here we use message
+     * body, because it is used in gRPC streams which do not support per message headers.
+     * This field will be populated with the trace context contained in the original submission.
+     * If that was not provided, a unique ledger-api-server generated trace context will be used
+     * instead.
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.TraceContext trace_context = 9
+     */
+    traceContext?: TraceContext;
+    /**
+     * May be used in a subsequent CompletionStreamRequest to resume the consumption of this stream at a later time.
+     * Required, must be a valid absolute offset (positive integer).
+     *
+     * @generated from protobuf field: int64 offset = 10
+     */
+    offset: bigint;
+    /**
+     * The synchronizer along with its record time.
+     * The synchronizer id provided, in case of
+     *
+     * - successful/failed transactions: identifies the synchronizer of the transaction
+     * - for successful/failed unassign commands: identifies the source synchronizer
+     * - for successful/failed assign commands: identifies the target synchronizer
+     *
+     * Required
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.SynchronizerTime synchronizer_time = 11
+     */
+    synchronizerTime?: SynchronizerTime;
+}
+declare class Completion$Type extends MessageType<Completion> {
+    constructor();
+    create(value?: PartialMessage<Completion>): Completion;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Completion): Completion;
+    internalBinaryWrite(message: Completion, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.Completion
+ */
+export declare const Completion: Completion$Type;
+export {};
+//# sourceMappingURL=completion.d.ts.map

package/dist/_proto/com/daml/ledger/api/v2/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../../../../../src/_proto/com/daml/ledger/api/v2/completion.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,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,4CAA4C,CAAA;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAA;AAC5D;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACvB;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;;;OASG;IACH,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB;;;;;;;;;;OAUG;IACH,mBAAmB,EACb;QACI,SAAS,EAAE,qBAAqB,CAAA;QAChC;;;;;;WAMG;QACH,mBAAmB,EAAE,MAAM,CAAA;KAC9B,GACD;QACI,SAAS,EAAE,uBAAuB,CAAA;QAClC;;;;;;;WAOG;QACH,qBAAqB,EAAE,QAAQ,CAAA;KAClC,GACD;QACI,SAAS,EAAE,SAAS,CAAA;KACvB,CAAA;IACP;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;CACtC;AAED,cAAM,eAAgB,SAAQ,WAAW,CAAC,UAAU,CAAC;;IAuEjD,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,UAAU;IAatD,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,UAAU,GACpB,UAAU;IAsFb,mBAAmB,CACf,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CA6DnB;AACD;;GAEG;AACH,eAAO,MAAM,UAAU,iBAAwB,CAAA"}

package/dist/_proto/com/daml/ledger/api/v2/completion.js

@@ -0,0 +1,196 @@
+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 { SynchronizerTime } from './offset_checkpoint.js';
+import { TraceContext } from './trace_context.js';
+import { Duration } from '../../../../../google/protobuf/duration.js';
+import { Status } from '../../../../../google/rpc/status.js';
+// @generated message type with reflection information, may provide speed optimized methods
+class Completion$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.Completion', [
+            {
+                no: 1,
+                name: 'command_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            { no: 2, name: 'status', kind: 'message', T: () => Status },
+            {
+                no: 3,
+                name: 'update_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 4,
+                name: 'user_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 5,
+                name: 'act_as',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 6,
+                name: 'submission_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 7,
+                name: 'deduplication_offset',
+                kind: 'scalar',
+                oneof: 'deduplicationPeriod',
+                T: 3 /*ScalarType.INT64*/,
+                L: 0 /*LongType.BIGINT*/,
+            },
+            {
+                no: 8,
+                name: 'deduplication_duration',
+                kind: 'message',
+                oneof: 'deduplicationPeriod',
+                T: () => Duration,
+            },
+            {
+                no: 9,
+                name: 'trace_context',
+                kind: 'message',
+                T: () => TraceContext,
+            },
+            {
+                no: 10,
+                name: 'offset',
+                kind: 'scalar',
+                T: 3 /*ScalarType.INT64*/,
+                L: 0 /*LongType.BIGINT*/,
+            },
+            {
+                no: 11,
+                name: 'synchronizer_time',
+                kind: 'message',
+                T: () => SynchronizerTime,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.commandId = '';
+        message.updateId = '';
+        message.userId = '';
+        message.actAs = [];
+        message.submissionId = '';
+        message.deduplicationPeriod = { oneofKind: undefined };
+        message.offset = 0n;
+        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 /* string command_id */ 1:
+                    message.commandId = reader.string();
+                    break;
+                case /* google.rpc.Status status */ 2:
+                    message.status = Status.internalBinaryRead(reader, reader.uint32(), options, message.status);
+                    break;
+                case /* string update_id */ 3:
+                    message.updateId = reader.string();
+                    break;
+                case /* string user_id */ 4:
+                    message.userId = reader.string();
+                    break;
+                case /* repeated string act_as */ 5:
+                    message.actAs.push(reader.string());
+                    break;
+                case /* string submission_id */ 6:
+                    message.submissionId = reader.string();
+                    break;
+                case /* int64 deduplication_offset */ 7:
+                    message.deduplicationPeriod = {
+                        oneofKind: 'deduplicationOffset',
+                        deduplicationOffset: reader.int64().toBigInt(),
+                    };
+                    break;
+                case /* google.protobuf.Duration deduplication_duration */ 8:
+                    message.deduplicationPeriod = {
+                        oneofKind: 'deduplicationDuration',
+                        deduplicationDuration: Duration.internalBinaryRead(reader, reader.uint32(), options, message.deduplicationPeriod
+                            .deduplicationDuration),
+                    };
+                    break;
+                case /* com.daml.ledger.api.v2.TraceContext trace_context */ 9:
+                    message.traceContext = TraceContext.internalBinaryRead(reader, reader.uint32(), options, message.traceContext);
+                    break;
+                case /* int64 offset */ 10:
+                    message.offset = reader.int64().toBigInt();
+                    break;
+                case /* com.daml.ledger.api.v2.SynchronizerTime synchronizer_time */ 11:
+                    message.synchronizerTime =
+                        SynchronizerTime.internalBinaryRead(reader, reader.uint32(), options, message.synchronizerTime);
+                    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) {
+        /* string command_id = 1; */
+        if (message.commandId !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.commandId);
+        /* google.rpc.Status status = 2; */
+        if (message.status)
+            Status.internalBinaryWrite(message.status, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* string update_id = 3; */
+        if (message.updateId !== '')
+            writer.tag(3, WireType.LengthDelimited).string(message.updateId);
+        /* string user_id = 4; */
+        if (message.userId !== '')
+            writer.tag(4, WireType.LengthDelimited).string(message.userId);
+        /* repeated string act_as = 5; */
+        for (let i = 0; i < message.actAs.length; i++)
+            writer.tag(5, WireType.LengthDelimited).string(message.actAs[i]);
+        /* string submission_id = 6; */
+        if (message.submissionId !== '')
+            writer.tag(6, WireType.LengthDelimited).string(message.submissionId);
+        /* int64 deduplication_offset = 7; */
+        if (message.deduplicationPeriod.oneofKind === 'deduplicationOffset')
+            writer
+                .tag(7, WireType.Varint)
+                .int64(message.deduplicationPeriod.deduplicationOffset);
+        /* google.protobuf.Duration deduplication_duration = 8; */
+        if (message.deduplicationPeriod.oneofKind === 'deduplicationDuration')
+            Duration.internalBinaryWrite(message.deduplicationPeriod.deduplicationDuration, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* com.daml.ledger.api.v2.TraceContext trace_context = 9; */
+        if (message.traceContext)
+            TraceContext.internalBinaryWrite(message.traceContext, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* int64 offset = 10; */
+        if (message.offset !== 0n)
+            writer.tag(10, WireType.Varint).int64(message.offset);
+        /* com.daml.ledger.api.v2.SynchronizerTime synchronizer_time = 11; */
+        if (message.synchronizerTime)
+            SynchronizerTime.internalBinaryWrite(message.synchronizerTime, writer.tag(11, 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.daml.ledger.api.v2.Completion
+ */
+export const Completion = new Completion$Type();