xrpl-ruby 0.0.1 → 0.2.4

data/lib/binary-codec/types/amount.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+require_relative '../utilities'
+
+module BinaryCodec
+  class Amount < SerializedType
+
+    DEFAULT_AMOUNT_HEX = "4000000000000000".freeze
+    ZERO_CURRENCY_AMOUNT_HEX = "8000000000000000".freeze
+    NATIVE_AMOUNT_BYTE_LENGTH = 8
+    CURRENCY_AMOUNT_BYTE_LENGTH = 48
+    MAX_IOU_PRECISION = 16
+    MIN_IOU_EXPONENT = -96
+    MAX_IOU_EXPONENT = 80
+
+    MAX_DROPS = BigDecimal("1e17")
+    MIN_XRP = BigDecimal("1e-6")
+
+    def initialize(bytes = nil)
+      if bytes.nil?
+        bytes = hex_to_bytes(DEFAULT_AMOUNT_HEX)
+      end
+
+      @bytes = bytes
+    end
+
+    # Construct an amount from an IOU, MPT, or string amount
+    #
+    # @param value [Amount, Hash, String] representing the amount
+    # @return [Amount] an Amount object
+    def self.from(value)
+      return value if value.is_a?(Amount)
+
+      amount = Array.new(8, 0) # Equivalent to a Uint8Array of 8 zeros
+
+      if value.is_a?(String)
+        Amount.assert_xrp_is_valid(value)
+
+        number = value.to_i # Use to_i for equivalent BigInt handling
+
+        int_buf = [Array.new(4, 0), Array.new(4, 0)]
+        BinaryCodec.write_uint32be(int_buf[0], (number >> 32) & 0xFFFFFFFF, 0)
+        BinaryCodec.write_uint32be(int_buf[1], number & 0xFFFFFFFF, 0)
+
+        amount = int_buf.flatten
+
+        amount[0] |= 0x40
+
+        return Amount.new(amount)
+      end
+
+      if is_amount_object_iou?(value)
+        number = BigDecimal(value[:value])
+        self.assert_iou_is_valid(number)
+
+        if number.zero?
+          amount[0] |= 0x80
+        else
+          scale = number.frac.to_s('F').split('.').last.size
+          unscaled_value = (number * (10**scale)).to_i
+          int_string = unscaled_value.abs.to_s.ljust(16, '0')
+          num = int_string.to_i
+
+          int_buf = [Array.new(4, 0), Array.new(4, 0)]
+          BinaryCodec.write_uint32be(int_buf[0], (num >> 32) & 0xFFFFFFFF)
+          BinaryCodec.write_uint32be(int_buf[1], num & 0xFFFFFFFF)
+
+          amount = int_buf.flatten
+
+          amount[0] |= 0x80
+
+          if number > 0
+            amount[0] |= 0x40
+          end
+
+          exponent = number.exponent - 16
+          exponent_byte = 97 + exponent
+          amount[0] |= exponent_byte >> 2
+          amount[1] |= (exponent_byte & 0x03) << 6
+        end
+
+        currency = Currency.from(value[:currency]).to_bytes
+        issuer = AccountId.from(value[:issuer]).to_bytes
+
+        return Amount.new(amount + currency + issuer)
+      end
+
+    end
+
+    # Read an amount from a BinaryParser
+    #
+    # @param parser [BinaryParser] The BinaryParser to read the Amount from
+    # @return [Amount] An Amount object
+    def self.from_parser(parser)
+      is_iou = parser.peek & 0x80 != 0
+      return Amount.new(parser.read(48)) if is_iou
+
+      # The amount can be either MPT or XRP at this point
+      is_mpt = parser.peek & 0x20 != 0
+      num_bytes = is_mpt ? 33 : 8
+      Amount.new(parser.read(num_bytes))
+    end
+
+    # The JSON representation of this Amount
+    #
+    # @return [Hash, String] The JSON interpretation of this.bytes
+    def to_json
+      if is_native?
+        bytes = @bytes.dup # Duplicate the bytes to avoid mutation
+        is_positive = (bytes[0] & 0x40) != 0
+        sign = is_positive ? '' : '-'
+        bytes[0] &= 0x3f
+
+        msb = BinaryCodec.read_uint32be(bytes[0, 4])
+        lsb = BinaryCodec.read_uint32be(bytes[4, 4])
+        num = (msb << 32) | lsb
+
+        return "#{sign}#{num}"
+      end
+
+      if is_iou?
+        parser = BinaryParser.new(to_s)
+        mantissa = parser.read(8)
+        currency = Currency.from_parser(parser)
+        issuer = AccountId.from_parser(parser)
+
+        b1 = mantissa[0]
+        b2 = mantissa[1]
+
+        is_positive = (b1 & 0x40) != 0
+        sign = is_positive ? '' : '-'
+        exponent = ((b1 & 0x3f) << 2) + ((b2 & 0xff) >> 6) - 97
+
+        mantissa[0] = 0
+        mantissa[1] &= 0x3f
+        value = BigDecimal("#{sign}#{bytes_to_hex(mantissa).to_i(16)}") * BigDecimal("1e#{exponent}")
+        self.class.assert_iou_is_valid(value)
+
+        return {
+          "value" => value.to_s('F'),
+          "currency" => currency.to_json,
+          "issuer" => issuer.to_json
+        }.to_s
+      end
+
+      if is_mpt?
+        parser = BinaryParser.new(to_s)
+        leading_byte = parser.read(1)
+        amount = parser.read(8)
+        mpt_id = Hash192.from_parser(parser)
+
+        is_positive = (leading_byte[0] & 0x40) != 0
+        sign = is_positive ? '' : '-'
+
+        msb = read_uint32be(amount[0, 4])
+        lsb = read_uint32be(amount[4, 4])
+        num = (msb << 32) | lsb
+
+        return {
+          value: "#{sign}#{num}",
+          mpt_issuance_id: mpt_id.to_s
+        }.to_s
+      end
+
+      raise 'Invalid amount to construct JSON'
+    end
+
+    private
+
+    # Type guard for AmountObjectIOU
+    def self.is_amount_object_iou?(arg)
+      keys = arg.transform_keys(&:to_s).keys.sort
+
+      keys.length == 3 &&
+        keys[0] == 'currency' &&
+        keys[1] == 'issuer' &&
+        keys[2] == 'value'
+    end
+
+    # Type guard for AmountObjectMPT
+    def self.is_amount_object_mpt?(arg)
+      keys = arg.keys.sort
+
+      keys.length == 2 &&
+        keys[0] == 'mpt_issuance_id' &&
+        keys[1] == 'value'
+    end
+
+    # Validate XRP amount
+    #
+    # @param amount [String] representing XRP amount
+    # @return [void], but raises an exception if the amount is invalid
+    def self.assert_xrp_is_valid(amount)
+      if amount.include?('.')
+        raise "#{amount} is an illegal amount"
+      end
+
+      decimal = BigDecimal(amount)
+      unless decimal.zero?
+        if decimal < MIN_XRP || decimal > MAX_DROPS
+          raise "#{amount} is an illegal amount"
+        end
+      end
+    end
+
+    # Validate IOU.value amount
+    #
+    # @param decimal [BigDecimal] object representing IOU.value
+    # @raise [ArgumentError] if the amount is invalid
+    def self.assert_iou_is_valid(decimal)
+      return if decimal.zero?
+
+      p = decimal.precision
+      e = (decimal.exponent || 0) - 15
+
+      if p > MAX_IOU_PRECISION || e > MAX_IOU_EXPONENT || e < MIN_IOU_EXPONENT
+        raise ArgumentError, 'Decimal precision out of range'
+      end
+
+      verify_no_decimal(decimal)
+    end
+
+    # Validate MPT.value amount
+    #
+    # @param amount [String] representing MPT.value
+    # @return [void], but raises an exception if the amount is invalid
+    def self.assert_mpt_is_valid(amount)
+      if amount.include?('.')
+        raise "#{amount} is an illegal amount"
+      end
+
+      decimal = BigDecimal(amount)
+      unless decimal.zero?
+        if decimal < BigDecimal("0")
+          raise "#{amount} is an illegal amount"
+        end
+
+        if (amount.to_i & mpt_mask) != 0
+          raise "#{amount} is an illegal amount"
+        end
+      end
+    end
+
+    # Ensure that the value, after being multiplied by the exponent, does not
+    # contain a decimal. This function is typically used to validate numbers
+    # that need to be represented as precise integers after scaling, such as
+    # amounts in financial transactions.
+    #
+    # @param decimal [BigDecimal] A BigDecimal object
+    # @raise [ArgumentError] if the value contains a decimal
+    # @return [String] The decimal converted to a string without a decimal point
+    def self.verify_no_decimal(decimal)
+      exponent = -((decimal.exponent || 0) - 16)
+      scaled_decimal = decimal * 10 ** exponent
+
+        raise ArgumentError, 'Decimal place found in int_string' unless scaled_decimal.frac == 0
+    end
+
+    # Check if this amount is in units of Native Currency (XRP)
+    #
+    # @return [Boolean] true if Native (XRP)
+    def is_native?
+      (self.bytes[0] & 0x80).zero? && (self.bytes[0] & 0x20).zero?
+    end
+
+    # Check if this amount is in units of MPT
+    #
+    # @return [Boolean] true if MPT
+    def is_mpt?
+      (self.bytes[0] & 0x80).zero? && (self.bytes[0] & 0x20) != 0
+    end
+
+    # Check if this amount is in units of IOU
+    #
+    # @return [Boolean] true if IOU
+    def is_iou?
+      (self.bytes[0] & 0x80) != 0
+    end
+
+  end
+end

data/lib/binary-codec/types/blob.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../core/core'
+
+module BinaryCodec
+  class Blob < SerializedType
+
+    def initialize(byte_buf = nil)
+      @bytes = byte_buf || Array.new(0)
+    end
+
+    def self.from(value)
+      return value if value.is_a?(Blob)
+
+      if value.is_a?(String)
+        if value !~ /^[A-F0-9]*$/i
+          raise StandardError, 'Cannot construct Blob from a non-hex string'
+        end
+        return Blob.new(hex_to_bytes(value))
+      end
+
+      raise StandardError, 'Cannot construct Blob from value given'
+    end
+
+    def self.from_parser(parser, hint = nil)
+      Blob.new(parser.read(hint))
+    end
+
+  end
+
+
+end

data/lib/binary-codec/types/currency.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../../core/core'
+
+module BinaryCodec
+  class Currency < Hash160
+
+    XRP_HEX_REGEX = /^0{40}$/
+    ISO_REGEX = /^[A-Z0-9a-z?!@#$%^&*(){}\[\]\|]{3}$/
+    HEX_REGEX = /^[A-F0-9]{40}$/
+    STANDARD_FORMAT_HEX_REGEX = /^0{24}[\x00-\x7F]{6}0{10}$/
+
+    attr_reader :iso
+
+    @width = 20
+
+    def initialize(byte_buf = nil)
+      super(byte_buf || Array.new(20, 0)) # Defaults to XRP bytes if no buffer is given
+      hex = bytes_to_hex(@bytes)
+
+      if XRP_HEX_REGEX.match?(hex)
+        @_iso = 'XRP'
+      elsif STANDARD_FORMAT_HEX_REGEX.match?(hex)
+        @_iso = iso_code_from_hex(@bytes[12..14])
+      else
+        @_iso = nil
+      end
+    end
+
+    def iso
+      @_iso
+    end
+
+    def self.from(value)
+      return value if value.is_a?(Currency)
+
+      if value.is_a?(String)
+        return Currency.new(bytes_from_representation(value))
+      end
+
+      raise StandardError, 'Cannot construct Currency from value given'
+    end
+
+    def to_json
+      iso = self.iso
+      return iso unless iso.nil?
+
+      bytes_to_hex(@bytes)
+    end
+
+    private
+
+    def iso_code_from_hex(code)
+      iso = hex_to_string(bytes_to_hex(code))
+      return nil if iso == 'XRP'
+      return iso if is_iso_code(iso)
+
+      nil
+    end
+
+    def is_iso_code(iso)
+      !!(ISO_REGEX.match(iso)) # Equivalent to test for regex
+    end
+
+    def self.bytes_from_representation(input)
+      unless is_valid_representation(input)
+        raise StandardError, "Unsupported Currency representation: #{input}"
+      end
+
+      input.length == 3 ? self.iso_to_bytes(input) : hex_to_bytes(input)
+    end
+
+    def self.iso_to_bytes(iso)
+      bytes = Array.new(20, 0) # Equivalent to Uint8Array(20)
+      if iso != 'XRP'
+        iso_bytes = iso.chars.map(&:ord)
+        # Insert iso_bytes at index 12
+        bytes[12, iso_bytes.length] = iso_bytes
+      end
+      bytes
+    end
+
+    def self.is_valid_representation(input)
+      if input.is_a?(Array)
+        self.is_bytes_array(input)
+      else
+        self.is_string_representation(input)
+      end
+    end
+
+    def self.is_string_representation(input)
+      input.length == 3 || is_hex(input)
+    end
+
+    def self.is_bytes_array(bytes)
+      bytes.length == 20
+    end
+
+    def self.is_hex(hex)
+      !!(HEX_REGEX.match(hex)) # Special case for Vurrency type, do not conflate with valid_hex? function
+    end
+
+  end
+
+end

data/lib/binary-codec/types/hash.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class Hash < ComparableSerializedType
+
+    def initialize(bytes, width)
+      @bytes = bytes
+      @width = width
+      if bytes.length != @width
+        # raise StandardError, "Invalid Hash length #{bytes.length} for width #{@width}"
+        raise StandardError, "Invalid Hash length #{bytes.length}"
+      end
+    end
+
+    def self.from(hex_string)
+      new(hex_to_bytes(hex_string))
+    end
+
+    def self.from_parser(parser, hint = nil)
+      new(parser.read(hint || width))
+    end
+
+    def compare_to(other)
+      @bytes <=> other.bytes
+    end
+
+    # Returns four bits at the specified depth within a hash
+    #
+    # @param depth [Integer] The depth of the four bits
+    # @return [Integer] The number represented by the four bits
+    def nibblet(depth)
+      byte_index = depth > 0 ? (depth / 2).floor : 0
+      b = bytes[byte_index]
+      if depth.even?
+        (b & 0xf0) >> 4
+      else
+        b & 0x0f
+      end
+    end
+
+  end
+
+  class Hash128 < Hash
+    @width = 16
+    @zero_128 = [0] * @width  # Array.new(@width, 0)
+
+    class << self
+      attr_reader :width, :zero_128
+    end
+
+    def initialize(bytes = nil)
+      bytes = self.class.zero_128 if bytes&.empty?
+      super(bytes, self.class.width)
+    end
+
+    def to_hex
+      hex = bytes_to_hex(to_bytes)
+      return '' if hex.match?(/^0+$/)
+      hex
+    end
+  end
+
+  class Hash160 < Hash
+    @width = 20
+    @zero_160 = [0] * @width  # Array.new(@width, 0)
+
+    class << self
+      attr_reader :width, :zero_160
+    end
+
+    def initialize(bytes = nil)
+      bytes = self.class.zero_160 if bytes&.empty?
+      super(bytes, self.class.width)
+    end
+  end
+
+  class Hash192 < Hash
+    @width = 24
+    @zero_192 = [0] * @width  # Array.new(@width, 0)
+
+    class << self
+      attr_reader :width, :zero_192
+    end
+
+    def initialize(bytes = nil)
+      bytes = self.class.zero_192 if bytes&.empty?
+      super(bytes, self.class.width)
+    end
+  end
+
+  class Hash256 < Hash
+    @width = 32
+    @zero_256 = [0] * @width  # Array.new(@width, 0)
+
+    class << self
+      attr_reader :width, :zero_256
+    end
+
+    def initialize(bytes = nil)
+      bytes = self.class.zero_256 if bytes&.empty?
+      super(bytes, self.class.width)
+    end
+  end
+
+end

data/lib/binary-codec/types/serialized_type.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative '../../core/core'
+
+module BinaryCodec
+  class SerializedType
+
+    attr_reader :bytes
+
+    def initialize(bytes = nil)
+      raise NotImplementedError, "#{self.class} is an abstract class and cannot be instantiated"
+    end
+
+    def self.from(value)
+      raise NotImplementedError, 'from not implemented'
+    end
+
+    def self.from_parser(parser, size_hint = nil)
+      raise NotImplementedError, 'from_parser not implemented'
+    end
+
+    # Check if this is needed
+    def self.from_json(json)
+      raise NotImplementedError, 'from_parser not implemented'
+    end
+
+    # Check if this is needed
+    def self.from_hex(hex)
+      self.from_bytes(hex_to_bytes(hex))
+    end
+
+    # Check if this is needed
+    def self.from_bytes(bytes)
+      new(bytes)
+    end
+
+    def to_byte_sink(sink)
+      sink.put(to_bytes)
+    end
+
+    # Serialize the given value into bytes
+    # This method must be implemented in the subclasses
+    # @return [Array<Integer>] - Byte array representing the serialized data
+    def to_bytes
+      @bytes
+    end
+
+    # Convert to a hex string
+    # @return [String] - Hexadecimal representation of the serialized data
+    def to_hex
+      bytes_to_hex(to_bytes)
+    end
+
+    # Deserialize instance data and convert it to JSON string
+    #
+    # @param _definitions [Hash] - Definitions for serialization
+    # @param _field_name [String] - Field name for serialization
+    # @return [String] - JSON representation of the serialized data
+    def to_json(_definitions = nil, _field_name = nil)
+      to_hex
+    end
+
+    # Represent object as a string (hexadecimal form)
+    def to_s
+      to_hex
+    end
+
+    def self.get_type_by_name(name)
+      type_map = {
+        "AccountID" => AccountId,
+        "Amount" => Amount,
+        "Blob" => Blob,
+        "Currency" => Currency,
+        "Hash128" => Hash128,
+        "Hash160" => Hash160,
+        "Hash256" => Hash256,
+        #"PathSet" => PathSet,
+        #"STArray" => STArray,
+        "STObject" => STObject,
+        "UInt8" => Uint8,
+        "UInt16" => Uint16,
+        "UInt32" => Uint32,
+        "UInt64" => Uint64,
+        #"Vector256" => Vector256
+      }
+
+      unless type_map.key?(name)
+        raise "unsupported type #{name}"
+      end
+
+      # Return class
+      type_map[name]
+    end
+
+  end
+
+  class ComparableSerializedType < SerializedType
+
+    # Compare if `self` is less than `other`
+    def lt(other)
+      compare_to(other) < 0
+    end
+
+    # Compare if `self` is equal to `other`
+    def eq(other)
+      compare_to(other) == 0
+    end
+
+    # Compare if `self` is greater than `other`
+    def gt(other)
+      compare_to(other) > 0
+    end
+
+    # Compare if `self` is greater than or equal to `other`
+    def gte(other)
+      compare_to(other) >= 0
+    end
+
+    # Compare if `self` is less than or equal to `other`
+    def lte(other)
+      compare_to(other) <= 0
+    end
+
+    # Overload this method in subclasses to define comparison logic
+    #
+    # @param other [Object] - The object to compare `self` to
+    # @return [Integer] - Returns -1, 0, or 1 depending on the comparison
+    def compare_to(other)
+      raise NotImplementedError, "Cannot compare #{self} and #{other}"
+    end
+  end
+
+end

data/lib/binary-codec/types/st_object.rb

@@ -0,0 +1,60 @@
+module BinaryCodec
+  class STObject  < SerializedType
+
+    OBJECT_END_MARKER_BYTE = [225]
+    OBJECT_END_MARKER = 'ObjectEndMarker'.freeze
+    ST_OBJECT = 'STObject'.freeze
+    DESTINATION = 'Destination'.freeze
+    ACCOUNT = 'Account'.freeze
+    SOURCE_TAG = 'SourceTag'.freeze
+    DEST_TAG = 'DestinationTag'.freeze
+
+    # attr_reader :type, :bytes
+    #
+    def initialize(byte_buf = nil)
+      @bytes = byte_buf || Array.new(0)
+    end
+
+    # Construct a STObject from a BinaryParser
+    #
+    # @param parser [BinaryParser] BinaryParser to read STObject from
+    # @param size_hint [Integer] Optional size hint for the object
+    # @return [STObject] A STObject object
+    def self.from_parser(parser, size_hint = nil)
+      list = BytesList.new
+      bytes = BinarySerializer.new(list)
+
+      until parser.end?
+        field = parser.read_field
+
+        break if field.name == OBJECT_END_MARKER
+
+        associated_value = parser.read_field_value(field)
+
+        bytes.write_field_and_value(field, associated_value)
+        bytes.put(OBJECT_END_MARKER_BYTE) if field.type == ST_OBJECT
+      end
+
+      STObject.new(list.to_bytes)
+    end
+
+    # Method to get the JSON interpretation of self.bytes
+    #
+    # @return [String] A stringified JSON object
+    def to_json()
+      parser = BinaryParser.new(to_s)
+      accumulator = {}
+
+      until parser.end?
+        field = parser.read_field
+        break if field.name == OBJECT_END_MARKER # Break if the object end marker is reached
+        value = parser.read_field_value(field).to_json
+        value = JSON.parse(value) if field.type == ST_OBJECT || field.type == Amount
+        accumulator[field.name] = value
+      end
+
+      JSON.generate(accumulator)
+    end
+
+  end
+end