ripple-binary-codec 2.7.0-smartescrow.0 → 2.8.0-smartcontract.0

package/src/types/hash-160.ts

@@ -1,4 +1,5 @@
 import { Hash } from './hash'
+import { SerializedTypeID } from './serialized-type'
 
 /**
  * Hash with a width of 160 bits
@@ -14,6 +15,10 @@ class Hash160 extends Hash {
 
     super(bytes ?? Hash160.ZERO_160.bytes)
   }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_UINT160
+  }
 }
 
 export { Hash160 }

package/src/types/hash-192.ts

@@ -1,4 +1,5 @@
 import { Hash } from './hash'
+import { SerializedTypeID } from './serialized-type'
 
 /**
  * Hash with a width of 192 bits
@@ -14,6 +15,10 @@ class Hash192 extends Hash {
 
     super(bytes ?? Hash192.ZERO_192.bytes)
   }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_UINT192
+  }
 }
 
 export { Hash192 }

package/src/types/hash-256.ts

@@ -1,4 +1,5 @@
 import { Hash } from './hash'
+import { SerializedTypeID } from './serialized-type'
 
 /**
  * Hash with a width of 256 bits
@@ -10,6 +11,10 @@ class Hash256 extends Hash {
   constructor(bytes: Uint8Array) {
     super(bytes ?? Hash256.ZERO_256.bytes)
   }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_UINT256
+  }
 }
 
 export { Hash256 }

package/src/types/index.ts

@@ -2,6 +2,8 @@ import { AccountID } from './account-id'
 import { Amount } from './amount'
 import { Blob } from './blob'
 import { Currency } from './currency'
+import { Data } from './data'
+import { DataType } from './dataType'
 import { Hash128 } from './hash-128'
 import { Hash160 } from './hash-160'
 import { Hash192 } from './hash-192'
@@ -26,6 +28,8 @@ const coreTypes: Record<string, typeof SerializedType> = {
   Amount,
   Blob,
   Currency,
+  Data,
+  DataType,
   Hash128,
   Hash160,
   Hash192,
@@ -55,6 +59,8 @@ export {
   Amount,
   Blob,
   Currency,
+  Data,
+  DataType,
   Hash128,
   Hash160,
   Hash192,

package/src/types/int-32.ts

@@ -1,26 +1,37 @@
-import { UInt } from './uint'
+import { Int } from './int'
 import { BinaryParser } from '../serdes/binary-parser'
 import { readInt32BE, writeInt32BE } from '../utils'
 
 /**
- * Derived Int class for serializing/deserializing 32 bit Int
+ * Derived Int class for serializing/deserializing signed 32-bit integers.
  */
-class Int32 extends UInt {
-  protected static readonly width: number = 32 / 8 // 4
+class Int32 extends Int {
+  protected static readonly width: number = 32 / 8 // 4 bytes
   static readonly defaultInt32: Int32 = new Int32(new Uint8Array(Int32.width))
 
+  // Signed 32-bit integer range
+  static readonly MIN_VALUE: number = -2147483648 // -2^31
+  static readonly MAX_VALUE: number = 2147483647 // 2^31 - 1
+
   constructor(bytes: Uint8Array) {
     super(bytes ?? Int32.defaultInt32.bytes)
   }
 
-  static fromParser(parser: BinaryParser): UInt {
+  /**
+   * Construct an Int32 from a BinaryParser
+   *
+   * @param parser BinaryParser to read Int32 from
+   * @returns An Int32 object
+   */
+  static fromParser(parser: BinaryParser): Int {
     return new Int32(parser.read(Int32.width))
   }
 
   /**
-   * Construct a Int32 object from a number
+   * Construct an Int32 object from a number or string
    *
-   * @param val Int32 object or number
+   * @param val Int32 object, number, or string
+   * @returns An Int32 object
    */
   static from<T extends Int32 | number | string>(val: T): Int32 {
     if (val instanceof Int32) {
@@ -30,13 +41,17 @@ class Int32 extends UInt {
     const buf = new Uint8Array(Int32.width)
 
     if (typeof val === 'string') {
-      const num = Number.parseInt(val)
+      const num = Number(val)
+      if (!Number.isFinite(num) || !Number.isInteger(num)) {
+        throw new Error(`Cannot construct Int32 from string: ${val}`)
+      }
+      Int32.checkIntRange('Int32', num, Int32.MIN_VALUE, Int32.MAX_VALUE)
       writeInt32BE(buf, num, 0)
       return new Int32(buf)
     }
 
-    if (typeof val === 'number') {
-      Int32.checkUintRange(val, -2147483648, 2147483647)
+    if (typeof val === 'number' && Number.isInteger(val)) {
+      Int32.checkIntRange('Int32', val, Int32.MIN_VALUE, Int32.MAX_VALUE)
       writeInt32BE(buf, val, 0)
       return new Int32(buf)
     }
@@ -45,9 +60,9 @@ class Int32 extends UInt {
   }
 
   /**
-   * get the value of a Int32 object
+   * Get the value of the Int32 object
    *
-   * @returns the number represented by this.bytes
+   * @returns the signed 32-bit integer represented by this.bytes
    */
   valueOf(): number {
     return readInt32BE(this.bytes, 0)

package/src/types/int.ts

@@ -0,0 +1,75 @@
+import { Comparable } from './serialized-type'
+
+/**
+ * Compare numbers and bigInts n1 and n2
+ *
+ * @param n1 First object to compare
+ * @param n2 Second object to compare
+ * @returns -1, 0, or 1, depending on how the two objects compare
+ */
+function compare(n1: number | bigint, n2: number | bigint): number {
+  return n1 < n2 ? -1 : n1 == n2 ? 0 : 1
+}
+
+/**
+ * Base class for serializing and deserializing signed integers.
+ */
+abstract class Int extends Comparable<Int | number> {
+  protected static width: number
+
+  constructor(bytes: Uint8Array) {
+    super(bytes)
+  }
+
+  /**
+   * Overload of compareTo for Comparable
+   *
+   * @param other other Int to compare this to
+   * @returns -1, 0, or 1 depending on how the objects relate to each other
+   */
+  compareTo(other: Int | number): number {
+    return compare(this.valueOf(), other.valueOf())
+  }
+
+  /**
+   * Convert an Int object to JSON
+   *
+   * @returns number or string represented by this.bytes
+   */
+  toJSON(): number | string {
+    const val = this.valueOf()
+    return typeof val === 'number' ? val : val.toString()
+  }
+
+  /**
+   * Get the value of the Int represented by this.bytes
+   *
+   * @returns the value
+   */
+  abstract valueOf(): number | bigint
+
+  /**
+   * Validate that a number is within the specified signed integer range
+   *
+   * @param typeName The name of the type (for error messages)
+   * @param val The number to validate
+   * @param min The minimum allowed value
+   * @param max The maximum allowed value
+   * @throws Error if the value is out of range
+   */
+  // eslint-disable-next-line max-params -- for error clarity in browsers
+  static checkIntRange(
+    typeName: string,
+    val: number | bigint,
+    min: number | bigint,
+    max: number | bigint,
+  ): void {
+    if (val < min || val > max) {
+      throw new Error(
+        `Invalid ${typeName}: ${val} must be >= ${min} and <= ${max}`,
+      )
+    }
+  }
+}
+
+export { Int }

package/src/types/issue.ts

@@ -3,7 +3,7 @@ import { BinaryParser } from '../serdes/binary-parser'
 
 import { AccountID } from './account-id'
 import { Currency } from './currency'
-import { JsonObject, SerializedType } from './serialized-type'
+import { JsonObject, SerializedType, SerializedTypeID } from './serialized-type'
 import { Hash192 } from './hash-192'
 import { readUInt32BE, writeUInt32BE } from '../utils'
 
@@ -158,6 +158,10 @@ class Issue extends SerializedType {
       issuer: issuer.toJSON(),
     }
   }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_ISSUE
+  }
 }
 
 export { Issue, IssueObject }