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

package/src/index.ts

@@ -100,9 +100,7 @@ function encodeForMultisigning(
   if (typeof json !== 'object') {
     throw new Error()
   }
-  if (json['SigningPubKey'] !== '') {
-    throw new Error()
-  }
+
   const definitionsOpt = definitions ? { definitions } : undefined
   return bytesToHex(
     multiSigningData(json as JsonObject, signer, definitionsOpt),

package/src/types/hash-128.ts

@@ -10,7 +10,7 @@ class Hash128 extends Hash {
   static readonly ZERO_128: Hash128 = new Hash128(new Uint8Array(Hash128.width))
 
   constructor(bytes: Uint8Array) {
-    if (bytes && bytes.byteLength === 0) {
+    if (bytes?.byteLength === 0) {
       bytes = Hash128.ZERO_128.bytes
     }
 

package/src/types/hash-160.ts

@@ -9,7 +9,7 @@ class Hash160 extends Hash {
   static readonly ZERO_160: Hash160 = new Hash160(new Uint8Array(Hash160.width))
 
   constructor(bytes?: Uint8Array) {
-    if (bytes && bytes.byteLength === 0) {
+    if (bytes?.byteLength === 0) {
       bytes = Hash160.ZERO_160.bytes
     }
 

package/src/types/hash-192.ts

@@ -9,7 +9,7 @@ class Hash192 extends Hash {
   static readonly ZERO_192: Hash192 = new Hash192(new Uint8Array(Hash192.width))
 
   constructor(bytes?: Uint8Array) {
-    if (bytes && bytes.byteLength === 0) {
+    if (bytes?.byteLength === 0) {
       bytes = Hash192.ZERO_192.bytes
     }
 

package/src/types/index.ts

@@ -8,6 +8,7 @@ import { Hash128 } from './hash-128'
 import { Hash160 } from './hash-160'
 import { Hash192 } from './hash-192'
 import { Hash256 } from './hash-256'
+import { Int32 } from './int-32'
 import { Issue } from './issue'
 import { STNumber } from './st-number'
 import { PathSet } from './path-set'
@@ -33,6 +34,7 @@ const coreTypes: Record<string, typeof SerializedType> = {
   Hash160,
   Hash192,
   Hash256,
+  Int32,
   Issue,
   Number: STNumber,
   PathSet,
@@ -63,6 +65,7 @@ export {
   Hash160,
   Hash192,
   Hash256,
+  Int32,
   PathSet,
   STArray,
   STObject,

package/src/types/int-32.ts

@@ -0,0 +1,72 @@
+import { Int } from './int'
+import { BinaryParser } from '../serdes/binary-parser'
+import { readInt32BE, writeInt32BE } from '../utils'
+
+/**
+ * Derived Int class for serializing/deserializing signed 32-bit integers.
+ */
+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)
+  }
+
+  /**
+   * 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 an Int32 object from a number or string
+   *
+   * @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) {
+      return val
+    }
+
+    const buf = new Uint8Array(Int32.width)
+
+    if (typeof val === 'string') {
+      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' && Number.isInteger(val)) {
+      Int32.checkIntRange('Int32', val, Int32.MIN_VALUE, Int32.MAX_VALUE)
+      writeInt32BE(buf, val, 0)
+      return new Int32(buf)
+    }
+
+    throw new Error('Cannot construct Int32 from given value')
+  }
+
+  /**
+   * Get the value of the Int32 object
+   *
+   * @returns the signed 32-bit integer represented by this.bytes
+   */
+  valueOf(): number {
+    return readInt32BE(this.bytes, 0)
+  }
+}
+
+export { Int32 }

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

@@ -1,140 +1,173 @@
-import { concat } from '@transia/isomorphic/utils'
-import { BinaryParser } from '../serdes/binary-parser'
-
-import { AccountID } from './account-id'
-import { Currency } from './currency'
-import { JsonObject, SerializedType, SerializedTypeID } from './serialized-type'
-import { Hash192 } from './hash-192'
+import { bytesToHex, concat } from "@transia/isomorphic/utils";
+import { BinaryParser } from "../serdes/binary-parser";
+
+import { AccountID } from "./account-id";
+import { Currency } from "./currency";
+import {
+  JsonObject,
+  SerializedType,
+  SerializedTypeID,
+} from "./serialized-type";
+import { Hash192 } from "./hash-192";
+import { readUInt32BE, writeUInt32BE } from "../utils";
 
 interface XRPIssue extends JsonObject {
-  currency: string
+  currency: string;
 }
 
 interface IOUIssue extends JsonObject {
-  currency: string
-  issuer: string
+  currency: string;
+  issuer: string;
 }
 interface MPTIssue extends JsonObject {
-  mpt_issuance_id: string
+  mpt_issuance_id: string;
 }
 /**
  * Interface for JSON objects that represent issues
  */
-type IssueObject = XRPIssue | IOUIssue | MPTIssue
+type IssueObject = XRPIssue | IOUIssue | MPTIssue;
 
 /**
  * Type guard for Issue Object
  */
 function isIssueObject(arg): arg is IssueObject {
-  const keys = Object.keys(arg).sort()
-  const isXRP = keys.length === 1 && keys[0] === 'currency'
+  const keys = Object.keys(arg).sort();
+  const isXRP = keys.length === 1 && keys[0] === "currency";
   const isIOU =
-    keys.length === 2 && keys[0] === 'currency' && keys[1] === 'issuer'
-  const isMPT = keys.length === 1 && keys[0] === 'mpt_issuance_id'
+    keys.length === 2 && keys[0] === "currency" && keys[1] === "issuer";
+  const isMPT = keys.length === 1 && keys[0] === "mpt_issuance_id";
 
-  return isXRP || isIOU || isMPT
+  return isXRP || isIOU || isMPT;
 }
 
+const MPT_WIDTH = 44;
+const NO_ACCOUNT = AccountID.from("0000000000000000000000000000000000000001");
+
 /**
- * Class for serializing/Deserializing Amounts
+ * Class for serializing/Deserializing Issue
  */
 class Issue extends SerializedType {
-  static readonly ZERO_ISSUED_CURRENCY: Issue = new Issue(new Uint8Array(20))
+  static readonly XRP_ISSUE: Issue = new Issue(new Uint8Array(20));
 
   constructor(bytes: Uint8Array) {
-    super(bytes ?? Issue.ZERO_ISSUED_CURRENCY.bytes)
+    super(bytes ?? Issue.XRP_ISSUE.bytes);
   }
 
   /**
-   * Construct an amount from an IOU or string amount
+   * Construct Issue from XRPIssue, IOUIssue or MPTIssue
    *
-   * @param value An Amount, object representing an IOU, MPTAmount, or a string
-   *     representing an integer amount
+   * @param value An object representing an XRPIssue, IOUIssue or MPTIssue
    * @returns An Issue object
    */
   static from<T extends Issue | IssueObject>(value: T): Issue {
     if (value instanceof Issue) {
-      return value
+      return value;
     }
 
     if (isIssueObject(value)) {
       if (value.currency) {
-        const currency = Currency.from(value.currency.toString()).toBytes()
+        const currency = Currency.from(value.currency.toString()).toBytes();
 
         //IOU case
         if (value.issuer) {
-          const issuer = AccountID.from(value.issuer.toString()).toBytes()
-          return new Issue(concat([currency, issuer]))
+          const issuer = AccountID.from(value.issuer.toString()).toBytes();
+          return new Issue(concat([currency, issuer]));
         }
 
         //XRP case
-        return new Issue(currency)
+        return new Issue(currency);
       }
 
       // MPT case
       if (value.mpt_issuance_id) {
         const mptIssuanceIdBytes = Hash192.from(
           value.mpt_issuance_id.toString(),
-        ).toBytes()
-        return new Issue(mptIssuanceIdBytes)
+        ).toBytes();
+        const issuerAccount = mptIssuanceIdBytes.slice(4);
+        const sequence = Number(
+          readUInt32BE(mptIssuanceIdBytes.slice(0, 4), 0),
+        ); // sequence is in Big-endian format in mpt_issuance_id
+
+        // Convert to Little-endian
+        const sequenceBuffer = new Uint8Array(4);
+        new DataView(sequenceBuffer.buffer).setUint32(0, sequence, true);
+
+        return new Issue(
+          concat([issuerAccount, NO_ACCOUNT.toBytes(), sequenceBuffer]),
+        );
       }
     }
 
-    throw new Error('Invalid type to construct an Amount')
+    throw new Error("Invalid type to construct an Issue");
   }
 
   /**
-   * Read an amount from a BinaryParser
+   * Read Issue from a BinaryParser
    *
-   * @param parser BinaryParser to read the Amount from
-   * @param hint The number of bytes to consume from the parser.
-   * For an MPT amount, pass 24 (the fixed length for Hash192).
+   * @param parser BinaryParser to read the Issue from
    *
    * @returns An Issue object
    */
-  static fromParser(parser: BinaryParser, hint?: number): Issue {
-    if (hint === Hash192.width) {
-      const mptBytes = parser.read(Hash192.width)
-      return new Issue(mptBytes)
+  static fromParser(parser: BinaryParser): Issue {
+    // XRP
+    const currencyOrAccount = parser.read(20);
+    if (new Currency(currencyOrAccount).toJSON() === "XRP") {
+      return new Issue(currencyOrAccount);
     }
-    const currency = parser.read(20)
-    if (new Currency(currency).toJSON() === 'XRP') {
-      return new Issue(currency)
+
+    // MPT
+    const issuerAccountId = new AccountID(parser.read(20));
+    if (NO_ACCOUNT.toHex() === issuerAccountId.toHex()) {
+      const sequence = parser.read(4);
+      return new Issue(
+        concat([currencyOrAccount, NO_ACCOUNT.toBytes(), sequence]),
+      );
     }
-    const currencyAndIssuer = [currency, parser.read(20)]
-    return new Issue(concat(currencyAndIssuer))
+
+    // IOU
+    return new Issue(concat([currencyOrAccount, issuerAccountId.toBytes()]));
   }
 
   /**
-   * Get the JSON representation of this Amount
+   * Get the JSON representation of this IssueObject
    *
    * @returns the JSON interpretation of this.bytes
    */
   toJSON(): IssueObject {
-    // If the buffer is exactly 24 bytes, treat it as an MPT amount.
-    if (this.toBytes().length === Hash192.width) {
+    // If the buffer is exactly 44 bytes, treat it as an MPTIssue.
+    if (this.toBytes().length === MPT_WIDTH) {
+      const issuerAccount = this.toBytes().slice(0, 20);
+      const sequence = new DataView(this.toBytes().slice(40).buffer).getUint32(
+        0,
+        true,
+      );
+
+      // sequence part of mpt_issuance_id should be in Big-endian
+      const sequenceBuffer = new Uint8Array(4);
+      writeUInt32BE(sequenceBuffer, sequence, 0);
+
       return {
-        mpt_issuance_id: this.toHex().toUpperCase(),
-      }
+        mpt_issuance_id: bytesToHex(concat([sequenceBuffer, issuerAccount])),
+      };
     }
 
-    const parser = new BinaryParser(this.toString())
+    const parser = new BinaryParser(this.toString());
 
-    const currency = Currency.fromParser(parser) as Currency
-    if (currency.toJSON() === 'XRP') {
-      return { currency: currency.toJSON() }
+    const currency = Currency.fromParser(parser) as Currency;
+    if (currency.toJSON() === "XRP") {
+      return { currency: currency.toJSON() };
     }
-    const issuer = AccountID.fromParser(parser) as AccountID
+    const issuer = AccountID.fromParser(parser) as AccountID;
 
     return {
       currency: currency.toJSON(),
       issuer: issuer.toJSON(),
-    }
+    };
   }
 
   getSType(): SerializedTypeID {
-    return SerializedTypeID.STI_ISSUE
+    return SerializedTypeID.STI_ISSUE;
   }
 }
 
-export { Issue, IssueObject }
+export { Issue, IssueObject };

package/src/types/st-number.ts

@@ -1,3 +1,4 @@
+/* eslint-disable complexity -- required for various checks */
 import { BinaryParser } from '../serdes/binary-parser'
 import { SerializedType, SerializedTypeID } from './serialized-type'
 import { writeInt32BE, writeInt64BE, readInt32BE, readInt64BE } from '../utils'
@@ -6,8 +7,9 @@ import { writeInt32BE, writeInt64BE, readInt32BE, readInt64BE } from '../utils'
  * Constants for mantissa and exponent normalization per XRPL Number spec.
  * These define allowed magnitude for mantissa and exponent after normalization.
  */
-const MIN_MANTISSA = BigInt('1000000000000000')
-const MAX_MANTISSA = BigInt('9999999999999999')
+const MIN_MANTISSA = BigInt('1000000000000000000') // 10^18
+const MAX_MANTISSA = BigInt('9999999999999999999') // 10^19 - 1
+const MAX_INT64 = BigInt('9223372036854775807') // 2^63 - 1, max signed 64-bit integer
 const MIN_EXPONENT = -32768
 const MAX_EXPONENT = 32768
 const DEFAULT_VALUE_EXPONENT = -2147483648
@@ -62,6 +64,12 @@ function extractNumberPartsFromString(val: string): {
   }
   if (expPart) exponent += parseInt(expPart, 10)
 
+  // Remove trailing zeros from mantissa and adjust exponent
+  while (mantissaStr.length > 1 && mantissaStr.endsWith('0')) {
+    mantissaStr = mantissaStr.slice(0, -1)
+    exponent += 1
+  }
+
   let mantissa = BigInt(mantissaStr)
   if (sign === '-') mantissa = -mantissa
   const isNegative = mantissa < BigInt(0)
@@ -72,7 +80,7 @@ function extractNumberPartsFromString(val: string): {
 /**
  * Normalize the mantissa and exponent to XRPL constraints.
  *
- * Ensures that after normalization, the mantissa is between MIN_MANTISSA and MAX_MANTISSA (unless zero).
+ * Ensures that after normalization, the mantissa is between MIN_MANTISSA and MAX_INT64.
  * Adjusts the exponent as needed by shifting the mantissa left/right (multiplying/dividing by 10).
  *
  * @param mantissa - The unnormalized mantissa (BigInt).
@@ -87,16 +95,65 @@ function normalize(
   let m = mantissa < BigInt(0) ? -mantissa : mantissa
   const isNegative = mantissa < BigInt(0)
 
-  while (m !== BigInt(0) && m < MIN_MANTISSA && exponent > MIN_EXPONENT) {
+  // Handle zero
+  if (m === BigInt(0)) {
+    return { mantissa: BigInt(0), exponent: DEFAULT_VALUE_EXPONENT }
+  }
+
+  // Grow mantissa until it reaches MIN_MANTISSA
+  while (m < MIN_MANTISSA && exponent > MIN_EXPONENT) {
     exponent -= 1
     m *= BigInt(10)
   }
+
+  let lastDigit: bigint | null = null
+
+  // Shrink mantissa until it fits within MAX_MANTISSA
   while (m > MAX_MANTISSA) {
-    if (exponent >= MAX_EXPONENT)
+    if (exponent >= MAX_EXPONENT) {
       throw new Error('Mantissa and exponent are too large')
+    }
     exponent += 1
+    lastDigit = m % BigInt(10)
     m /= BigInt(10)
   }
+
+  // Handle underflow: if exponent too small or mantissa too small, throw error
+  if (exponent < MIN_EXPONENT || m < MIN_MANTISSA) {
+    throw new Error('Underflow: value too small to represent')
+  }
+
+  // Handle overflow: if exponent exceeds MAX_EXPONENT after growing.
+  if (exponent > MAX_EXPONENT) {
+    throw new Error('Exponent overflow: value too large to represent')
+  }
+
+  // Handle overflow: if mantissa exceeds MAX_INT64 (2^63-1) after growing.
+  if (m > MAX_INT64) {
+    if (exponent >= MAX_EXPONENT) {
+      throw new Error('Exponent overflow: value too large to represent')
+    }
+    exponent += 1
+    lastDigit = m % BigInt(10)
+    m /= BigInt(10)
+  }
+
+  if (lastDigit != null && lastDigit >= BigInt(5)) {
+    m += BigInt(1)
+    // After rounding, mantissa may exceed MAX_INT64 again
+    if (m > MAX_INT64) {
+      if (exponent >= MAX_EXPONENT) {
+        throw new Error('Exponent overflow: value too large to represent')
+      }
+      lastDigit = m % BigInt(10)
+      exponent += 1
+      m /= BigInt(10)
+      if (lastDigit >= BigInt(5)) {
+        m += BigInt(1)
+      }
+    }
+  }
+
   if (isNegative) m = -m
   return { mantissa: m, exponent }
 }
@@ -159,17 +216,9 @@ export class STNumber extends SerializedType {
    * @throws Error if val is not a valid number string.
    */
   static fromValue(val: string): STNumber {
-    const { mantissa, exponent, isNegative } = extractNumberPartsFromString(val)
-    let normalizedMantissa: bigint
-    let normalizedExponent: number
-
-    if (mantissa === BigInt(0) && exponent === 0 && !isNegative) {
-      normalizedMantissa = BigInt(0)
-      normalizedExponent = DEFAULT_VALUE_EXPONENT
-    } else {
-      ;({ mantissa: normalizedMantissa, exponent: normalizedExponent } =
-        normalize(mantissa, exponent))
-    }
+    const { mantissa, exponent } = extractNumberPartsFromString(val)
+    const { mantissa: normalizedMantissa, exponent: normalizedExponent } =
+      normalize(mantissa, exponent)
 
     const bytes = new Uint8Array(12)
     writeInt64BE(bytes, normalizedMantissa, 0)
@@ -193,39 +242,66 @@ export class STNumber extends SerializedType {
    *
    * @returns String representation of the value
    */
-  // eslint-disable-next-line complexity -- required
   toJSON(): string {
     const b = this.bytes
-    if (!b || b.length !== 12)
+    if (!b || b?.length !== 12)
       throw new Error('STNumber internal bytes not set or wrong length')
 
     // Signed 64-bit mantissa
     const mantissa = readInt64BE(b, 0)
     // Signed 32-bit exponent
-    const exponent = readInt32BE(b, 8)
+    let exponent = readInt32BE(b, 8)
 
     // Special zero: XRPL encodes canonical zero as mantissa=0, exponent=DEFAULT_VALUE_EXPONENT.
     if (mantissa === BigInt(0) && exponent === DEFAULT_VALUE_EXPONENT) {
       return '0'
     }
-    if (exponent === 0) return mantissa.toString()
 
-    // Use scientific notation for small/large exponents, decimal otherwise
-    if (exponent < -25 || exponent > -5) {
-      return `${mantissa}e${exponent}`
+    const isNegative = mantissa < BigInt(0)
+    let mantissaAbs = isNegative ? -mantissa : mantissa
+
+    // If mantissa < MIN_MANTISSA, it was shrunk for int64 serialization (mantissa > 2^63-1).
+    // Restore it for proper string rendering to match rippled's internal representation.
+    if (mantissaAbs !== BigInt(0) && mantissaAbs < MIN_MANTISSA) {
+      mantissaAbs *= BigInt(10)
+      exponent -= 1
     }
 
-    // Decimal rendering for -25 <= exp <= -5
-    const isNegative = mantissa < BigInt(0)
-    const mantissaAbs = mantissa < BigInt(0) ? -mantissa : mantissa
+    // For large mantissa range (default), rangeLog = 18
+    const rangeLog = 18
+
+    // Use scientific notation for exponents that are too small or too large
+    // Condition from rippled: exponent != 0 AND (exponent < -(rangeLog + 10) OR exponent > -(rangeLog - 10))
+    // For rangeLog = 18: exponent != 0 AND (exponent < -28 OR exponent > -8)
+    if (
+      exponent !== 0 &&
+      (exponent < -(rangeLog + 10) || exponent > -(rangeLog - 10))
+    ) {
+      // Strip trailing zeros from mantissa (matches rippled behavior)
+      let exp = exponent
+      while (
+        mantissaAbs !== BigInt(0) &&
+        mantissaAbs % BigInt(10) === BigInt(0) &&
+        exp < MAX_EXPONENT
+      ) {
+        mantissaAbs /= BigInt(10)
+        exp += 1
+      }
+      const sign = isNegative ? '-' : ''
+      return `${sign}${mantissaAbs}e${exp}`
+    }
+
+    // Decimal rendering for -(rangeLog + 10) <= exponent <= -(rangeLog - 10)
+    // i.e., -28 <= exponent <= -8, or exponent == 0
+    const padPrefix = rangeLog + 12 // 30
+    const padSuffix = rangeLog + 8 // 26
 
-    const padPrefix = 27
-    const padSuffix = 23
     const mantissaStr = mantissaAbs.toString()
     const rawValue = '0'.repeat(padPrefix) + mantissaStr + '0'.repeat(padSuffix)
-    const OFFSET = exponent + 43
-    const integerPart = rawValue.slice(0, OFFSET).replace(/^0+/, '') || '0'
-    const fractionPart = rawValue.slice(OFFSET).replace(/0+$/, '')
+    const offset = exponent + padPrefix + rangeLog + 1 // exponent + 49
+
+    const integerPart = rawValue.slice(0, offset).replace(/^0+/, '') || '0'
+    const fractionPart = rawValue.slice(offset).replace(/0+$/, '')
 
     return `${isNegative ? '-' : ''}${integerPart}${
       fractionPart ? '.' + fractionPart : ''