feat(sdk-coin-canton): added transaction class and local parser for prepared transaction data

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": {

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();

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();

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();