From 2062ff5eb341dda8b9b8696f0d6b2f0c76ba7c02 Mon Sep 17 00:00:00 2001 From: Ravi Hegde Date: Tue, 30 Sep 2025 18:46:43 +0530 Subject: [PATCH] feat(sdk-coin-canton): added transaction class and canton raw transaction local parser Ticket: COIN-5871 --- modules/sdk-coin-canton/package.json | 6 +- .../resources/proto/damlTransaction.js | 100 +++ .../resources/proto/damlTransactionNode.js | 71 ++ .../proto/damlTransactionNodeSeed.js | 56 ++ .../resources/proto/metadata.js | 189 ++++ .../metadata/metadataGlobalKeyMappingEntry.js | 53 ++ .../proto/metadata/metadataInputContract.js | 80 ++ .../proto/metadata/metadataSubmitterInfo.js | 62 ++ .../resources/proto/node/empty.js | 36 + .../resources/proto/node/globalKey.js | 81 ++ .../resources/proto/node/identifier.js | 73 ++ .../resources/proto/node/node.js | 656 ++++++++++++++ .../resources/proto/node/timestamp.js | 145 +++ .../resources/proto/node/value.js | 824 ++++++++++++++++++ .../resources/proto/preparedTransaction.d.ts | 8 + .../resources/proto/preparedTransaction.js | 66 ++ modules/sdk-coin-canton/src/lib/iface.ts | 37 + modules/sdk-coin-canton/src/lib/keyPair.ts | 1 + .../src/lib/resourcesInterface.ts | 263 ++++++ .../sdk-coin-canton/src/lib/transaction.ts | 46 +- modules/sdk-coin-canton/src/lib/utils.ts | 105 ++- .../walletInitializationTransaction.ts | 43 + modules/sdk-coin-canton/test/resources.ts | 2 + modules/sdk-coin-canton/test/unit/utils.ts | 16 + modules/sdk-coin-canton/tsconfig.json | 2 +- yarn.lock | 5 + 26 files changed, 3011 insertions(+), 15 deletions(-) create mode 100644 modules/sdk-coin-canton/resources/proto/damlTransaction.js create mode 100644 modules/sdk-coin-canton/resources/proto/damlTransactionNode.js create mode 100644 modules/sdk-coin-canton/resources/proto/damlTransactionNodeSeed.js create mode 100644 modules/sdk-coin-canton/resources/proto/metadata.js create mode 100644 modules/sdk-coin-canton/resources/proto/metadata/metadataGlobalKeyMappingEntry.js create mode 100644 modules/sdk-coin-canton/resources/proto/metadata/metadataInputContract.js create mode 100644 modules/sdk-coin-canton/resources/proto/metadata/metadataSubmitterInfo.js create mode 100644 modules/sdk-coin-canton/resources/proto/node/empty.js create mode 100644 modules/sdk-coin-canton/resources/proto/node/globalKey.js create mode 100644 modules/sdk-coin-canton/resources/proto/node/identifier.js create mode 100644 modules/sdk-coin-canton/resources/proto/node/node.js create mode 100644 modules/sdk-coin-canton/resources/proto/node/timestamp.js create mode 100644 modules/sdk-coin-canton/resources/proto/node/value.js create mode 100644 modules/sdk-coin-canton/resources/proto/preparedTransaction.d.ts create mode 100644 modules/sdk-coin-canton/resources/proto/preparedTransaction.js create mode 100644 modules/sdk-coin-canton/src/lib/resourcesInterface.ts create mode 100644 modules/sdk-coin-canton/src/lib/walletInitialization/walletInitializationTransaction.ts create mode 100644 modules/sdk-coin-canton/test/resources.ts create mode 100644 modules/sdk-coin-canton/test/unit/utils.ts diff --git a/modules/sdk-coin-canton/package.json b/modules/sdk-coin-canton/package.json index d280e69584..330fd87cd9 100644 --- a/modules/sdk-coin-canton/package.json +++ b/modules/sdk-coin-canton/package.json @@ -5,12 +5,13 @@ "main": "./dist/src/index.js", "types": "./dist/src/index.d.ts", "scripts": { - "build": "yarn tsc --build --incremental --verbose .", + "build": "npm run prepare", + "build-ts": "yarn tsc --build --incremental --verbose .", "fmt": "prettier --write .", "check-fmt": "prettier --check .", "clean": "rm -r ./dist", "lint": "eslint --quiet .", - "prepare": "npm run build", + "prepare": "npm run build-ts && shx cp -r ./resources ./dist", "test": "npm run coverage", "coverage": "nyc -- npm run unit-test", "unit-test": "mocha" @@ -42,6 +43,7 @@ "dependencies": { "@bitgo/sdk-core": "^36.10.1", "@bitgo/statics": "^58.2.0", + "@protobuf-ts/runtime": "^2.11.1", "bignumber.js": "^9.1.1" }, "devDependencies": { diff --git a/modules/sdk-coin-canton/resources/proto/damlTransaction.js b/modules/sdk-coin-canton/resources/proto/damlTransaction.js new file mode 100644 index 0000000000..1ace6b6ec6 --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/damlTransaction.js @@ -0,0 +1,100 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { DamlTransaction_Node } from './damlTransactionNode.js'; +import { DamlTransaction_NodeSeed } from './damlTransactionNodeSeed.js'; + +class DamlTransaction$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.DamlTransaction', [ + { + no: 1, + name: 'version', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 2, + name: 'roots', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 3, + name: 'nodes', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => DamlTransaction_Node, + }, + { + no: 4, + name: 'node_seeds', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => DamlTransaction_NodeSeed, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.version = ''; + message.roots = []; + message.nodes = []; + message.nodeSeeds = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string version */ 1: + message.version = reader.string(); + break; + case /* repeated string roots */ 2: + message.roots.push(reader.string()); + break; + case /* repeated com.daml.ledger.api.v2.interactive.DamlTransaction.Node nodes */ 3: + message.nodes.push(DamlTransaction_Node.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* repeated com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed node_seeds */ 4: + message.nodeSeeds.push(DamlTransaction_NodeSeed.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 version = 1; */ + if (message.version !== '') writer.tag(1, WireType.LengthDelimited).string(message.version); + /* repeated string roots = 2; */ + for (let i = 0; i < message.roots.length; i++) writer.tag(2, WireType.LengthDelimited).string(message.roots[i]); + /* repeated com.daml.ledger.api.v2.interactive.DamlTransaction.Node nodes = 3; */ + for (let i = 0; i < message.nodes.length; i++) + DamlTransaction_Node.internalBinaryWrite( + message.nodes[i], + writer.tag(3, WireType.LengthDelimited).fork(), + options + ).join(); + /* repeated com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed node_seeds = 4; */ + for (let i = 0; i < message.nodeSeeds.length; i++) + DamlTransaction_NodeSeed.internalBinaryWrite( + message.nodeSeeds[i], + writer.tag(4, WireType.LengthDelimited).fork(), + options + ).join(); + const 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.interactive.DamlTransaction + */ +export const DamlTransaction = new DamlTransaction$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/damlTransactionNode.js b/modules/sdk-coin-canton/resources/proto/damlTransactionNode.js new file mode 100644 index 0000000000..840fc903a1 --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/damlTransactionNode.js @@ -0,0 +1,71 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { Node } from './node/node.js'; + +class DamlTransaction_Node$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.DamlTransaction.Node', [ + { + no: 1, + name: 'node_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 1000, + name: 'v1', + kind: 'message', + oneof: 'versionedNode', + T: () => Node, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.nodeId = ''; + message.versionedNode = { oneofKind: undefined }; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string node_id */ 1: + message.nodeId = reader.string(); + break; + case /* com.daml.ledger.api.v2.interactive.transaction.v1.Node v1 */ 1000: + message.versionedNode = { + oneofKind: 'v1', + v1: Node.internalBinaryRead(reader, reader.uint32(), options, message.versionedNode.v1), + }; + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 node_id = 1; */ + if (message.nodeId !== '') writer.tag(1, WireType.LengthDelimited).string(message.nodeId); + /* com.daml.ledger.api.v2.interactive.transaction.v1.Node v1 = 1000; */ + if (message.versionedNode.oneofKind === 'v1') + Node.internalBinaryWrite( + message.versionedNode.v1, + writer.tag(1000, WireType.LengthDelimited).fork(), + options + ).join(); + const 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.interactive.DamlTransaction.Node + */ +export const DamlTransaction_Node = new DamlTransaction_Node$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/damlTransactionNodeSeed.js b/modules/sdk-coin-canton/resources/proto/damlTransactionNodeSeed.js new file mode 100644 index 0000000000..fa14cff7cd --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/damlTransactionNodeSeed.js @@ -0,0 +1,56 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; + +class DamlTransaction_NodeSeed$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed', [ + { + no: 1, + name: 'node_id', + kind: 'scalar', + T: 5 /*ScalarType.INT32*/, + }, + { no: 2, name: 'seed', kind: 'scalar', T: 12 /*ScalarType.BYTES*/ }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.nodeId = 0; + message.seed = new Uint8Array(0); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* int32 node_id */ 1: + message.nodeId = reader.int32(); + break; + case /* bytes seed */ 2: + message.seed = reader.bytes(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* int32 node_id = 1; */ + if (message.nodeId !== 0) writer.tag(1, WireType.Varint).int32(message.nodeId); + /* bytes seed = 2; */ + if (message.seed.length) writer.tag(2, WireType.LengthDelimited).bytes(message.seed); + const 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.interactive.DamlTransaction.NodeSeed + */ +export const DamlTransaction_NodeSeed = new DamlTransaction_NodeSeed$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/metadata.js b/modules/sdk-coin-canton/resources/proto/metadata.js new file mode 100644 index 0000000000..d2d529f21a --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/metadata.js @@ -0,0 +1,189 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { Metadata_GlobalKeyMappingEntry } from './metadata/metadataGlobalKeyMappingEntry.js'; +import { Metadata_InputContract } from './metadata/metadataInputContract.js'; +import { Metadata_SubmitterInfo } from './metadata/metadataSubmitterInfo.js'; + +class Metadata$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.Metadata', [ + { + no: 2, + name: 'submitter_info', + kind: 'message', + T: () => Metadata_SubmitterInfo, + }, + { + no: 3, + name: 'synchronizer_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 4, + name: 'mediator_group', + kind: 'scalar', + T: 13 /*ScalarType.UINT32*/, + }, + { + no: 5, + name: 'transaction_uuid', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 6, + name: 'preparation_time', + kind: 'scalar', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 7, + name: 'input_contracts', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => Metadata_InputContract, + }, + { + no: 9, + name: 'min_ledger_effective_time', + kind: 'scalar', + opt: true, + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 10, + name: 'max_ledger_effective_time', + kind: 'scalar', + opt: true, + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 8, + name: 'global_key_mapping', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => Metadata_GlobalKeyMappingEntry, + }, + { + no: 11, + name: 'max_record_time', + kind: 'scalar', + opt: true, + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.synchronizerId = ''; + message.mediatorGroup = 0; + message.transactionUuid = ''; + message.preparationTime = 0n; + message.inputContracts = []; + message.globalKeyMapping = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo submitter_info */ 2: + message.submitterInfo = Metadata_SubmitterInfo.internalBinaryRead( + reader, + reader.uint32(), + options, + message.submitterInfo + ); + break; + case /* string synchronizer_id */ 3: + message.synchronizerId = reader.string(); + break; + case /* uint32 mediator_group */ 4: + message.mediatorGroup = reader.uint32(); + break; + case /* string transaction_uuid */ 5: + message.transactionUuid = reader.string(); + break; + case /* uint64 preparation_time */ 6: + message.preparationTime = reader.uint64().toBigInt(); + break; + case /* repeated com.daml.ledger.api.v2.interactive.Metadata.InputContract input_contracts */ 7: + message.inputContracts.push(Metadata_InputContract.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* optional uint64 min_ledger_effective_time */ 9: + message.minLedgerEffectiveTime = reader.uint64().toBigInt(); + break; + case /* optional uint64 max_ledger_effective_time */ 10: + message.maxLedgerEffectiveTime = reader.uint64().toBigInt(); + break; + case /* repeated com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry global_key_mapping */ 8: + message.globalKeyMapping.push( + Metadata_GlobalKeyMappingEntry.internalBinaryRead(reader, reader.uint32(), options) + ); + break; + case /* optional uint64 max_record_time */ 11: + message.maxRecordTime = reader.uint64().toBigInt(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo submitter_info = 2; */ + if (message.submitterInfo) + Metadata_SubmitterInfo.internalBinaryWrite( + message.submitterInfo, + writer.tag(2, WireType.LengthDelimited).fork(), + options + ).join(); + /* string synchronizer_id = 3; */ + if (message.synchronizerId !== '') writer.tag(3, WireType.LengthDelimited).string(message.synchronizerId); + /* uint32 mediator_group = 4; */ + if (message.mediatorGroup !== 0) writer.tag(4, WireType.Varint).uint32(message.mediatorGroup); + /* string transaction_uuid = 5; */ + if (message.transactionUuid !== '') writer.tag(5, WireType.LengthDelimited).string(message.transactionUuid); + /* uint64 preparation_time = 6; */ + if (message.preparationTime !== 0n) writer.tag(6, WireType.Varint).uint64(message.preparationTime); + /* repeated com.daml.ledger.api.v2.interactive.Metadata.InputContract input_contracts = 7; */ + for (let i = 0; i < message.inputContracts.length; i++) + Metadata_InputContract.internalBinaryWrite( + message.inputContracts[i], + writer.tag(7, WireType.LengthDelimited).fork(), + options + ).join(); + /* repeated com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry global_key_mapping = 8; */ + for (let i = 0; i < message.globalKeyMapping.length; i++) + Metadata_GlobalKeyMappingEntry.internalBinaryWrite( + message.globalKeyMapping[i], + writer.tag(8, WireType.LengthDelimited).fork(), + options + ).join(); + /* optional uint64 min_ledger_effective_time = 9; */ + if (message.minLedgerEffectiveTime !== undefined) + writer.tag(9, WireType.Varint).uint64(message.minLedgerEffectiveTime); + /* optional uint64 max_ledger_effective_time = 10; */ + if (message.maxLedgerEffectiveTime !== undefined) + writer.tag(10, WireType.Varint).uint64(message.maxLedgerEffectiveTime); + /* optional uint64 max_record_time = 11; */ + if (message.maxRecordTime !== undefined) writer.tag(11, WireType.Varint).uint64(message.maxRecordTime); + const 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.interactive.Metadata + */ +export const Metadata = new Metadata$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/metadata/metadataGlobalKeyMappingEntry.js b/modules/sdk-coin-canton/resources/proto/metadata/metadataGlobalKeyMappingEntry.js new file mode 100644 index 0000000000..e3fde10dfc --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/metadata/metadataGlobalKeyMappingEntry.js @@ -0,0 +1,53 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { Value } from '../node/value.js'; +import { GlobalKey } from '../node/globalKey.js'; + +class Metadata_GlobalKeyMappingEntry$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry', [ + { no: 1, name: 'key', kind: 'message', T: () => GlobalKey }, + { no: 2, name: 'value', kind: 'message', T: () => Value }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.interactive.GlobalKey key */ 1: + message.key = GlobalKey.internalBinaryRead(reader, reader.uint32(), options, message.key); + break; + case /* optional com.daml.ledger.api.v2.Value value */ 2: + message.value = Value.internalBinaryRead(reader, reader.uint32(), options, message.value); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.interactive.GlobalKey key = 1; */ + if (message.key) + GlobalKey.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* optional com.daml.ledger.api.v2.Value value = 2; */ + if (message.value) + Value.internalBinaryWrite(message.value, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + const 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.interactive.Metadata.GlobalKeyMappingEntry + */ +export const Metadata_GlobalKeyMappingEntry = new Metadata_GlobalKeyMappingEntry$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/metadata/metadataInputContract.js b/modules/sdk-coin-canton/resources/proto/metadata/metadataInputContract.js new file mode 100644 index 0000000000..0ff427e1ba --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/metadata/metadataInputContract.js @@ -0,0 +1,80 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { Create } from '../node/node.js'; + +class Metadata_InputContract$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.Metadata.InputContract', [ + { + no: 1, + name: 'v1', + kind: 'message', + oneof: 'contract', + T: () => Create, + }, + { + no: 1000, + name: 'created_at', + kind: 'scalar', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 1002, + name: 'event_blob', + kind: 'scalar', + T: 12 /*ScalarType.BYTES*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.contract = { oneofKind: undefined }; + message.createdAt = 0n; + message.eventBlob = new Uint8Array(0); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.interactive.transaction.v1.Create v1 */ 1: + message.contract = { + oneofKind: 'v1', + v1: Create.internalBinaryRead(reader, reader.uint32(), options, message.contract.v1), + }; + break; + case /* uint64 created_at */ 1000: + message.createdAt = reader.uint64().toBigInt(); + break; + case /* bytes event_blob */ 1002: + message.eventBlob = reader.bytes(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.interactive.transaction.v1.Create v1 = 1; */ + if (message.contract.oneofKind === 'v1') + Create.internalBinaryWrite(message.contract.v1, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* uint64 created_at = 1000; */ + if (message.createdAt !== 0n) writer.tag(1000, WireType.Varint).uint64(message.createdAt); + /* bytes event_blob = 1002; */ + if (message.eventBlob.length) writer.tag(1002, WireType.LengthDelimited).bytes(message.eventBlob); + const 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.interactive.Metadata.InputContract + */ +export const Metadata_InputContract = new Metadata_InputContract$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/metadata/metadataSubmitterInfo.js b/modules/sdk-coin-canton/resources/proto/metadata/metadataSubmitterInfo.js new file mode 100644 index 0000000000..5f55d5df94 --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/metadata/metadataSubmitterInfo.js @@ -0,0 +1,62 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; + +class Metadata_SubmitterInfo$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo', [ + { + no: 1, + name: 'act_as', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 2, + name: 'command_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.actAs = []; + message.commandId = ''; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated string act_as */ 1: + message.actAs.push(reader.string()); + break; + case /* string command_id */ 2: + message.commandId = reader.string(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* repeated string act_as = 1; */ + for (let i = 0; i < message.actAs.length; i++) writer.tag(1, WireType.LengthDelimited).string(message.actAs[i]); + /* string command_id = 2; */ + if (message.commandId !== '') writer.tag(2, WireType.LengthDelimited).string(message.commandId); + const 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.interactive.Metadata.SubmitterInfo + */ +export const Metadata_SubmitterInfo = new Metadata_SubmitterInfo$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/node/empty.js b/modules/sdk-coin-canton/resources/proto/node/empty.js new file mode 100644 index 0000000000..cf6ba063bb --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/node/empty.js @@ -0,0 +1,36 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial } from '@protobuf-ts/runtime'; + +class Empty$Type extends MessageType { + constructor() { + super('google.protobuf.Empty', []); + } + create(value) { + const message = Object.create(this.messagePrototype); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + const u = options.writeUnknownFields; + if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.Empty + */ +export const Empty = new Empty$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/node/globalKey.js b/modules/sdk-coin-canton/resources/proto/node/globalKey.js new file mode 100644 index 0000000000..9a8d0e594b --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/node/globalKey.js @@ -0,0 +1,81 @@ +import { MessageType, reflectionMergePartial, UnknownFieldHandler, WireType } from '@protobuf-ts/runtime'; +import { Value } from './value.js'; +import { Identifier } from './identifier.js'; + +class GlobalKey$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.GlobalKey', [ + { + no: 1, + name: 'template_id', + kind: 'message', + T: () => Identifier, + }, + { + no: 2, + name: 'package_name', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { no: 3, name: 'key', kind: 'message', T: () => Value }, + { no: 4, name: 'hash', kind: 'scalar', T: 12 /*ScalarType.BYTES*/ }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.packageName = ''; + message.hash = new Uint8Array(0); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.Identifier template_id */ 1: + message.templateId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.templateId); + break; + case /* string package_name */ 2: + message.packageName = reader.string(); + break; + case /* com.daml.ledger.api.v2.Value key */ 3: + message.key = Value.internalBinaryRead(reader, reader.uint32(), options, message.key); + break; + case /* bytes hash */ 4: + message.hash = reader.bytes(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.Identifier template_id = 1; */ + if (message.templateId) + Identifier.internalBinaryWrite( + message.templateId, + writer.tag(1, WireType.LengthDelimited).fork(), + options + ).join(); + /* string package_name = 2; */ + if (message.packageName !== '') writer.tag(2, WireType.LengthDelimited).string(message.packageName); + /* com.daml.ledger.api.v2.Value key = 3; */ + if (message.key) + Value.internalBinaryWrite(message.key, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + /* bytes hash = 4; */ + if (message.hash.length) writer.tag(4, WireType.LengthDelimited).bytes(message.hash); + const 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.interactive.GlobalKey + */ +export const GlobalKey = new GlobalKey$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/node/identifier.js b/modules/sdk-coin-canton/resources/proto/node/identifier.js new file mode 100644 index 0000000000..4522d3dabd --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/node/identifier.js @@ -0,0 +1,73 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; + +class Identifier$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.Identifier', [ + { + no: 1, + name: 'package_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 2, + name: 'module_name', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 3, + name: 'entity_name', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.packageId = ''; + message.moduleName = ''; + message.entityName = ''; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string package_id */ 1: + message.packageId = reader.string(); + break; + case /* string module_name */ 2: + message.moduleName = reader.string(); + break; + case /* string entity_name */ 3: + message.entityName = reader.string(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 package_id = 1; */ + if (message.packageId !== '') writer.tag(1, WireType.LengthDelimited).string(message.packageId); + /* string module_name = 2; */ + if (message.moduleName !== '') writer.tag(2, WireType.LengthDelimited).string(message.moduleName); + /* string entity_name = 3; */ + if (message.entityName !== '') writer.tag(3, WireType.LengthDelimited).string(message.entityName); + const 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.Identifier + */ +export const Identifier = new Identifier$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/node/node.js b/modules/sdk-coin-canton/resources/proto/node/node.js new file mode 100644 index 0000000000..9cd862dc55 --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/node/node.js @@ -0,0 +1,656 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { Value } from './value.js'; +import { Identifier } from './identifier.js'; + +class Fetch$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.transaction.v1.Fetch', [ + { + no: 1, + name: 'lf_version', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 2, + name: 'contract_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 3, + name: 'package_name', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 4, + name: 'template_id', + kind: 'message', + T: () => Identifier, + }, + { + no: 5, + name: 'signatories', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 6, + name: 'stakeholders', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 7, + name: 'acting_parties', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 8, + name: 'interface_id', + kind: 'message', + T: () => Identifier, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.lfVersion = ''; + message.contractId = ''; + message.packageName = ''; + message.signatories = []; + message.stakeholders = []; + message.actingParties = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string lf_version */ 1: + message.lfVersion = reader.string(); + break; + case /* string contract_id */ 2: + message.contractId = reader.string(); + break; + case /* string package_name */ 3: + message.packageName = reader.string(); + break; + case /* com.daml.ledger.api.v2.Identifier template_id */ 4: + message.templateId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.templateId); + break; + case /* repeated string signatories */ 5: + message.signatories.push(reader.string()); + break; + case /* repeated string stakeholders */ 6: + message.stakeholders.push(reader.string()); + break; + case /* repeated string acting_parties */ 7: + message.actingParties.push(reader.string()); + break; + case /* com.daml.ledger.api.v2.Identifier interface_id */ 8: + message.interfaceId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.interfaceId); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 lf_version = 1; */ + if (message.lfVersion !== '') writer.tag(1, WireType.LengthDelimited).string(message.lfVersion); + /* string contract_id = 2; */ + if (message.contractId !== '') writer.tag(2, WireType.LengthDelimited).string(message.contractId); + /* string package_name = 3; */ + if (message.packageName !== '') writer.tag(3, WireType.LengthDelimited).string(message.packageName); + /* com.daml.ledger.api.v2.Identifier template_id = 4; */ + if (message.templateId) + Identifier.internalBinaryWrite( + message.templateId, + writer.tag(4, WireType.LengthDelimited).fork(), + options + ).join(); + /* repeated string signatories = 5; */ + for (let i = 0; i < message.signatories.length; i++) + writer.tag(5, WireType.LengthDelimited).string(message.signatories[i]); + /* repeated string stakeholders = 6; */ + for (let i = 0; i < message.stakeholders.length; i++) + writer.tag(6, WireType.LengthDelimited).string(message.stakeholders[i]); + /* repeated string acting_parties = 7; */ + for (let i = 0; i < message.actingParties.length; i++) + writer.tag(7, WireType.LengthDelimited).string(message.actingParties[i]); + /* com.daml.ledger.api.v2.Identifier interface_id = 8; */ + if (message.interfaceId) + Identifier.internalBinaryWrite( + message.interfaceId, + writer.tag(8, WireType.LengthDelimited).fork(), + options + ).join(); + const 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.interactive.transaction.v1.Fetch + */ +export const Fetch = new Fetch$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Exercise$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.transaction.v1.Exercise', [ + { + no: 1, + name: 'lf_version', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 2, + name: 'contract_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 3, + name: 'package_name', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 4, + name: 'template_id', + kind: 'message', + T: () => Identifier, + }, + { + no: 5, + name: 'signatories', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 6, + name: 'stakeholders', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 7, + name: 'acting_parties', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 8, + name: 'interface_id', + kind: 'message', + T: () => Identifier, + }, + { + no: 9, + name: 'choice_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { no: 10, name: 'chosen_value', kind: 'message', T: () => Value }, + { + no: 11, + name: 'consuming', + kind: 'scalar', + T: 8 /*ScalarType.BOOL*/, + }, + { + no: 12, + name: 'children', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 13, + name: 'exercise_result', + kind: 'message', + T: () => Value, + }, + { + no: 14, + name: 'choice_observers', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.lfVersion = ''; + message.contractId = ''; + message.packageName = ''; + message.signatories = []; + message.stakeholders = []; + message.actingParties = []; + message.choiceId = ''; + message.consuming = false; + message.children = []; + message.choiceObservers = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string lf_version */ 1: + message.lfVersion = reader.string(); + break; + case /* string contract_id */ 2: + message.contractId = reader.string(); + break; + case /* string package_name */ 3: + message.packageName = reader.string(); + break; + case /* com.daml.ledger.api.v2.Identifier template_id */ 4: + message.templateId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.templateId); + break; + case /* repeated string signatories */ 5: + message.signatories.push(reader.string()); + break; + case /* repeated string stakeholders */ 6: + message.stakeholders.push(reader.string()); + break; + case /* repeated string acting_parties */ 7: + message.actingParties.push(reader.string()); + break; + case /* com.daml.ledger.api.v2.Identifier interface_id */ 8: + message.interfaceId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.interfaceId); + break; + case /* string choice_id */ 9: + message.choiceId = reader.string(); + break; + case /* com.daml.ledger.api.v2.Value chosen_value */ 10: + message.chosenValue = Value.internalBinaryRead(reader, reader.uint32(), options, message.chosenValue); + break; + case /* bool consuming */ 11: + message.consuming = reader.bool(); + break; + case /* repeated string children */ 12: + message.children.push(reader.string()); + break; + case /* com.daml.ledger.api.v2.Value exercise_result */ 13: + message.exerciseResult = Value.internalBinaryRead(reader, reader.uint32(), options, message.exerciseResult); + break; + case /* repeated string choice_observers */ 14: + message.choiceObservers.push(reader.string()); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 lf_version = 1; */ + if (message.lfVersion !== '') writer.tag(1, WireType.LengthDelimited).string(message.lfVersion); + /* string contract_id = 2; */ + if (message.contractId !== '') writer.tag(2, WireType.LengthDelimited).string(message.contractId); + /* string package_name = 3; */ + if (message.packageName !== '') writer.tag(3, WireType.LengthDelimited).string(message.packageName); + /* com.daml.ledger.api.v2.Identifier template_id = 4; */ + if (message.templateId) + Identifier.internalBinaryWrite( + message.templateId, + writer.tag(4, WireType.LengthDelimited).fork(), + options + ).join(); + /* repeated string signatories = 5; */ + for (let i = 0; i < message.signatories.length; i++) + writer.tag(5, WireType.LengthDelimited).string(message.signatories[i]); + /* repeated string stakeholders = 6; */ + for (let i = 0; i < message.stakeholders.length; i++) + writer.tag(6, WireType.LengthDelimited).string(message.stakeholders[i]); + /* repeated string acting_parties = 7; */ + for (let i = 0; i < message.actingParties.length; i++) + writer.tag(7, WireType.LengthDelimited).string(message.actingParties[i]); + /* com.daml.ledger.api.v2.Identifier interface_id = 8; */ + if (message.interfaceId) + Identifier.internalBinaryWrite( + message.interfaceId, + writer.tag(8, WireType.LengthDelimited).fork(), + options + ).join(); + /* string choice_id = 9; */ + if (message.choiceId !== '') writer.tag(9, WireType.LengthDelimited).string(message.choiceId); + /* com.daml.ledger.api.v2.Value chosen_value = 10; */ + if (message.chosenValue) + Value.internalBinaryWrite(message.chosenValue, writer.tag(10, WireType.LengthDelimited).fork(), options).join(); + /* bool consuming = 11; */ + if (message.consuming !== false) writer.tag(11, WireType.Varint).bool(message.consuming); + /* repeated string children = 12; */ + for (let i = 0; i < message.children.length; i++) + writer.tag(12, WireType.LengthDelimited).string(message.children[i]); + /* com.daml.ledger.api.v2.Value exercise_result = 13; */ + if (message.exerciseResult) + Value.internalBinaryWrite( + message.exerciseResult, + writer.tag(13, WireType.LengthDelimited).fork(), + options + ).join(); + /* repeated string choice_observers = 14; */ + for (let i = 0; i < message.choiceObservers.length; i++) + writer.tag(14, WireType.LengthDelimited).string(message.choiceObservers[i]); + const 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.interactive.transaction.v1.Exercise + */ +export const Exercise = new Exercise$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Create$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.transaction.v1.Create', [ + { + no: 1, + name: 'lf_version', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 2, + name: 'contract_id', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 3, + name: 'package_name', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 4, + name: 'template_id', + kind: 'message', + T: () => Identifier, + }, + { no: 5, name: 'argument', kind: 'message', T: () => Value }, + { + no: 6, + name: 'signatories', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 7, + name: 'stakeholders', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.lfVersion = ''; + message.contractId = ''; + message.packageName = ''; + message.signatories = []; + message.stakeholders = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string lf_version */ 1: + message.lfVersion = reader.string(); + break; + case /* string contract_id */ 2: + message.contractId = reader.string(); + break; + case /* string package_name */ 3: + message.packageName = reader.string(); + break; + case /* com.daml.ledger.api.v2.Identifier template_id */ 4: + message.templateId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.templateId); + break; + case /* com.daml.ledger.api.v2.Value argument */ 5: + message.argument = Value.internalBinaryRead(reader, reader.uint32(), options, message.argument); + break; + case /* repeated string signatories */ 6: + message.signatories.push(reader.string()); + break; + case /* repeated string stakeholders */ 7: + message.stakeholders.push(reader.string()); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 lf_version = 1; */ + if (message.lfVersion !== '') writer.tag(1, WireType.LengthDelimited).string(message.lfVersion); + /* string contract_id = 2; */ + if (message.contractId !== '') writer.tag(2, WireType.LengthDelimited).string(message.contractId); + /* string package_name = 3; */ + if (message.packageName !== '') writer.tag(3, WireType.LengthDelimited).string(message.packageName); + /* com.daml.ledger.api.v2.Identifier template_id = 4; */ + if (message.templateId) + Identifier.internalBinaryWrite( + message.templateId, + writer.tag(4, WireType.LengthDelimited).fork(), + options + ).join(); + /* com.daml.ledger.api.v2.Value argument = 5; */ + if (message.argument) + Value.internalBinaryWrite(message.argument, writer.tag(5, WireType.LengthDelimited).fork(), options).join(); + /* repeated string signatories = 6; */ + for (let i = 0; i < message.signatories.length; i++) + writer.tag(6, WireType.LengthDelimited).string(message.signatories[i]); + /* repeated string stakeholders = 7; */ + for (let i = 0; i < message.stakeholders.length; i++) + writer.tag(7, WireType.LengthDelimited).string(message.stakeholders[i]); + const 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.interactive.transaction.v1.Create + */ +export const Create = new Create$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Rollback$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.transaction.v1.Rollback', [ + { + no: 1, + name: 'children', + kind: 'scalar', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.children = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated string children */ 1: + message.children.push(reader.string()); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* repeated string children = 1; */ + for (let i = 0; i < message.children.length; i++) + writer.tag(1, WireType.LengthDelimited).string(message.children[i]); + const 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.interactive.transaction.v1.Rollback + */ +export const Rollback = new Rollback$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Node$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.transaction.v1.Node', [ + { + no: 1, + name: 'create', + kind: 'message', + oneof: 'nodeType', + T: () => Create, + }, + { + no: 2, + name: 'fetch', + kind: 'message', + oneof: 'nodeType', + T: () => Fetch, + }, + { + no: 3, + name: 'exercise', + kind: 'message', + oneof: 'nodeType', + T: () => Exercise, + }, + { + no: 4, + name: 'rollback', + kind: 'message', + oneof: 'nodeType', + T: () => Rollback, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.nodeType = { oneofKind: undefined }; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.interactive.transaction.v1.Create create */ 1: + message.nodeType = { + oneofKind: 'create', + create: Create.internalBinaryRead(reader, reader.uint32(), options, message.nodeType.create), + }; + break; + case /* com.daml.ledger.api.v2.interactive.transaction.v1.Fetch fetch */ 2: + message.nodeType = { + oneofKind: 'fetch', + fetch: Fetch.internalBinaryRead(reader, reader.uint32(), options, message.nodeType.fetch), + }; + break; + case /* com.daml.ledger.api.v2.interactive.transaction.v1.Exercise exercise */ 3: + message.nodeType = { + oneofKind: 'exercise', + exercise: Exercise.internalBinaryRead(reader, reader.uint32(), options, message.nodeType.exercise), + }; + break; + case /* com.daml.ledger.api.v2.interactive.transaction.v1.Rollback rollback */ 4: + message.nodeType = { + oneofKind: 'rollback', + rollback: Rollback.internalBinaryRead(reader, reader.uint32(), options, message.nodeType.rollback), + }; + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.interactive.transaction.v1.Create create = 1; */ + if (message.nodeType.oneofKind === 'create') + Create.internalBinaryWrite( + message.nodeType.create, + writer.tag(1, WireType.LengthDelimited).fork(), + options + ).join(); + /* com.daml.ledger.api.v2.interactive.transaction.v1.Fetch fetch = 2; */ + if (message.nodeType.oneofKind === 'fetch') + Fetch.internalBinaryWrite(message.nodeType.fetch, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* com.daml.ledger.api.v2.interactive.transaction.v1.Exercise exercise = 3; */ + if (message.nodeType.oneofKind === 'exercise') + Exercise.internalBinaryWrite( + message.nodeType.exercise, + writer.tag(3, WireType.LengthDelimited).fork(), + options + ).join(); + /* com.daml.ledger.api.v2.interactive.transaction.v1.Rollback rollback = 4; */ + if (message.nodeType.oneofKind === 'rollback') + Rollback.internalBinaryWrite( + message.nodeType.rollback, + writer.tag(4, WireType.LengthDelimited).fork(), + options + ).join(); + const 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.interactive.transaction.v1.Node + */ +export const Node = new Node$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/node/timestamp.js b/modules/sdk-coin-canton/resources/proto/node/timestamp.js new file mode 100644 index 0000000000..15462022da --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/node/timestamp.js @@ -0,0 +1,145 @@ +import { + MessageType, + UnknownFieldHandler, + reflectionMergePartial, + WireType, + PbLong, + typeofJsonValue, +} from '@protobuf-ts/runtime'; + +class Timestamp$Type extends MessageType { + constructor() { + super('google.protobuf.Timestamp', [ + { + no: 1, + name: 'seconds', + kind: 'scalar', + T: 3 /*ScalarType.INT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ }, + ]); + } + /** + * Creates a new `Timestamp` for the current time. + */ + now() { + const msg = this.create(); + const ms = Date.now(); + msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt(); + msg.nanos = (ms % 1000) * 1000000; + return msg; + } + /** + * Converts a `Timestamp` to a JavaScript Date. + */ + toDate(message) { + return new Date(PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000)); + } + /** + * Converts a JavaScript Date to a `Timestamp`. + */ + fromDate(date) { + const msg = this.create(); + const ms = date.getTime(); + msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt(); + msg.nanos = ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000; + return msg; + } + /** + * In JSON format, the `Timestamp` type is encoded as a string + * in the RFC 3339 format. + */ + internalJsonWrite(message, options) { + const ms = PbLong.from(message.seconds).toNumber() * 1000; + if (ms < Date.parse('0001-01-01T00:00:00Z') || ms > Date.parse('9999-12-31T23:59:59Z')) + throw new Error( + 'Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.' + ); + if (message.nanos < 0) throw new Error('Unable to encode invalid Timestamp to JSON. Nanos must not be negative.'); + let z = 'Z'; + if (message.nanos > 0) { + const nanosStr = (message.nanos + 1000000000).toString().substring(1); + if (nanosStr.substring(3) === '000000') z = '.' + nanosStr.substring(0, 3) + 'Z'; + else if (nanosStr.substring(6) === '000') z = '.' + nanosStr.substring(0, 6) + 'Z'; + else z = '.' + nanosStr + 'Z'; + } + return new Date(ms).toISOString().replace('.000Z', z); + } + /** + * In JSON format, the `Timestamp` type is encoded as a string + * in the RFC 3339 format. + */ + internalJsonRead(json, options, target) { + if (typeof json !== 'string') throw new Error('Unable to parse Timestamp from JSON ' + typeofJsonValue(json) + '.'); + const matches = json.match( + /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/ + ); + if (!matches) throw new Error('Unable to parse Timestamp from JSON. Invalid format.'); + const ms = Date.parse( + matches[1] + + '-' + + matches[2] + + '-' + + matches[3] + + 'T' + + matches[4] + + ':' + + matches[5] + + ':' + + matches[6] + + (matches[8] ? matches[8] : 'Z') + ); + if (Number.isNaN(ms)) throw new Error('Unable to parse Timestamp from JSON. Invalid value.'); + if (ms < Date.parse('0001-01-01T00:00:00Z') || ms > Date.parse('9999-12-31T23:59:59Z')) + throw new Error( + 'Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.' + ); + if (!target) target = this.create(); + target.seconds = PbLong.from(ms / 1000).toBigInt(); + target.nanos = 0; + if (matches[7]) target.nanos = parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length), 10) - 1000000000; + return target; + } + create(value) { + const message = Object.create(this.messagePrototype); + message.seconds = 0n; + message.nanos = 0; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* int64 seconds */ 1: + message.seconds = reader.int64().toBigInt(); + break; + case /* int32 nanos */ 2: + message.nanos = reader.int32(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* int64 seconds = 1; */ + if (message.seconds !== 0n) writer.tag(1, WireType.Varint).int64(message.seconds); + /* int32 nanos = 2; */ + if (message.nanos !== 0) writer.tag(2, WireType.Varint).int32(message.nanos); + const u = options.writeUnknownFields; + if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.Timestamp + */ +export const Timestamp = new Timestamp$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/node/value.js b/modules/sdk-coin-canton/resources/proto/node/value.js new file mode 100644 index 0000000000..f85a871f52 --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/node/value.js @@ -0,0 +1,824 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { Empty } from './empty.js'; +import { Identifier } from './identifier.js'; + +class Value$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.Value', [ + { + no: 1, + name: 'unit', + kind: 'message', + oneof: 'sum', + T: () => Empty, + }, + { + no: 2, + name: 'bool', + kind: 'scalar', + oneof: 'sum', + T: 8 /*ScalarType.BOOL*/, + }, + { + no: 3, + name: 'int64', + kind: 'scalar', + oneof: 'sum', + T: 18 /*ScalarType.SINT64*/, + }, + { + no: 4, + name: 'date', + kind: 'scalar', + oneof: 'sum', + T: 5 /*ScalarType.INT32*/, + }, + { + no: 5, + name: 'timestamp', + kind: 'scalar', + oneof: 'sum', + T: 16 /*ScalarType.SFIXED64*/, + }, + { + no: 6, + name: 'numeric', + kind: 'scalar', + oneof: 'sum', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 7, + name: 'party', + kind: 'scalar', + oneof: 'sum', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 8, + name: 'text', + kind: 'scalar', + oneof: 'sum', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 9, + name: 'contract_id', + kind: 'scalar', + oneof: 'sum', + T: 9 /*ScalarType.STRING*/, + }, + { + no: 10, + name: 'optional', + kind: 'message', + oneof: 'sum', + T: () => Optional, + }, + { + no: 11, + name: 'list', + kind: 'message', + oneof: 'sum', + T: () => List, + }, + { + no: 12, + name: 'text_map', + kind: 'message', + oneof: 'sum', + T: () => TextMap, + }, + { + no: 13, + name: 'gen_map', + kind: 'message', + oneof: 'sum', + T: () => GenMap, + }, + { + no: 14, + name: 'record', + kind: 'message', + oneof: 'sum', + T: () => Record, + }, + { + no: 15, + name: 'variant', + kind: 'message', + oneof: 'sum', + T: () => Variant, + }, + { + no: 16, + name: 'enum', + kind: 'message', + oneof: 'sum', + T: () => Enum, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.sum = { oneofKind: undefined }; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* google.protobuf.Empty unit */ 1: + message.sum = { + oneofKind: 'unit', + unit: Empty.internalBinaryRead(reader, reader.uint32(), options, message.sum.unit), + }; + break; + case /* bool bool */ 2: + message.sum = { + oneofKind: 'bool', + bool: reader.bool(), + }; + break; + case /* sint64 int64 = 3 [jstype = JS_STRING] */ 3: + message.sum = { + oneofKind: 'int64', + int64: reader.sint64().toString(), + }; + break; + case /* int32 date */ 4: + message.sum = { + oneofKind: 'date', + date: reader.int32(), + }; + break; + case /* sfixed64 timestamp = 5 [jstype = JS_STRING] */ 5: + message.sum = { + oneofKind: 'timestamp', + timestamp: reader.sfixed64().toString(), + }; + break; + case /* string numeric */ 6: + message.sum = { + oneofKind: 'numeric', + numeric: reader.string(), + }; + break; + case /* string party */ 7: + message.sum = { + oneofKind: 'party', + party: reader.string(), + }; + break; + case /* string text */ 8: + message.sum = { + oneofKind: 'text', + text: reader.string(), + }; + break; + case /* string contract_id */ 9: + message.sum = { + oneofKind: 'contractId', + contractId: reader.string(), + }; + break; + case /* com.daml.ledger.api.v2.Optional optional */ 10: + message.sum = { + oneofKind: 'optional', + optional: Optional.internalBinaryRead(reader, reader.uint32(), options, message.sum.optional), + }; + break; + case /* com.daml.ledger.api.v2.List list */ 11: + message.sum = { + oneofKind: 'list', + list: List.internalBinaryRead(reader, reader.uint32(), options, message.sum.list), + }; + break; + case /* com.daml.ledger.api.v2.TextMap text_map */ 12: + message.sum = { + oneofKind: 'textMap', + textMap: TextMap.internalBinaryRead(reader, reader.uint32(), options, message.sum.textMap), + }; + break; + case /* com.daml.ledger.api.v2.GenMap gen_map */ 13: + message.sum = { + oneofKind: 'genMap', + genMap: GenMap.internalBinaryRead(reader, reader.uint32(), options, message.sum.genMap), + }; + break; + case /* com.daml.ledger.api.v2.Record record */ 14: + message.sum = { + oneofKind: 'record', + record: Record.internalBinaryRead(reader, reader.uint32(), options, message.sum.record), + }; + break; + case /* com.daml.ledger.api.v2.Variant variant */ 15: + message.sum = { + oneofKind: 'variant', + variant: Variant.internalBinaryRead(reader, reader.uint32(), options, message.sum.variant), + }; + break; + case /* com.daml.ledger.api.v2.Enum enum */ 16: + message.sum = { + oneofKind: 'enum', + enum: Enum.internalBinaryRead(reader, reader.uint32(), options, message.sum.enum), + }; + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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.Empty unit = 1; */ + if (message.sum.oneofKind === 'unit') + Empty.internalBinaryWrite(message.sum.unit, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* bool bool = 2; */ + if (message.sum.oneofKind === 'bool') writer.tag(2, WireType.Varint).bool(message.sum.bool); + /* sint64 int64 = 3 [jstype = JS_STRING]; */ + if (message.sum.oneofKind === 'int64') writer.tag(3, WireType.Varint).sint64(message.sum.int64); + /* int32 date = 4; */ + if (message.sum.oneofKind === 'date') writer.tag(4, WireType.Varint).int32(message.sum.date); + /* sfixed64 timestamp = 5 [jstype = JS_STRING]; */ + if (message.sum.oneofKind === 'timestamp') writer.tag(5, WireType.Bit64).sfixed64(message.sum.timestamp); + /* string numeric = 6; */ + if (message.sum.oneofKind === 'numeric') writer.tag(6, WireType.LengthDelimited).string(message.sum.numeric); + /* string party = 7; */ + if (message.sum.oneofKind === 'party') writer.tag(7, WireType.LengthDelimited).string(message.sum.party); + /* string text = 8; */ + if (message.sum.oneofKind === 'text') writer.tag(8, WireType.LengthDelimited).string(message.sum.text); + /* string contract_id = 9; */ + if (message.sum.oneofKind === 'contractId') writer.tag(9, WireType.LengthDelimited).string(message.sum.contractId); + /* com.daml.ledger.api.v2.Optional optional = 10; */ + if (message.sum.oneofKind === 'optional') + Optional.internalBinaryWrite( + message.sum.optional, + writer.tag(10, WireType.LengthDelimited).fork(), + options + ).join(); + /* com.daml.ledger.api.v2.List list = 11; */ + if (message.sum.oneofKind === 'list') + List.internalBinaryWrite(message.sum.list, writer.tag(11, WireType.LengthDelimited).fork(), options).join(); + /* com.daml.ledger.api.v2.TextMap text_map = 12; */ + if (message.sum.oneofKind === 'textMap') + TextMap.internalBinaryWrite(message.sum.textMap, writer.tag(12, WireType.LengthDelimited).fork(), options).join(); + /* com.daml.ledger.api.v2.GenMap gen_map = 13; */ + if (message.sum.oneofKind === 'genMap') + GenMap.internalBinaryWrite(message.sum.genMap, writer.tag(13, WireType.LengthDelimited).fork(), options).join(); + /* com.daml.ledger.api.v2.Record record = 14; */ + if (message.sum.oneofKind === 'record') + Record.internalBinaryWrite(message.sum.record, writer.tag(14, WireType.LengthDelimited).fork(), options).join(); + /* com.daml.ledger.api.v2.Variant variant = 15; */ + if (message.sum.oneofKind === 'variant') + Variant.internalBinaryWrite(message.sum.variant, writer.tag(15, WireType.LengthDelimited).fork(), options).join(); + /* com.daml.ledger.api.v2.Enum enum = 16; */ + if (message.sum.oneofKind === 'enum') + Enum.internalBinaryWrite(message.sum.enum, writer.tag(16, WireType.LengthDelimited).fork(), options).join(); + const 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.Value + */ +export const Value = new Value$Type(); + +class Optional$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.Optional', [{ no: 1, name: 'value', kind: 'message', T: () => Value }]); + } + create(value) { + const message = Object.create(this.messagePrototype); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.Value value */ 1: + message.value = Value.internalBinaryRead(reader, reader.uint32(), options, message.value); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.Value value = 1; */ + if (message.value) + Value.internalBinaryWrite(message.value, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + const 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.Optional + */ +export const Optional = new Optional$Type(); + +class List$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.List', [ + { + no: 1, + name: 'elements', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => Value, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.elements = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated com.daml.ledger.api.v2.Value elements */ 1: + message.elements.push(Value.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* repeated com.daml.ledger.api.v2.Value elements = 1; */ + for (let i = 0; i < message.elements.length; i++) + Value.internalBinaryWrite(message.elements[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + const 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.List + */ +export const List = new List$Type(); + +class TextMap$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.TextMap', [ + { + no: 1, + name: 'entries', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => TextMap_Entry, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.entries = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated com.daml.ledger.api.v2.TextMap.Entry entries */ 1: + message.entries.push(TextMap_Entry.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* repeated com.daml.ledger.api.v2.TextMap.Entry entries = 1; */ + for (let i = 0; i < message.entries.length; i++) + TextMap_Entry.internalBinaryWrite( + message.entries[i], + writer.tag(1, WireType.LengthDelimited).fork(), + options + ).join(); + const 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.TextMap + */ +export const TextMap = new TextMap$Type(); + +class TextMap_Entry$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.TextMap.Entry', [ + { no: 1, name: 'key', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: 'value', kind: 'message', T: () => Value }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.key = ''; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string key */ 1: + message.key = reader.string(); + break; + case /* com.daml.ledger.api.v2.Value value */ 2: + message.value = Value.internalBinaryRead(reader, reader.uint32(), options, message.value); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 key = 1; */ + if (message.key !== '') writer.tag(1, WireType.LengthDelimited).string(message.key); + /* com.daml.ledger.api.v2.Value value = 2; */ + if (message.value) + Value.internalBinaryWrite(message.value, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + const 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.TextMap.Entry + */ +export const TextMap_Entry = new TextMap_Entry$Type(); + +class GenMap$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.GenMap', [ + { + no: 1, + name: 'entries', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => GenMap_Entry, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.entries = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated com.daml.ledger.api.v2.GenMap.Entry entries */ 1: + message.entries.push(GenMap_Entry.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* repeated com.daml.ledger.api.v2.GenMap.Entry entries = 1; */ + for (let i = 0; i < message.entries.length; i++) + GenMap_Entry.internalBinaryWrite( + message.entries[i], + writer.tag(1, WireType.LengthDelimited).fork(), + options + ).join(); + const 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.GenMap + */ +export const GenMap = new GenMap$Type(); + +class GenMap_Entry$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.GenMap.Entry', [ + { no: 1, name: 'key', kind: 'message', T: () => Value }, + { no: 2, name: 'value', kind: 'message', T: () => Value }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.Value key */ 1: + message.key = Value.internalBinaryRead(reader, reader.uint32(), options, message.key); + break; + case /* com.daml.ledger.api.v2.Value value */ 2: + message.value = Value.internalBinaryRead(reader, reader.uint32(), options, message.value); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.Value key = 1; */ + if (message.key) + Value.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* com.daml.ledger.api.v2.Value value = 2; */ + if (message.value) + Value.internalBinaryWrite(message.value, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + const 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.GenMap.Entry + */ +export const GenMap_Entry = new GenMap_Entry$Type(); + +class Record$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.Record', [ + { no: 1, name: 'record_id', kind: 'message', T: () => Identifier }, + { + no: 2, + name: 'fields', + kind: 'message', + repeat: 2 /*RepeatType.UNPACKED*/, + T: () => RecordField, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.fields = []; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.Identifier record_id */ 1: + message.recordId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.recordId); + break; + case /* repeated com.daml.ledger.api.v2.RecordField fields */ 2: + message.fields.push(RecordField.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.Identifier record_id = 1; */ + if (message.recordId) + Identifier.internalBinaryWrite(message.recordId, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* repeated com.daml.ledger.api.v2.RecordField fields = 2; */ + for (let i = 0; i < message.fields.length; i++) + RecordField.internalBinaryWrite( + message.fields[i], + writer.tag(2, WireType.LengthDelimited).fork(), + options + ).join(); + const 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.Record + */ +export const Record = new Record$Type(); + +class RecordField$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.RecordField', [ + { + no: 1, + name: 'label', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { no: 2, name: 'value', kind: 'message', T: () => Value }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.label = ''; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string label */ 1: + message.label = reader.string(); + break; + case /* com.daml.ledger.api.v2.Value value */ 2: + message.value = Value.internalBinaryRead(reader, reader.uint32(), options, message.value); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const 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 label = 1; */ + if (message.label !== '') writer.tag(1, WireType.LengthDelimited).string(message.label); + /* com.daml.ledger.api.v2.Value value = 2; */ + if (message.value) + Value.internalBinaryWrite(message.value, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + const 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.RecordField + */ +export const RecordField = new RecordField$Type(); + +class Variant$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.Variant', [ + { no: 1, name: 'variant_id', kind: 'message', T: () => Identifier }, + { + no: 2, + name: 'constructor', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + { no: 3, name: 'value', kind: 'message', T: () => Value }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.constructor = ''; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.Identifier variant_id */ 1: + message.variantId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.variantId); + break; + case /* string constructor */ 2: + message.constructor = reader.string(); + break; + case /* com.daml.ledger.api.v2.Value value */ 3: + message.value = Value.internalBinaryRead(reader, reader.uint32(), options, message.value); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.Identifier variant_id = 1; */ + if (message.variantId) + Identifier.internalBinaryWrite(message.variantId, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* string constructor = 2; */ + if (message.constructor !== '') writer.tag(2, WireType.LengthDelimited).string(message.constructor); + /* com.daml.ledger.api.v2.Value value = 3; */ + if (message.value) + Value.internalBinaryWrite(message.value, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + const 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.Variant + */ +export const Variant = new Variant$Type(); + +class Enum$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.Enum', [ + { no: 1, name: 'enum_id', kind: 'message', T: () => Identifier }, + { + no: 2, + name: 'constructor', + kind: 'scalar', + T: 9 /*ScalarType.STRING*/, + }, + ]); + } + create(value) { + const message = Object.create(this.messagePrototype); + message.constructor = ''; + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.Identifier enum_id */ 1: + message.enumId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.enumId); + break; + case /* string constructor */ 2: + message.constructor = reader.string(); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.Identifier enum_id = 1; */ + if (message.enumId) + Identifier.internalBinaryWrite(message.enumId, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* string constructor = 2; */ + if (message.constructor !== '') writer.tag(2, WireType.LengthDelimited).string(message.constructor); + const 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.Enum + */ +export const Enum = new Enum$Type(); diff --git a/modules/sdk-coin-canton/resources/proto/preparedTransaction.d.ts b/modules/sdk-coin-canton/resources/proto/preparedTransaction.d.ts new file mode 100644 index 0000000000..e0fa04c012 --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/preparedTransaction.d.ts @@ -0,0 +1,8 @@ +declare module '../../resources/proto/preparedTransaction.js' { + import { MessageType } from '@protobuf-ts/runtime'; + import { PreparedTransaction as IPreparedTransaction } from '../../src/lib/iface'; + + export const PreparedTransaction: MessageType; +} + +export {}; diff --git a/modules/sdk-coin-canton/resources/proto/preparedTransaction.js b/modules/sdk-coin-canton/resources/proto/preparedTransaction.js new file mode 100644 index 0000000000..d819280050 --- /dev/null +++ b/modules/sdk-coin-canton/resources/proto/preparedTransaction.js @@ -0,0 +1,66 @@ +import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime'; +import { DamlTransaction } from './damlTransaction.js'; +import { Metadata } from './metadata.js'; + +class PreparedTransaction$Type extends MessageType { + constructor() { + super('com.daml.ledger.api.v2.interactive.PreparedTransaction', [ + { + no: 1, + name: 'transaction', + kind: 'message', + T: () => DamlTransaction, + }, + { no: 2, name: 'metadata', kind: 'message', T: () => Metadata }, + ]); + } + + create(value) { + const message = Object.create(this.messagePrototype); + if (value !== undefined) reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + const message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + const [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* com.daml.ledger.api.v2.interactive.DamlTransaction transaction */ 1: + message.transaction = DamlTransaction.internalBinaryRead( + reader, + reader.uint32(), + options, + message.transaction + ); + break; + case /* com.daml.ledger.api.v2.interactive.Metadata metadata */ 2: + message.metadata = Metadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + default: + const u = options.readUnknownField; + if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + const d = reader.skip(wireType); + if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* com.daml.ledger.api.v2.interactive.DamlTransaction transaction = 1; */ + if (message.transaction) + DamlTransaction.internalBinaryWrite( + message.transaction, + writer.tag(1, WireType.LengthDelimited).fork(), + options + ).join(); + /* com.daml.ledger.api.v2.interactive.Metadata metadata = 2; */ + if (message.metadata) + Metadata.internalBinaryWrite(message.metadata, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + const u = options.writeUnknownFields; + if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} + +export const PreparedTransaction = new PreparedTransaction$Type(); diff --git a/modules/sdk-coin-canton/src/lib/iface.ts b/modules/sdk-coin-canton/src/lib/iface.ts index 546ef821e8..971feab1f1 100644 --- a/modules/sdk-coin-canton/src/lib/iface.ts +++ b/modules/sdk-coin-canton/src/lib/iface.ts @@ -1,6 +1,43 @@ +import { TransactionType } from '@bitgo/sdk-core'; +import { DamlTransaction, Metadata } from './resourcesInterface'; + /** * The transaction data returned from the toJson() function of a transaction */ export interface TxData { id: string; + type: TransactionType; + sender: string; + receiver: string; +} + +export interface PreparedTxnParsedInfo { + sender: string; + receiver: string; + amount: string; +} + +export interface WalletInitializationDataTxData { + id: string; + type: TransactionType; +} + +export interface CantonPrepareCommandResponse { + preparedTransaction?: string; + preparedTransactionHash: string; + hashingSchemeVersion: string; + hashingDetails?: string; +} + +export interface PreparedParty { + partyTransactions: Uint8Array[]; + combinedHash: string; + txHashes: Buffer[]; + namespace: string; + partyId: string; +} + +export interface PreparedTransaction { + transaction?: DamlTransaction; + metadata?: Metadata; } diff --git a/modules/sdk-coin-canton/src/lib/keyPair.ts b/modules/sdk-coin-canton/src/lib/keyPair.ts index 604d0a6d40..7f6b2e1d86 100644 --- a/modules/sdk-coin-canton/src/lib/keyPair.ts +++ b/modules/sdk-coin-canton/src/lib/keyPair.ts @@ -10,6 +10,7 @@ export class KeyPair extends Ed25519KeyPair { constructor(source?: KeyPairOptions) { super(source); } + /** @inheritdoc */ getKeys(): DefaultKeys { const result: DefaultKeys = { pub: this.keyPair.pub }; diff --git a/modules/sdk-coin-canton/src/lib/resourcesInterface.ts b/modules/sdk-coin-canton/src/lib/resourcesInterface.ts new file mode 100644 index 0000000000..5d71d661c6 --- /dev/null +++ b/modules/sdk-coin-canton/src/lib/resourcesInterface.ts @@ -0,0 +1,263 @@ +export interface Metadata { + submitterInfo?: Metadata_SubmitterInfo; + synchronizerId: string; + mediatorGroup: number; + transactionUuid: string; + preparationTime: bigint; + inputContracts: Metadata_InputContract[]; + minLedgerEffectiveTime?: bigint; + maxLedgerEffectiveTime?: bigint; + globalKeyMapping: Metadata_GlobalKeyMappingEntry[]; + maxRecordTime?: bigint; +} + +interface Metadata_SubmitterInfo { + actAs: string[]; + commandId: string; +} + +interface Metadata_InputContract { + contract: + | { + oneofKind: 'v1'; + v1: Create; + } + | { + oneofKind: undefined; + }; + createdAt: bigint; + eventBlob: Uint8Array; +} + +interface Create { + lfVersion: string; + contractId: string; + packageName: string; + templateId?: Identifier; + argument?: Value; + signatories: string[]; + stakeholders: string[]; +} + +interface Metadata_GlobalKeyMappingEntry { + key?: GlobalKey; + value?: Value; +} + +interface GlobalKey { + templateId?: Identifier; + packageName: string; + key?: Value; + hash: Uint8Array; +} + +interface Identifier { + packageId: string; + moduleName: string; + entityName: string; +} + +interface Value { + sum: + | { + oneofKind: 'unit'; + unit: Empty; + } + | { + oneofKind: 'bool'; + bool: boolean; + } + | { + oneofKind: 'int64'; + int64: string; + } + | { + oneofKind: 'date'; + date: number; + } + | { + oneofKind: 'timestamp'; + timestamp: string; + } + | { + oneofKind: 'numeric'; + numeric: string; + } + | { + oneofKind: 'party'; + party: string; + } + | { + oneofKind: 'text'; + text: string; + } + | { + oneofKind: 'contractId'; + contractId: string; + } + | { + oneofKind: 'optional'; + optional: Optional; + } + | { + oneofKind: 'list'; + list: List; + } + | { + oneofKind: 'textMap'; + textMap: TextMap; + } + | { + oneofKind: 'genMap'; + genMap: GenMap; + } + | { + oneofKind: 'record'; + record: Record; + } + | { + oneofKind: 'variant'; + variant: Variant; + } + | { + oneofKind: 'enum'; + enum: Enum; + } + | { + oneofKind: undefined; + }; +} + +// eslint-disable-next-line @typescript-eslint/no-empty-interface +interface Empty {} + +interface Optional { + value?: Value; +} + +interface List { + elements: Value[]; +} + +interface TextMap { + entries: TextMap_Entry[]; +} + +interface TextMap_Entry { + key: string; + value?: Value; +} + +interface GenMap { + entries: GenMap_Entry[]; +} + +interface GenMap_Entry { + key?: Value; + value?: Value; +} + +interface Record { + recordId?: Identifier; + fields: RecordField[]; +} + +export interface RecordField { + label: string; + value?: Value; +} + +interface Variant { + variantId?: Identifier; + constructor: string; + value?: Value; +} + +interface Enum { + enumId?: Identifier; + constructor: string; +} + +export interface DamlTransaction { + version: string; + roots: string[]; + nodes: DamlTransaction_Node[]; + nodeSeeds: DamlTransaction_NodeSeed[]; +} + +interface DamlTransaction_Node { + nodeId: string; + /** + * Versioned node + * + * @generated from protobuf oneof: versioned_node + */ + versionedNode: + | { + oneofKind: 'v1'; + v1: Node; + } + | { + oneofKind: undefined; + }; +} + +interface Node { + nodeType: + | { + oneofKind: 'create'; + create: Create; + } + | { + oneofKind: 'fetch'; + fetch: Fetch; + } + | { + oneofKind: 'exercise'; + exercise: Exercise; + } + | { + oneofKind: 'rollback'; + rollback: Rollback; + } + | { + oneofKind: undefined; + }; +} + +interface Fetch { + lfVersion: string; + contractId: string; + packageName: string; + templateId?: Identifier; + signatories: string[]; + stakeholders: string[]; + actingParties: string[]; + interfaceId?: Identifier; +} + +interface Exercise { + lfVersion: string; + contractId: string; + packageName: string; + templateId?: Identifier; + signatories: string[]; + stakeholders: string[]; + actingParties: string[]; + interfaceId?: Identifier; + choiceId: string; + chosenValue?: Value; + consuming: boolean; + children: string[]; + exerciseResult?: Value; + choiceObservers: string[]; +} + +interface Rollback { + children: string[]; +} + +interface DamlTransaction_NodeSeed { + nodeId: number; + seed: Uint8Array; +} diff --git a/modules/sdk-coin-canton/src/lib/transaction.ts b/modules/sdk-coin-canton/src/lib/transaction.ts index 431c397b49..b27b63c102 100644 --- a/modules/sdk-coin-canton/src/lib/transaction.ts +++ b/modules/sdk-coin-canton/src/lib/transaction.ts @@ -1,16 +1,54 @@ -import { BaseKey, BaseTransaction } from '@bitgo/sdk-core'; -import { TxData } from './iface'; +import { BaseKey, BaseTransaction, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core'; +import { BaseCoin as CoinConfig } from '@bitgo/statics'; +import { CantonPrepareCommandResponse, PreparedTxnParsedInfo, TxData } from './iface'; +import utils from './utils'; export class Transaction extends BaseTransaction { + private _transaction: CantonPrepareCommandResponse; + + constructor(coinConfig: Readonly) { + super(coinConfig); + } + + get transaction(): CantonPrepareCommandResponse { + return this._transaction; + } + + set transaction(transaction: CantonPrepareCommandResponse) { + this._transaction = transaction; + this._id = transaction.preparedTransactionHash; + } + canSign(key: BaseKey): boolean { return false; } toBroadcastFormat(): string { - throw new Error('Method not implemented.'); + if (!this._transaction) { + throw new InvalidTransactionError('Empty transaction data'); + } + return this._transaction.preparedTransactionHash; } toJson(): TxData { - throw new Error('Method not implemented.'); + if (!this._transaction || !this._transaction.preparedTransaction) { + throw new InvalidTransactionError('Empty transaction data'); + } + const result: TxData = { + id: this.id, + type: this._type as TransactionType, + sender: '', + receiver: '', + }; + // TODO: extract other required data (utxo used, request time, execute before etc) + let parsedInfo: PreparedTxnParsedInfo; + try { + parsedInfo = utils.parseRawCantonTransactionData(this._transaction.preparedTransaction); + } catch (e) { + throw new InvalidTransactionError(`Failed to parse transaction hash: ${e instanceof Error ? e.message : e}`); + } + result.sender = parsedInfo.sender; + result.receiver = parsedInfo.receiver; + return result; } } diff --git a/modules/sdk-coin-canton/src/lib/utils.ts b/modules/sdk-coin-canton/src/lib/utils.ts index 5e86128561..ececacba07 100644 --- a/modules/sdk-coin-canton/src/lib/utils.ts +++ b/modules/sdk-coin-canton/src/lib/utils.ts @@ -1,6 +1,12 @@ -import { BaseUtils, isValidEd25519PublicKey } from '@bitgo/sdk-core'; import crypto from 'crypto'; + +import { BaseUtils, isValidEd25519PublicKey } from '@bitgo/sdk-core'; + +import { PreparedTransaction } from '../../resources/proto/preparedTransaction.js'; + import { CryptoKeyFormat, SigningAlgorithmSpec, SigningKeySpec } from './constant'; +import { PreparedTransaction as IPreparedTransaction, PreparedTxnParsedInfo } from './iface'; +import { RecordField } from './resourcesInterface'; export class Utils implements BaseUtils { /** @inheritdoc */ @@ -33,6 +39,79 @@ export class Utils implements BaseUtils { throw new Error('Method not implemented.'); } + /** + * Method to create fingerprint (part of the canton partyId) from public key + * @param {String} publicKey the public key + * @returns {String} + */ + getAddressFromPublicKey(publicKey: string): string { + const key = this.signingPublicKeyFromEd25519(publicKey); + const hashPurpose = 12; + return this.computeSha256CantonHash(hashPurpose, key.publicKey); + } + + /** + * Method to parse raw canton transaction & get required data + * @param {String} rawData base64 encoded string + * @returns {PreparedTxnParsedInfo} + */ + parseRawCantonTransactionData(rawData: string): PreparedTxnParsedInfo { + const decodedData = this.decodePreparedTransaction(rawData); + let sender = ''; + let receiver = ''; + let amount = ''; + decodedData.transaction?.nodes?.forEach((node) => { + const versionedNode = node.versionedNode; + if (!versionedNode || versionedNode.oneofKind !== 'v1') return; + + const v1Node = versionedNode.v1; + const nodeType = v1Node.nodeType; + + if (nodeType.oneofKind !== 'create') return; + + const createNode = nodeType.create; + + // Check if it's the correct template + const template = createNode.templateId; + if (template?.entityName !== 'AmuletTransferInstruction') return; + + // Now parse the 'create' argument + if (createNode.argument?.sum?.oneofKind !== 'record') return; + const fields = createNode.argument?.sum?.record?.fields; + if (!fields) return; + + // Find the 'transfer' field + const transferField = fields.find((f) => f.label === 'transfer'); + if (transferField?.value?.sum?.oneofKind !== 'record') return; + const transferRecord = transferField?.value?.sum?.record?.fields; + if (!transferRecord) return; + + const getField = (fields: RecordField[], label: string) => fields.find((f) => f.label === label)?.value?.sum; + + const senderData = getField(transferRecord, 'sender'); + if (!senderData || senderData.oneofKind !== 'party') return; + sender = senderData.party; + const receiverData = getField(transferRecord, 'receiver'); + if (!receiverData || receiverData.oneofKind !== 'party') return; + receiver = receiverData.party; + const amountData = getField(transferRecord, 'amount'); + if (!amountData || amountData.oneofKind !== 'numeric') return; + amount = amountData.numeric; + }); + if (!sender || !receiver || !amount) { + const missingFields: string[] = []; + if (!sender) missingFields.push('sender'); + if (!receiver) missingFields.push('receiver'); + if (!amount) missingFields.push('amount'); + throw new Error(`invalid transaction data: missing ${missingFields.join(', ')}`); + } + return { + sender, + receiver, + amount, + }; + } + /** * Converts a base64-encoded Ed25519 public key string into a structured signing public key object. * @param {String} publicKey The base64-encoded Ed25519 public key @@ -86,14 +165,24 @@ export class Utils implements BaseUtils { } /** - * Method to create fingerprint (part of the canton partyId) from public key - * @param {String} publicKey the public key - * @returns {String} + * Decodes a Base64-encoded string into a Uint8Array + * @param {String} b64 The Base64-encoded string + * @returns {Uint8Array} The decoded byte array + * @private */ - getAddressFromPublicKey(publicKey: string): string { - const key = this.signingPublicKeyFromEd25519(publicKey); - const hashPurpose = 12; - return this.computeSha256CantonHash(hashPurpose, key.publicKey); + private fromBase64(b64: string): Uint8Array { + return new Uint8Array(Buffer.from(b64, 'base64')); + } + + /** + * Decodes a Base64-encoded prepared transaction into a structured object + * @param {String} base64 The Base64-encoded transaction data + * @returns {IPreparedTransaction} The decoded `IPreparedTransaction` object + * @private + */ + private decodePreparedTransaction(base64: string): IPreparedTransaction { + const bytes = this.fromBase64(base64); + return PreparedTransaction.fromBinary(bytes); } } diff --git a/modules/sdk-coin-canton/src/lib/walletInitialization/walletInitializationTransaction.ts b/modules/sdk-coin-canton/src/lib/walletInitialization/walletInitializationTransaction.ts new file mode 100644 index 0000000000..9ac541d622 --- /dev/null +++ b/modules/sdk-coin-canton/src/lib/walletInitialization/walletInitializationTransaction.ts @@ -0,0 +1,43 @@ +import { BaseKey, BaseTransaction, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core'; +import { BaseCoin as CoinConfig } from '@bitgo/statics'; +import { PreparedParty, WalletInitializationDataTxData } from '../iface'; + +export class WalletInitializationTransaction extends BaseTransaction { + private _transaction: PreparedParty; + + constructor(coinConfig: Readonly) { + super(coinConfig); + } + + get transaction(): PreparedParty { + return this._transaction; + } + + set transaction(transaction: PreparedParty) { + this._transaction = transaction; + this._id = transaction.combinedHash; + } + + canSign(key: BaseKey): boolean { + return false; + } + + toBroadcastFormat(): string { + if (!this._transaction) { + throw new InvalidTransactionError('Empty transaction data'); + } + return this._transaction.combinedHash; + } + + toJson(): WalletInitializationDataTxData { + if (!this._transaction) { + throw new InvalidTransactionError('Empty transaction data'); + } + const result: WalletInitializationDataTxData = { + id: this.id, + type: this._type as TransactionType, + }; + // Add logic to parse the preparedTransaction & extract sender, receiver + return result; + } +} diff --git a/modules/sdk-coin-canton/test/resources.ts b/modules/sdk-coin-canton/test/resources.ts new file mode 100644 index 0000000000..1df289153c --- /dev/null +++ b/modules/sdk-coin-canton/test/resources.ts @@ -0,0 +1,2 @@ +export const PreparedTransactionRawData = + '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'; diff --git a/modules/sdk-coin-canton/test/unit/utils.ts b/modules/sdk-coin-canton/test/unit/utils.ts new file mode 100644 index 0000000000..3afaf9b80f --- /dev/null +++ b/modules/sdk-coin-canton/test/unit/utils.ts @@ -0,0 +1,16 @@ +import assert from 'assert'; +import should from 'should'; +import utils from '../../src/lib/utils'; +import { PreparedTransactionRawData } from '../resources'; + +describe('Canton Util', function () { + describe('Raw transaction parser', function () { + it('should parse the prepared transaction', () => { + const parsedData = utils.parseRawCantonTransactionData(PreparedTransactionRawData); + should.exist(parsedData); + assert.equal(parsedData.sender, 'abc-1::12200c1ee226fbdf9fba3461c2c0c73331b69d3c6fd8cfce28cdf864141141cc656d'); + assert.equal(parsedData.receiver, 'abc-2::12207e96ada18a845adf4dc01410265633d5266dca9bb280c98e35c3692db87d3e35'); + assert.equal(parsedData.amount, '20.0000000000'); + }); + }); +}); diff --git a/modules/sdk-coin-canton/tsconfig.json b/modules/sdk-coin-canton/tsconfig.json index 64aeea134a..b967e45713 100644 --- a/modules/sdk-coin-canton/tsconfig.json +++ b/modules/sdk-coin-canton/tsconfig.json @@ -7,7 +7,7 @@ "esModuleInterop": true, "typeRoots": ["../../types", "./node_modules/@types", "../../node_modules/@types"] }, - "include": ["src/**/*", "test/**/*"], + "include": ["src/**/*", "test/**/*", "resources/**/*"], "exclude": ["node_modules"], "references": [ { diff --git a/yarn.lock b/yarn.lock index 9d6d4e85b0..cf68cafe5f 100644 --- a/yarn.lock +++ b/yarn.lock @@ -4769,6 +4769,11 @@ tslib "^2.8.0" ws "^8.18.0" +"@protobuf-ts/runtime@^2.11.1": + version "2.11.1" + resolved "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.11.1.tgz#ee2bf2fac6e2d8deac0ca63471a77481548e5553" + integrity sha512-KuDaT1IfHkugM2pyz+FwiY80ejWrkH1pAtOBOZFuR6SXEFTsnb/jiQWQ1rCIrcKx2BtyxnxW6BWwsVSA/Ie+WQ== + "@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2": version "1.1.2" resolved "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz"