xrpl-ruby 0.0.3 → 0.5.0

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

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+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
+    # Creates a new Amount instance from a value.
+    # @param value [Amount, String, Hash, Integer] The value to convert.
+    # @return [Amount] The created instance.
+    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 bundle exec rspec spec/binary-codec/types/st_object_spec.rb object
+    # Creates an Amount instance from a parser.
+    # @param parser [BinaryParser] The parser to read from.
+    # @param _size_hint [Integer, nil] Optional size hint (unused).
+    # @return [Amount] The created instance.
+    def self.from_parser(parser, _size_hint = nil)
+      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
+    # Returns the JSON representation of the Amount.
+    # @param _definitions [Definitions, nil] Unused.
+    # @param _field_name [String, nil] Optional field name.
+    # @return [String, Hash] The JSON representation.
+    def to_json(_definitions = nil, _field_name = nil)
+      if is_native?
+        bytes = @bytes.dup
+        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_hex)
+        mantissa_bytes = parser.read(8)
+        currency = Currency.from_parser(parser)
+        issuer = AccountId.from_parser(parser)
+
+        b1 = mantissa_bytes[0]
+        b2 = mantissa_bytes[1]
+
+        is_positive = (b1 & 0x40) != 0
+        sign = is_positive ? '' : '-'
+        exponent = ((b1 & 0x3f) << 2) + ((b2 & 0xff) >> 6) - 97
+
+        mantissa_bytes[0] = 0
+        mantissa_bytes[1] &= 0x3f
+        
+        # Convert mantissa bytes to integer
+        mantissa_int = mantissa_bytes.reduce(0) { |acc, b| (acc << 8) + b }
+        
+        value = BigDecimal(mantissa_int) * (BigDecimal(10)**exponent)
+        value = -value unless is_positive
+        self.class.assert_iou_is_valid(value)
+
+        return {
+          "value" => value.to_s('F').sub(/\.0$/, ''),
+          "currency" => currency.to_json,
+          "issuer" => issuer.to_json
+        }
+      end
+
+      if is_mpt?
+        parser = BinaryParser.new(to_hex)
+        leading_byte = parser.read(1)
+        amount_bytes = parser.read(8)
+        mpt_id = Hash192.from_parser(parser)
+
+        is_positive = (leading_byte[0] & 0x40) != 0
+        sign = is_positive ? '' : '-'
+
+        msb = BinaryCodec.read_uint32be(amount_bytes[0, 4])
+        lsb = BinaryCodec.read_uint32be(amount_bytes[4, 4])
+        num = (msb << 32) | lsb
+
+        return {
+          "value" => "#{sign}#{num}",
+          "mpt_issuance_id" => mpt_id.to_hex
+        }
+      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. Example failure:1.1234567891234567
+    #
+    # @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)
+    # Checks if the amount is a native XRP amount.
+    # @return [Boolean] True if native, false otherwise.
+    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
+    # Checks if the amount is a multi-purpose token (MPT).
+    # @return [Boolean] True if MPT, false otherwise.
+    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
+    # Checks if the amount is an IOU amount.
+    # @return [Boolean] True if IOU, false otherwise.
+    def is_iou?
+      (self.bytes[0] & 0x80) != 0
+    end
+
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class Blob < SerializedType
+
+    def initialize(byte_buf = nil)
+      super(byte_buf || [])
+    end
+
+    # Creates a new Blob instance from a value.
+    # @param value [Blob, String, Array<Integer>] The value to convert.
+    # @return [Blob] The created instance.
+    def self.from(value)
+      return value if value.is_a?(Blob)
+
+      if value.is_a?(String)
+        unless valid_hex?(value)
+          raise StandardError, 'Cannot construct Blob from a non-hex string'
+        end
+        return Blob.new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Array)
+        return Blob.new(value)
+      end
+
+      raise StandardError, 'Cannot construct Blob from value given'
+    end
+
+    # Creates a Blob instance from a parser.
+    # @param parser [BinaryParser] The parser to read from.
+    # @param hint [Integer, nil] Optional width hint.
+    # @return [Blob] The created instance.
+    def self.from_parser(parser, hint = nil)
+      new(parser.read(hint))
+    end
+
+  end
+
+
+end

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

@@ -0,0 +1,116 @@
+# 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)
+      hex = to_hex
+
+      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
+
+    # Returns the ISO code of the currency, if applicable.
+    # @return [String, nil] The ISO code.
+    def iso
+      @_iso
+    end
+
+    # Creates a new Currency instance from a value.
+    # @param value [Currency, String, Array<Integer>] The value to convert.
+    # @return [Currency] The created instance.
+    def self.from(value)
+      return value if value.is_a?(Currency)
+
+      if value.is_a?(String)
+        return new(bytes_from_representation(value))
+      end
+
+      if value.is_a?(Array)
+        return new(value)
+      end
+
+      raise StandardError, "Cannot construct Currency from #{value.class}"
+    end
+
+    # Returns the JSON representation of the currency.
+    # @return [String] The ISO code or hex string.
+    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,106 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class Hash < ComparableSerializedType
+    # Returns the width of the Hash type in bytes.
+    # @return [Integer] The width.
+    def self.width
+      @width
+    end
+
+    def initialize(bytes = nil)
+      bytes = Array.new(self.class.width, 0) if bytes.nil? || bytes.empty?
+      super(bytes)
+      if @bytes.length != self.class.width
+        raise StandardError, "Invalid Hash length #{@bytes.length}"
+      end
+    end
+
+    # Creates a new Hash instance from a value.
+    # @param value [Hash, String, Array<Integer>] The value to convert.
+    # @return [Hash] The created instance.
+    def self.from(value)
+      return value if value.is_a?(self)
+
+      if value.is_a?(String)
+        return new if value.empty?
+        return new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Array)
+        return new(value)
+      end
+
+      raise StandardError, "Cannot construct #{self} from the value given"
+    end
+
+    # Creates a Hash instance from a parser.
+    # @param parser [BinaryParser] The parser to read from.
+    # @param hint [Integer, nil] Optional width hint.
+    # @return [Hash] The created instance.
+    def self.from_parser(parser, hint = nil)
+      new(parser.read(hint || width))
+    end
+
+    # Compares this Hash to another Hash.
+    # @param other [Hash] The other Hash to compare to.
+    # @return [Integer] Comparison result (-1, 0, or 1).
+    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
+
+    def initialize(bytes = nil)
+      super(bytes)
+    end
+
+    def to_hex
+      hex = bytes_to_hex(to_bytes)
+      return '' if hex.match?(/^0+$/)
+      hex
+    end
+  end
+
+  class Hash160 < Hash
+    @width = 20
+
+    def initialize(bytes = nil)
+      super(bytes)
+    end
+  end
+
+  class Hash192 < Hash
+    @width = 24
+
+    def initialize(bytes = nil)
+      super(bytes)
+    end
+  end
+
+  class Hash256 < Hash
+    @width = 32
+
+    def initialize(bytes = nil)
+      super(bytes)
+    end
+  end
+
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class Issue < SerializedType
+    def initialize(bytes = nil)
+      super(bytes || [])
+    end
+
+    def self.from(value)
+      return value if value.is_a?(Issue)
+
+      if value.is_a?(String)
+        return Issue.new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Hash) || value.is_a?(::Hash)
+        bytes = []
+        bytes.concat(Currency.from(value['currency']).to_bytes)
+        bytes.concat(AccountId.from(value['issuer']).to_bytes) if value['issuer']
+        return Issue.new(bytes)
+      end
+
+      raise StandardError, "Cannot construct Issue from #{value.class}"
+    end
+
+    def self.from_parser(parser, _hint = nil)
+      bytes = []
+      bytes.concat(parser.read(20)) # Currency
+      # If there are more bytes in this field, it might have an issuer?
+      # Actually Issue is often fixed length 20 or 40.
+      # For XChainBridge it uses Issue.
+      # Let's see how much we should read. 
+      # Usually if it's an Issue in a field, we might know the size.
+      # For now, let's assume it can be 20 or 40.
+      # But wait, how does the parser know?
+      # If it's not variable length, it must have a fixed width or be the rest of the object.
+      # Definitions.json says Issue is type 24.
+      bytes.concat(parser.read(20)) unless parser.end? # Try reading issuer
+      Issue.new(bytes)
+    end
+
+    def to_json(_definitions = nil, _field_name = nil)
+      parser = BinaryParser.new(to_hex)
+      result = {}
+      result['currency'] = Currency.from_parser(parser).to_json
+      result['issuer'] = AccountId.from_parser(parser).to_json unless parser.end?
+      result
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class PathSet < SerializedType
+    PATH_STEP_END_MARKER = 0xFF
+    PATH_END_MARKER = 0xFE
+
+    TYPE_ACCOUNT = 0x01
+    TYPE_CURRENCY = 0x10
+    TYPE_ISSUER = 0x20
+
+    def initialize(bytes = nil)
+      super(bytes || [])
+    end
+
+    def self.from(value)
+      return value if value.is_a?(PathSet)
+
+      if value.is_a?(String)
+        return PathSet.new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Array)
+        bytes = []
+        value.each_with_index do |path, index|
+          path.each do |step|
+            type = 0
+            step_bytes = []
+
+            if step['account']
+              type |= TYPE_ACCOUNT
+              step_bytes.concat(AccountId.from(step['account']).to_bytes)
+            end
+            if step['currency']
+              type |= TYPE_CURRENCY
+              step_bytes.concat(Currency.from(step['currency']).to_bytes)
+            end
+            if step['issuer']
+              type |= TYPE_ISSUER
+              step_bytes.concat(AccountId.from(step['issuer']).to_bytes)
+            end
+
+            bytes << type
+            bytes.concat(step_bytes)
+          end
+          bytes << (index == value.length - 1 ? PATH_END_MARKER : PATH_STEP_END_MARKER)
+        end
+        return PathSet.new(bytes)
+      end
+
+      raise StandardError, "Cannot construct PathSet from #{value.class}"
+    end
+
+    def self.from_parser(parser, _hint = nil)
+      bytes = []
+      loop do
+        type = parser.read_uint8
+        bytes << type
+        break if type == PATH_END_MARKER
+
+        if type != PATH_STEP_END_MARKER
+          bytes.concat(parser.read(20)) if (type & TYPE_ACCOUNT) != 0
+          bytes.concat(parser.read(20)) if (type & TYPE_CURRENCY) != 0
+          bytes.concat(parser.read(20)) if (type & TYPE_ISSUER) != 0
+        end
+      end
+      PathSet.new(bytes)
+    end
+
+    def to_json(_definitions = nil, _field_name = nil)
+      parser = BinaryParser.new(to_hex)
+      paths = []
+      current_path = []
+
+      until parser.end?
+        type = parser.read_uint8
+        if type == PATH_END_MARKER || type == PATH_STEP_END_MARKER
+          paths << current_path
+          current_path = []
+          break if type == PATH_END_MARKER
+          next
+        end
+
+        step = {}
+        step['account'] = AccountId.from_parser(parser).to_json if (type & TYPE_ACCOUNT) != 0
+        step['currency'] = Currency.from_parser(parser).to_json if (type & TYPE_CURRENCY) != 0
+        step['issuer'] = AccountId.from_parser(parser).to_json if (type & TYPE_ISSUER) != 0
+        current_path << step
+      end
+      paths
+    end
+  end
+end