@transia/ripple-binary-codec 1.4.6-alpha.8 → 2.5.1

package/src/types/hash-160.ts

@@ -0,0 +1,24 @@
+import { Hash } from './hash'
+import { SerializedTypeID } from './serialized-type'
+
+/**
+ * Hash with a width of 160 bits
+ */
+class Hash160 extends Hash {
+  static readonly width = 20
+  static readonly ZERO_160: Hash160 = new Hash160(new Uint8Array(Hash160.width))
+
+  constructor(bytes?: Uint8Array) {
+    if (bytes && bytes.byteLength === 0) {
+      bytes = Hash160.ZERO_160.bytes
+    }
+
+    super(bytes ?? Hash160.ZERO_160.bytes)
+  }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_UINT160
+  }
+}
+
+export { Hash160 }

package/src/types/hash-192.ts

@@ -0,0 +1,24 @@
+import { Hash } from './hash'
+import { SerializedTypeID } from './serialized-type'
+
+/**
+ * Hash with a width of 192 bits
+ */
+class Hash192 extends Hash {
+  static readonly width = 24
+  static readonly ZERO_192: Hash192 = new Hash192(new Uint8Array(Hash192.width))
+
+  constructor(bytes?: Uint8Array) {
+    if (bytes && bytes.byteLength === 0) {
+      bytes = Hash192.ZERO_192.bytes
+    }
+
+    super(bytes ?? Hash192.ZERO_192.bytes)
+  }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_UINT192
+  }
+}
+
+export { Hash192 }

package/src/types/hash-256.ts

@@ -0,0 +1,20 @@
+import { Hash } from './hash'
+import { SerializedTypeID } from './serialized-type'
+
+/**
+ * Hash with a width of 256 bits
+ */
+class Hash256 extends Hash {
+  static readonly width = 32
+  static readonly ZERO_256 = new Hash256(new Uint8Array(Hash256.width))
+
+  constructor(bytes: Uint8Array) {
+    super(bytes ?? Hash256.ZERO_256.bytes)
+  }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_UINT256
+  }
+}
+
+export { Hash256 }

package/src/types/hash.ts

@@ -0,0 +1,86 @@
+import { Comparable } from './serialized-type'
+import { BinaryParser } from '../serdes/binary-parser'
+import { HEX_REGEX, hexToBytes } from '@transia/isomorphic/utils'
+import { compare } from '../utils'
+
+/**
+ * Base class defining how to encode and decode hashes
+ */
+class Hash extends Comparable<Hash | string> {
+  static readonly width: number
+
+  constructor(bytes: Uint8Array) {
+    super(bytes)
+    if (this.bytes.length !== (this.constructor as typeof Hash).width) {
+      throw new Error(`Invalid Hash length ${this.bytes.byteLength}`)
+    }
+  }
+
+  /**
+   * Construct a Hash object from an existing Hash object or a hex-string
+   *
+   * @param value A hash object or hex-string of a hash
+   */
+  static from<T extends Hash | string>(value: T): Hash {
+    if (value instanceof this) {
+      return value
+    }
+
+    if (typeof value === 'string') {
+      if (!HEX_REGEX.test(value)) {
+        throw new Error(`Invalid hash string ${value}`)
+      }
+      return new this(hexToBytes(value))
+    }
+
+    throw new Error('Cannot construct Hash from given value')
+  }
+
+  /**
+   * Read a Hash object from a BinaryParser
+   *
+   * @param parser BinaryParser to read the hash from
+   * @param hint length of the bytes to read, optional
+   */
+  static fromParser(parser: BinaryParser, hint?: number): Hash {
+    return new this(parser.read(hint ?? this.width))
+  }
+
+  /**
+   * Overloaded operator for comparing two hash objects
+   *
+   * @param other The Hash to compare this to
+   */
+  compareTo(other: Hash): number {
+    return compare(
+      this.bytes,
+      (this.constructor as typeof Hash).from(other).bytes,
+    )
+  }
+
+  /**
+   * @returns the hex-string representation of this Hash
+   */
+  toString(): string {
+    return this.toHex()
+  }
+
+  /**
+   * Returns four bits at the specified depth within a hash
+   *
+   * @param depth The depth of the four bits
+   * @returns The number represented by the four bits
+   */
+  nibblet(depth: number): number {
+    const byteIx = depth > 0 ? (depth / 2) | 0 : 0
+    let b = this.bytes[byteIx]
+    if (depth % 2 === 0) {
+      b = (b & 0xf0) >>> 4
+    } else {
+      b = b & 0x0f
+    }
+    return b
+  }
+}
+
+export { Hash }

package/src/types/index.ts

@@ -0,0 +1,74 @@
+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'
+import { Hash256 } from './hash-256'
+import { Issue } from './issue'
+import { STNumber } from './st-number'
+import { PathSet } from './path-set'
+import { STArray } from './st-array'
+import { STObject } from './st-object'
+import { UInt16 } from './uint-16'
+import { UInt32 } from './uint-32'
+import { UInt64 } from './uint-64'
+import { UInt8 } from './uint-8'
+import { Vector256 } from './vector-256'
+import { XChainBridge } from './xchain-bridge'
+import { type SerializedType } from './serialized-type'
+import { DEFAULT_DEFINITIONS } from '../enums'
+
+const coreTypes: Record<string, typeof SerializedType> = {
+  AccountID,
+  Amount,
+  Blob,
+  Currency,
+  Data,
+  DataType,
+  Hash128,
+  Hash160,
+  Hash192,
+  Hash256,
+  Issue,
+  Number: STNumber,
+  PathSet,
+  STArray,
+  STObject,
+  UInt8,
+  UInt16,
+  UInt32,
+  UInt64,
+  Vector256,
+  XChainBridge,
+}
+
+// Ensures that the DEFAULT_DEFINITIONS object connects these types to fields for serializing/deserializing
+// This is done here instead of in enums/index.ts to avoid a circular dependency
+// because some of the above types depend on BinarySerializer which depends on enums/index.ts.
+DEFAULT_DEFINITIONS.associateTypes(coreTypes)
+
+export {
+  coreTypes,
+  AccountID,
+  Amount,
+  Blob,
+  Currency,
+  Data,
+  DataType,
+  Hash128,
+  Hash160,
+  Hash192,
+  Hash256,
+  PathSet,
+  STArray,
+  STObject,
+  UInt8,
+  UInt16,
+  UInt32,
+  UInt64,
+  Vector256,
+}

package/src/types/issue.ts

@@ -0,0 +1,140 @@
+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'
+
+interface XRPIssue extends JsonObject {
+  currency: string
+}
+
+interface IOUIssue extends JsonObject {
+  currency: string
+  issuer: string
+}
+interface MPTIssue extends JsonObject {
+  mpt_issuance_id: string
+}
+/**
+ * Interface for JSON objects that represent issues
+ */
+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 isIOU =
+    keys.length === 2 && keys[0] === 'currency' && keys[1] === 'issuer'
+  const isMPT = keys.length === 1 && keys[0] === 'mpt_issuance_id'
+
+  return isXRP || isIOU || isMPT
+}
+
+/**
+ * Class for serializing/Deserializing Amounts
+ */
+class Issue extends SerializedType {
+  static readonly ZERO_ISSUED_CURRENCY: Issue = new Issue(new Uint8Array(20))
+
+  constructor(bytes: Uint8Array) {
+    super(bytes ?? Issue.ZERO_ISSUED_CURRENCY.bytes)
+  }
+
+  /**
+   * Construct an amount from an IOU or string amount
+   *
+   * @param value An Amount, object representing an IOU, MPTAmount, or a string
+   *     representing an integer amount
+   * @returns An Issue object
+   */
+  static from<T extends Issue | IssueObject>(value: T): Issue {
+    if (value instanceof Issue) {
+      return value
+    }
+
+    if (isIssueObject(value)) {
+      if (value.currency) {
+        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]))
+        }
+
+        //XRP case
+        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)
+      }
+    }
+
+    throw new Error('Invalid type to construct an Amount')
+  }
+
+  /**
+   * Read an amount 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).
+   *
+   * @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)
+    }
+    const currency = parser.read(20)
+    if (new Currency(currency).toJSON() === 'XRP') {
+      return new Issue(currency)
+    }
+    const currencyAndIssuer = [currency, parser.read(20)]
+    return new Issue(concat(currencyAndIssuer))
+  }
+
+  /**
+   * Get the JSON representation of this Amount
+   *
+   * @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) {
+      return {
+        mpt_issuance_id: this.toHex().toUpperCase(),
+      }
+    }
+
+    const parser = new BinaryParser(this.toString())
+
+    const currency = Currency.fromParser(parser) as Currency
+    if (currency.toJSON() === 'XRP') {
+      return { currency: currency.toJSON() }
+    }
+    const issuer = AccountID.fromParser(parser) as AccountID
+
+    return {
+      currency: currency.toJSON(),
+      issuer: issuer.toJSON(),
+    }
+  }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_ISSUE
+  }
+}
+
+export { Issue, IssueObject }