ripple-binary-codec refactor (#88)

Refactored all components in ripple-binary-codec /src

packages/ripple-binary-codec/src/binary.ts

@@ -1,36 +1,107 @@
 /* eslint-disable func-style */
 
 import { coreTypes } from "./types";
-const { HashPrefix } = require("./hash-prefixes");
-const { BinaryParser } = require("./serdes/binary-parser");
-const { BinarySerializer, BytesList } = require("./serdes/binary-serializer");
-const { bytesToHex, slice, parseBytes } = require("./utils/bytes-utils");
+import { BinaryParser } from "./serdes/binary-parser";
+import { AccountID } from "./types/account-id";
+import { HashPrefix } from "./hash-prefixes";
+import { BinarySerializer, BytesList } from "./serdes/binary-serializer";
+import { sha512Half, transactionID } from "./hashes";
+import { FieldInstance } from "./enums";
+import { STObject } from "./types/st-object";
+import { JsonObject } from "./types/serialized-type";
 
-const { sha512Half, transactionID } = require("./hashes");
+/**
+ * Construct a BinaryParser
+ *
+ * @param bytes hex-string to construct BinaryParser from
+ * @returns A BinaryParser
+ */
+const makeParser = (bytes: string): BinaryParser => new BinaryParser(bytes);
 
-const makeParser = (bytes) => new BinaryParser(bytes);
-const readJSON = (parser) => parser.readType(coreTypes.STObject).toJSON();
-const binaryToJSON = (bytes) => readJSON(makeParser(bytes));
+/**
+ * Parse BinaryParser into JSON
+ *
+ * @param parser BinaryParser object
+ * @returns JSON for the bytes in the BinaryParser
+ */
+const readJSON = (parser: BinaryParser): JsonObject =>
+  (parser.readType(coreTypes.STObject) as STObject).toJSON();
 
-function serializeObject(object, opts = <any>{}) {
+/**
+ * Parse a hex-string into its JSON interpretation
+ *
+ * @param bytes hex-string to parse into JSON
+ * @returns JSON
+ */
+const binaryToJSON = (bytes: string): JsonObject => readJSON(makeParser(bytes));
+
+/**
+ * Interface for passing parameters to SerializeObject
+ *
+ * @field set signingFieldOnly to true if you want to serialize only signing fields
+ */
+interface OptionObject {
+  prefix?: Buffer;
+  suffix?: Buffer;
+  signingFieldsOnly?: boolean;
+}
+
+/**
+ * Function to serialize JSON object representing a transaction
+ *
+ * @param object JSON object to serialize
+ * @param opts options for serializing, including optional prefix, suffix, and signingFieldOnly
+ * @returns A Buffer containing the serialized object
+ */
+function serializeObject(object: JsonObject, opts: OptionObject = {}): Buffer {
   const { prefix, suffix, signingFieldsOnly = false } = opts;
   const bytesList = new BytesList();
+
   if (prefix) {
     bytesList.put(prefix);
   }
-  const filter = signingFieldsOnly ? (f) => f.isSigningField : undefined;
+
+  const filter = signingFieldsOnly
+    ? (f: FieldInstance): boolean => f.isSigningField
+    : undefined;
   coreTypes.STObject.from(object, filter).toBytesSink(bytesList);
+
   if (suffix) {
     bytesList.put(suffix);
   }
+
   return bytesList.toBytes();
 }
 
-function signingData(tx, prefix = HashPrefix.transactionSig) {
-  return serializeObject(tx, { prefix, signingFieldsOnly: true });
+/**
+ * Serialize an object for signing
+ *
+ * @param transaction Transaction to serialize
+ * @param prefix Prefix bytes to put before the serialized object
+ * @returns A Buffer with the serialized object
+ */
+function signingData(
+  transaction: JsonObject,
+  prefix: Buffer = HashPrefix.transactionSig
+): Buffer {
+  return serializeObject(transaction, { prefix, signingFieldsOnly: true });
 }
 
-function signingClaimData(claim) {
+/**
+ * Interface describing fields required for a Claim
+ */
+interface ClaimObject extends JsonObject {
+  channel: string;
+  amount: string | number;
+}
+
+/**
+ * Serialize a signingClaim
+ *
+ * @param claim A claim object to serialize
+ * @returns the serialized object with appropriate prefix
+ */
+function signingClaimData(claim: ClaimObject): Buffer {
   const prefix = HashPrefix.paymentChannelClaim;
   const channel = coreTypes.Hash256.from(claim.channel).toBytes();
   const amount = coreTypes.UInt64.from(BigInt(claim.amount)).toBytes();
@@ -43,26 +114,38 @@ function signingClaimData(claim) {
   return bytesList.toBytes();
 }
 
-function multiSigningData(tx, signingAccount) {
+/**
+ * Serialize a transaction object for multiSigning
+ *
+ * @param transaction transaction to serialize
+ * @param signingAccount Account to sign the transaction with
+ * @returns serialized transaction with appropriate prefix and suffix
+ */
+function multiSigningData(
+  transaction: JsonObject,
+  signingAccount: string | AccountID
+): Buffer {
   const prefix = HashPrefix.transactionMultiSig;
   const suffix = coreTypes.AccountID.from(signingAccount).toBytes();
-  return serializeObject(tx, { prefix, suffix, signingFieldsOnly: true });
+  return serializeObject(transaction, {
+    prefix,
+    suffix,
+    signingFieldsOnly: true,
+  });
 }
 
 export {
   BinaryParser,
   BinarySerializer,
   BytesList,
+  ClaimObject,
   makeParser,
   serializeObject,
   readJSON,
-  bytesToHex,
-  parseBytes,
   multiSigningData,
   signingData,
   signingClaimData,
   binaryToJSON,
   sha512Half,
   transactionID,
-  slice,
 };