@transia/ripple-binary-codec 2.5.5-alpha.0 → 2.5.5-alpha.2

package/src/types/st-object.ts

@@ -3,25 +3,29 @@ import {
   FieldInstance,
   Bytes,
   XrplDefinitionsBase,
-} from '../enums'
-import { SerializedType, JsonObject, SerializedTypeID } from './serialized-type'
+} from "../enums";
+import {
+  SerializedType,
+  JsonObject,
+  SerializedTypeID,
+} from "./serialized-type";
 import {
   xAddressToClassicAddress,
   isValidXAddress,
-} from '@transia/ripple-address-codec'
-import { BinaryParser } from '../serdes/binary-parser'
-import { BinarySerializer, BytesList } from '../serdes/binary-serializer'
+} from "@transia/ripple-address-codec";
+import { BinaryParser } from "../serdes/binary-parser";
+import { BinarySerializer, BytesList } from "../serdes/binary-serializer";
 
-import { STArray } from './st-array'
-import { UInt64 } from './uint-64'
+import { STArray } from "./st-array";
+import { UInt64 } from "./uint-64";
 
-const OBJECT_END_MARKER_BYTE = Uint8Array.from([0xe1])
-const OBJECT_END_MARKER = 'ObjectEndMarker'
-const ST_OBJECT = 'STObject'
-const DESTINATION = 'Destination'
-const ACCOUNT = 'Account'
-const SOURCE_TAG = 'SourceTag'
-const DEST_TAG = 'DestinationTag'
+const OBJECT_END_MARKER_BYTE = Uint8Array.from([0xe1]);
+const OBJECT_END_MARKER = "ObjectEndMarker";
+const ST_OBJECT = "STObject";
+const DESTINATION = "Destination";
+const ACCOUNT = "Account";
+const SOURCE_TAG = "SourceTag";
+const DEST_TAG = "DestinationTag";
 
 /**
  * Break down an X-Address into an account and a tag
@@ -30,17 +34,17 @@ const DEST_TAG = 'DestinationTag'
  * @param xAddress X-Address corresponding to the field
  */
 function handleXAddress(field: string, xAddress: string): JsonObject {
-  const decoded = xAddressToClassicAddress(xAddress)
+  const decoded = xAddressToClassicAddress(xAddress);
 
-  let tagName
-  if (field === DESTINATION) tagName = DEST_TAG
-  else if (field === ACCOUNT) tagName = SOURCE_TAG
+  let tagName;
+  if (field === DESTINATION) tagName = DEST_TAG;
+  else if (field === ACCOUNT) tagName = SOURCE_TAG;
   else if (decoded.tag !== false)
-    throw new Error(`${field} cannot have an associated tag`)
+    throw new Error(`${field} cannot have an associated tag`);
 
   return decoded.tag !== false
     ? { [field]: decoded.classicAddress, [tagName]: decoded.tag }
-    : { [field]: decoded.classicAddress }
+    : { [field]: decoded.classicAddress };
 }
 
 /**
@@ -52,9 +56,9 @@ function handleXAddress(field: string, xAddress: string): JsonObject {
  */
 function checkForDuplicateTags(obj1: JsonObject, obj2: JsonObject): void {
   if (!(obj1[SOURCE_TAG] === undefined || obj2[SOURCE_TAG] === undefined))
-    throw new Error('Cannot have Account X-Address and SourceTag')
+    throw new Error("Cannot have Account X-Address and SourceTag");
   if (!(obj1[DEST_TAG] === undefined || obj2[DEST_TAG] === undefined))
-    throw new Error('Cannot have Destination X-Address and DestinationTag')
+    throw new Error("Cannot have Destination X-Address and DestinationTag");
 }
 
 /**
@@ -68,24 +72,24 @@ class STObject extends SerializedType {
    * @returns A STObject object
    */
   static fromParser(parser: BinaryParser): STObject {
-    const list: BytesList = new BytesList()
-    const bytes: BinarySerializer = new BinarySerializer(list)
+    const list: BytesList = new BytesList();
+    const bytes: BinarySerializer = new BinarySerializer(list);
 
     while (!parser.end()) {
-      const field = parser.readField()
+      const field = parser.readField();
       if (field.name === OBJECT_END_MARKER) {
-        break
+        break;
       }
 
-      const associatedValue = parser.readFieldValue(field)
+      const associatedValue = parser.readFieldValue(field);
 
-      bytes.writeFieldAndValue(field, associatedValue)
+      bytes.writeFieldAndValue(field, associatedValue);
       if (field.type.name === ST_OBJECT) {
-        bytes.put(OBJECT_END_MARKER_BYTE)
+        bytes.put(OBJECT_END_MARKER_BYTE);
       }
     }
 
-    return new STObject(list.toBytes())
+    return new STObject(list.toBytes());
   }
 
   /**
@@ -102,22 +106,22 @@ class STObject extends SerializedType {
     definitions: XrplDefinitionsBase = DEFAULT_DEFINITIONS,
   ): STObject {
     if (value instanceof STObject) {
-      return value
+      return value;
     }
 
-    const list: BytesList = new BytesList()
-    const bytes: BinarySerializer = new BinarySerializer(list)
+    const list: BytesList = new BytesList();
+    const bytes: BinarySerializer = new BinarySerializer(list);
 
-    let isUnlModify = false
+    let isUnlModify = false;
 
     const xAddressDecoded = Object.entries(value).reduce((acc, [key, val]) => {
-      let handled: JsonObject | undefined = undefined
+      let handled: JsonObject | undefined = undefined;
       if (val && isValidXAddress(val.toString())) {
-        handled = handleXAddress(key, val.toString())
-        checkForDuplicateTags(handled, value)
+        handled = handleXAddress(key, val.toString());
+        checkForDuplicateTags(handled, value);
       }
-      return Object.assign(acc, handled ?? { [key]: val })
-    }, {})
+      return Object.assign(acc, handled ?? { [key]: val });
+    }, {});
 
     function isValidFieldInstance(
       f: FieldInstance | undefined,
@@ -126,65 +130,65 @@ class STObject extends SerializedType {
         f !== undefined &&
         xAddressDecoded[f.name] !== undefined &&
         f.isSerialized
-      )
+      );
     }
 
     let sorted = Object.keys(xAddressDecoded)
       .map((f: string): FieldInstance | undefined => {
         if (!(f in definitions.field)) {
-          if (f[0] === f[0].toLowerCase()) return undefined
-          throw new Error(`Field ${f} is not defined in the definitions`)
+          if (f[0] === f[0].toLowerCase()) return undefined;
+          throw new Error(`Field ${f} is not defined in the definitions`);
         }
-        return definitions.field[f] as FieldInstance
+        return definitions.field[f] as FieldInstance;
       })
       .filter(isValidFieldInstance)
       .sort((a, b) => {
-        return a.ordinal - b.ordinal
-      })
+        return a.ordinal - b.ordinal;
+      });
 
     if (filter !== undefined) {
-      sorted = sorted.filter(filter)
+      sorted = sorted.filter(filter);
     }
 
     sorted.forEach((field) => {
       const associatedValue =
         field.type.name === ST_OBJECT
           ? this.from(xAddressDecoded[field.name], undefined, definitions)
-          : field.type.name === 'STArray'
-          ? STArray.from(xAddressDecoded[field.name], definitions)
-          : field.type.name === 'UInt64'
-          ? UInt64.from(xAddressDecoded[field.name], field.name)
-          : field.associatedType?.from
-          ? field.associatedType.from(xAddressDecoded[field.name])
-          : (() => {
-              throw new Error(
-                `Type ${field.type.name} for field ${field.name} is missing associatedType.from`,
-              )
-            })()
+          : field.type.name === "STArray"
+            ? STArray.from(xAddressDecoded[field.name], definitions)
+            : field.type.name === "UInt64"
+              ? UInt64.from(xAddressDecoded[field.name], field.name)
+              : field.associatedType?.from
+                ? field.associatedType.from(xAddressDecoded[field.name])
+                : (() => {
+                    throw new Error(
+                      `Type ${field.type.name} for field ${field.name} is missing associatedType.from`,
+                    );
+                  })();
 
       if (associatedValue == undefined) {
         throw new TypeError(
           `Unable to interpret "${field.name}: ${
             xAddressDecoded[field.name]
           }".`,
-        )
+        );
       }
 
-      if ((associatedValue as unknown as Bytes).name === 'UNLModify') {
+      if ((associatedValue as unknown as Bytes).name === "UNLModify") {
         // triggered when the TransactionType field has a value of 'UNLModify'
-        isUnlModify = true
+        isUnlModify = true;
       }
       // true when in the UNLModify pseudotransaction (after the transaction type has been processed) and working with the
       // Account field
       // The Account field must not be a part of the UNLModify pseudotransaction encoding, due to a bug in rippled
-      const isUnlModifyWorkaround = field.name == 'Account' && isUnlModify
-      bytes.writeFieldAndValue(field, associatedValue, isUnlModifyWorkaround)
+      const isUnlModifyWorkaround = field.name == "Account" && isUnlModify;
+      bytes.writeFieldAndValue(field, associatedValue, isUnlModifyWorkaround);
       if (field.type.name === ST_OBJECT) {
-        bytes.put(OBJECT_END_MARKER_BYTE)
+        bytes.put(OBJECT_END_MARKER_BYTE);
       }
-    })
+    });
 
-    return new STObject(list.toBytes())
+    return new STObject(list.toBytes());
   }
 
   /**
@@ -194,26 +198,26 @@ class STObject extends SerializedType {
    * @returns a JSON object
    */
   toJSON(definitions?: XrplDefinitionsBase): JsonObject {
-    const objectParser = new BinaryParser(this.toString(), definitions)
-    const accumulator = {}
+    const objectParser = new BinaryParser(this.toString(), definitions);
+    const accumulator = {};
 
     while (!objectParser.end()) {
-      const field = objectParser.readField()
+      const field = objectParser.readField();
       if (field.name === OBJECT_END_MARKER) {
-        break
+        break;
       }
 
       accumulator[field.name] = objectParser
         .readFieldValue(field)
-        .toJSON(definitions, field.name)
+        .toJSON(definitions, field.name);
     }
 
-    return accumulator
+    return accumulator;
   }
 
   getSType(): SerializedTypeID {
-    return SerializedTypeID.STI_OBJECT
+    return SerializedTypeID.STI_OBJECT;
   }
 }
 
-export { STObject }
+export { STObject };

package/src/types/uint-16.ts

@@ -30,7 +30,7 @@ class UInt16 extends UInt {
       return val
     }
 
-    if (typeof val === 'number') {
+    if (typeof val === 'number' && Number.isInteger(val)) {
       UInt16.checkUintRange(val, 0, 0xffff)
 
       const buf = new Uint8Array(UInt16.width)
@@ -38,7 +38,7 @@ class UInt16 extends UInt {
       return new UInt16(buf)
     }
 
-    throw new Error('Can not construct UInt16 with given value')
+    throw new Error('Cannot construct UInt16 from given value')
   }
 
   /**

package/src/types/uint-32.ts

@@ -38,7 +38,7 @@ class UInt32 extends UInt {
       return new UInt32(buf)
     }
 
-    if (typeof val === 'number') {
+    if (typeof val === 'number' && Number.isInteger(val)) {
       UInt32.checkUintRange(val, 0, 0xffffffff)
       writeUInt32BE(buf, val, 0)
       return new UInt32(buf)

package/src/types/uint-64.ts

@@ -54,7 +54,7 @@ class UInt64 extends UInt {
 
     let buf = new Uint8Array(UInt64.width)
 
-    if (typeof val === 'number') {
+    if (typeof val === 'number' && Number.isInteger(val)) {
       if (val < 0) {
         throw new Error('value must be an unsigned integer')
       }

package/src/types/uint-8.ts

@@ -29,7 +29,7 @@ class UInt8 extends UInt {
       return val
     }
 
-    if (typeof val === 'number') {
+    if (typeof val === 'number' && Number.isInteger(val)) {
       UInt8.checkUintRange(val, 0, 0xff)
 
       const buf = new Uint8Array(UInt8.width)