@transia/ripple-binary-codec 1.4.6-alpha.9 → 2.5.2-alpha.0

package/src/serdes/binary-serializer.ts

@@ -0,0 +1,166 @@
+import { FieldInstance } from '../enums'
+import { type SerializedType } from '../types/serialized-type'
+import { bytesToHex, concat } from '@transia/isomorphic/utils'
+
+/**
+ * Bytes list is a collection of Uint8Array objects
+ */
+class BytesList {
+  private bytesArray: Array<Uint8Array> = []
+
+  /**
+   * Get the total number of bytes in the BytesList
+   *
+   * @return the number of bytes
+   */
+  public getLength(): number {
+    return concat(this.bytesArray).byteLength
+  }
+
+  /**
+   * Put bytes in the BytesList
+   *
+   * @param bytesArg A Uint8Array
+   * @return this BytesList
+   */
+  public put(bytesArg: Uint8Array): BytesList {
+    const bytes = Uint8Array.from(bytesArg) // Temporary, to catch instances of Uint8Array being passed in
+    this.bytesArray.push(bytes)
+    return this
+  }
+
+  /**
+   * Write this BytesList to the back of another bytes list
+   *
+   *  @param list The BytesList to write to
+   */
+  public toBytesSink(list: BytesList): void {
+    list.put(this.toBytes())
+  }
+
+  public toBytes(): Uint8Array {
+    return concat(this.bytesArray)
+  }
+
+  toHex(): string {
+    return bytesToHex(this.toBytes())
+  }
+}
+
+/**
+ * BinarySerializer is used to write fields and values to Uint8Arrays
+ */
+class BinarySerializer {
+  private sink: BytesList = new BytesList()
+
+  constructor(sink: BytesList) {
+    this.sink = sink
+  }
+
+  /**
+   * Write a value to this BinarySerializer
+   *
+   * @param value a SerializedType value
+   */
+  write(value: SerializedType): void {
+    value.toBytesSink(this.sink)
+  }
+
+  /**
+   * Write bytes to this BinarySerializer
+   *
+   * @param bytes the bytes to write
+   */
+  put(bytes: Uint8Array): void {
+    this.sink.put(bytes)
+  }
+
+  /**
+   * Write a value of a given type to this BinarySerializer
+   *
+   * @param type the type to write
+   * @param value a value of that type
+   */
+  writeType(type: typeof SerializedType, value: SerializedType): void {
+    this.write(type.from(value))
+  }
+
+  /**
+   * Write BytesList to this BinarySerializer
+   *
+   * @param bl BytesList to write to BinarySerializer
+   */
+  writeBytesList(bl: BytesList): void {
+    bl.toBytesSink(this.sink)
+  }
+
+  /**
+   * Calculate the header of Variable Length encoded bytes
+   *
+   * @param length the length of the bytes
+   */
+  static encodeVariableLength(length: number): Uint8Array {
+    const lenBytes = new Uint8Array(3)
+    if (length <= 192) {
+      lenBytes[0] = length
+      return lenBytes.slice(0, 1)
+    } else if (length <= 12480) {
+      length -= 193
+      lenBytes[0] = 193 + (length >>> 8)
+      lenBytes[1] = length & 0xff
+      return lenBytes.slice(0, 2)
+    } else if (length <= 918744) {
+      length -= 12481
+      lenBytes[0] = 241 + (length >>> 16)
+      lenBytes[1] = (length >> 8) & 0xff
+      lenBytes[2] = length & 0xff
+      return lenBytes.slice(0, 3)
+    }
+    throw new Error('Overflow error')
+  }
+
+  /**
+   * Write field and value to BinarySerializer
+   *
+   * @param field field to write to BinarySerializer
+   * @param value value to write to BinarySerializer
+   */
+  writeFieldAndValue(
+    field: FieldInstance,
+    value: SerializedType,
+    isUnlModifyWorkaround = false,
+  ): void {
+    const associatedValue = field.associatedType.from(value)
+    if (associatedValue.toBytesSink === undefined || field.name === undefined) {
+      throw new Error()
+    }
+
+    this.sink.put(field.header)
+
+    if (field.isVariableLengthEncoded) {
+      this.writeLengthEncoded(associatedValue, isUnlModifyWorkaround)
+    } else {
+      associatedValue.toBytesSink(this.sink)
+    }
+  }
+
+  /**
+   * Write a variable length encoded value to the BinarySerializer
+   *
+   * @param value length encoded value to write to BytesList
+   */
+  public writeLengthEncoded(
+    value: SerializedType,
+    isUnlModifyWorkaround = false,
+  ): void {
+    const bytes = new BytesList()
+    if (!isUnlModifyWorkaround) {
+      // this part doesn't happen for the Account field in a UNLModify transaction
+      value.toBytesSink(bytes)
+    }
+    this.put(BinarySerializer.encodeVariableLength(bytes.getLength()))
+    this.writeBytesList(bytes)
+  }
+}
+
+export { BytesList, BinarySerializer }

package/src/shamap.ts

@@ -0,0 +1,189 @@
+import { coreTypes } from './types'
+import { HashPrefix } from './hash-prefixes'
+import { Sha512Half } from './hashes'
+import { Hash256 } from './types/hash-256'
+import { BytesList } from './serdes/binary-serializer'
+
+/**
+ * Abstract class describing a SHAMapNode
+ */
+abstract class ShaMapNode {
+  abstract hashPrefix(): Uint8Array
+  abstract isLeaf(): boolean
+  abstract isInner(): boolean
+  abstract toBytesSink(list: BytesList): void
+  abstract hash(): Hash256
+}
+
+/**
+ * Class describing a Leaf of SHAMap
+ */
+class ShaMapLeaf extends ShaMapNode {
+  constructor(
+    public index: Hash256,
+    public item?: ShaMapNode,
+  ) {
+    super()
+  }
+
+  /**
+   * @returns true as ShaMapLeaf is a leaf node
+   */
+  isLeaf(): boolean {
+    return true
+  }
+
+  /**
+   * @returns false as ShaMapLeaf is not an inner node
+   */
+  isInner(): boolean {
+    return false
+  }
+
+  /**
+   * Get the prefix of the this.item
+   *
+   * @returns The hash prefix, unless this.item is undefined, then it returns an empty Uint8Array
+   */
+  hashPrefix(): Uint8Array {
+    return this.item === undefined ? new Uint8Array(0) : this.item.hashPrefix()
+  }
+
+  /**
+   * Hash the bytes representation of this
+   *
+   * @returns hash of this.item concatenated with this.index
+   */
+  hash(): Hash256 {
+    const hash = Sha512Half.put(this.hashPrefix())
+    this.toBytesSink(hash)
+    return hash.finish()
+  }
+
+  /**
+   * Write the bytes representation of this to a BytesList
+   * @param list BytesList to write bytes to
+   */
+  toBytesSink(list: BytesList): void {
+    if (this.item !== undefined) {
+      this.item.toBytesSink(list)
+    }
+    this.index.toBytesSink(list)
+  }
+}
+
+/**
+ * Class defining an Inner Node of a SHAMap
+ */
+class ShaMapInner extends ShaMapNode {
+  private slotBits = 0
+  private branches: Array<ShaMapNode> = Array(16)
+
+  constructor(private depth = 0) {
+    super()
+  }
+
+  /**
+   * @returns true as ShaMapInner is an inner node
+   */
+  isInner(): boolean {
+    return true
+  }
+
+  /**
+   * @returns false as ShaMapInner is not a leaf node
+   */
+  isLeaf(): boolean {
+    return false
+  }
+
+  /**
+   * Get the hash prefix for this node
+   *
+   * @returns hash prefix describing an inner node
+   */
+  hashPrefix(): Uint8Array {
+    return HashPrefix.innerNode
+  }
+
+  /**
+   * Set a branch of this node to be another node
+   *
+   * @param slot Slot to add branch to this.branches
+   * @param branch Branch to add
+   */
+  setBranch(slot: number, branch: ShaMapNode): void {
+    this.slotBits = this.slotBits | (1 << slot)
+    this.branches[slot] = branch
+  }
+
+  /**
+   * @returns true if node is empty
+   */
+  empty(): boolean {
+    return this.slotBits === 0
+  }
+
+  /**
+   * Compute the hash of this node
+   *
+   * @returns The hash of this node
+   */
+  hash(): Hash256 {
+    if (this.empty()) {
+      return (coreTypes.Hash256 as typeof Hash256).ZERO_256
+    }
+    const hash = Sha512Half.put(this.hashPrefix())
+    this.toBytesSink(hash)
+    return hash.finish()
+  }
+
+  /**
+   * Writes the bytes representation of this node to a BytesList
+   *
+   * @param list BytesList to write bytes to
+   */
+  toBytesSink(list: BytesList): void {
+    for (let i = 0; i < this.branches.length; i++) {
+      const branch = this.branches[i]
+      const hash = branch
+        ? branch.hash()
+        : (coreTypes.Hash256 as typeof Hash256).ZERO_256
+      hash.toBytesSink(list)
+    }
+  }
+
+  /**
+   * Add item to the SHAMap
+   *
+   * @param index Hash of the index of the item being inserted
+   * @param item Item to insert in the map
+   * @param leaf Leaf node to insert when branch doesn't exist
+   */
+  addItem(index?: Hash256, item?: ShaMapNode, leaf?: ShaMapLeaf): void {
+    if (index === undefined) {
+      throw new Error()
+    }
+    if (index !== undefined) {
+      const nibble = index.nibblet(this.depth)
+      const existing = this.branches[nibble]
+
+      if (existing === undefined) {
+        this.setBranch(nibble, leaf || new ShaMapLeaf(index, item))
+      } else if (existing instanceof ShaMapLeaf) {
+        const newInner = new ShaMapInner(this.depth + 1)
+        newInner.addItem(existing.index, undefined, existing)
+        newInner.addItem(index, item, leaf)
+        this.setBranch(nibble, newInner)
+      } else if (existing instanceof ShaMapInner) {
+        existing.addItem(index, item, leaf)
+      } else {
+        throw new Error('invalid ShaMap.addItem call')
+      }
+    }
+  }
+}
+
+class ShaMap extends ShaMapInner {}
+
+export { ShaMap, ShaMapNode, ShaMapLeaf }

package/src/types/account-id.ts

@@ -0,0 +1,91 @@
+import {
+  decodeAccountID,
+  encodeAccountID,
+  isValidXAddress,
+  xAddressToClassicAddress,
+} from '@transia/ripple-address-codec'
+import { Hash160 } from './hash-160'
+import { hexToBytes } from '@transia/isomorphic/utils'
+import { SerializedTypeID } from './serialized-type'
+
+const HEX_REGEX = /^[A-F0-9]{40}$/
+
+/**
+ * Class defining how to encode and decode an AccountID
+ */
+class AccountID extends Hash160 {
+  static readonly defaultAccountID: AccountID = new AccountID(
+    new Uint8Array(20),
+  )
+
+  constructor(bytes?: Uint8Array) {
+    super(bytes ?? AccountID.defaultAccountID.bytes)
+  }
+
+  /**
+   * Defines how to construct an AccountID
+   *
+   * @param value either an existing AccountID, a hex-string, or a base58 r-Address
+   * @returns an AccountID object
+   */
+  static from<T extends Hash160 | string>(value: T): AccountID {
+    if (value instanceof AccountID) {
+      return value
+    }
+
+    if (typeof value === 'string') {
+      if (value === '') {
+        return new AccountID()
+      }
+
+      return HEX_REGEX.test(value)
+        ? new AccountID(hexToBytes(value))
+        : this.fromBase58(value)
+    }
+
+    throw new Error('Cannot construct AccountID from value given')
+  }
+
+  /**
+   * Defines how to build an AccountID from a base58 r-Address
+   *
+   * @param value a base58 r-Address
+   * @returns an AccountID object
+   */
+  static fromBase58(value: string): AccountID {
+    if (isValidXAddress(value)) {
+      const classic = xAddressToClassicAddress(value)
+
+      if (classic.tag !== false)
+        throw new Error('Only allowed to have tag on Account or Destination')
+
+      value = classic.classicAddress
+    }
+
+    return new AccountID(Uint8Array.from(decodeAccountID(value)))
+  }
+
+  /**
+   * Overload of toJSON
+   *
+   * @returns the base58 string for this AccountID
+   */
+  toJSON(): string {
+    return this.toBase58()
+  }
+
+  /**
+   * Defines how to encode AccountID into a base58 address
+   *
+   * @returns the base58 string defined by this.bytes
+   */
+  toBase58(): string {
+    return encodeAccountID(this.bytes)
+  }
+
+  getSType(): SerializedTypeID {
+    return SerializedTypeID.STI_ACCOUNT
+  }
+}
+
+export { AccountID }