xrpl-ruby 0.2.4 → 0.6.0

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

@@ -3,8 +3,6 @@
 require 'bigdecimal'
 require 'bigdecimal/util'
 
-require_relative '../utilities'
-
 module BinaryCodec
   class Amount < SerializedType
 
@@ -18,6 +16,8 @@ module BinaryCodec
 
     MAX_DROPS = BigDecimal("1e17")
     MIN_XRP = BigDecimal("1e-6")
+    MIN_XRP_DROPS = 1
+    MAX_XRP_DROPS = 10**17
 
     def initialize(bytes = nil)
       if bytes.nil?
@@ -31,70 +31,91 @@ module BinaryCodec
     #
     # @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)
+        number = value.to_i
+        amount_bytes = int_to_bytes(number, 8)
+        amount_bytes[0] |= 0x40
+        return Amount.new(amount_bytes)
       end
 
-      if is_amount_object_iou?(value)
-        number = BigDecimal(value[:value])
-        self.assert_iou_is_valid(number)
+      if value.respond_to?(:key?)
+        val = value[:value] || value['value']
+        cur = value[:currency] || value['currency']
+        iss = value[:issuer] || value['issuer']
 
-        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
+        if val && cur && iss
+          number = BigDecimal(val.to_s)
+          
+          if number.precision > MAX_IOU_PRECISION
+            raise ArgumentError, 'Decimal precision out of range'
+          end
 
-          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)
+          currency_inst = Currency.from(cur)
+          issuer_inst = AccountId.from(iss)
 
-          amount = int_buf.flatten
+          if number.zero?
+            iou_bytes = [0x80, 0, 0, 0, 0, 0, 0, 0]
+            return Amount.new(iou_bytes + currency_inst.to_bytes + issuer_inst.to_bytes)
+          end
 
-          amount[0] |= 0x80
+          is_positive = number >= 0
+          abs_value = number.abs
+          
+          exponent = (Math.log10(abs_value.to_f).floor) - 15
+          mantissa = (abs_value / (BigDecimal(10)**exponent)).to_i
 
-          if number > 0
-            amount[0] |= 0x40
+          while mantissa < 1000000000000000
+            mantissa *= 10
+            exponent -= 1
+          end
+          while mantissa > 9999999999999999
+            mantissa /= 10
+            exponent += 1
           end
 
-          exponent = number.exponent - 16
-          exponent_byte = 97 + exponent
-          amount[0] |= exponent_byte >> 2
-          amount[1] |= (exponent_byte & 0x03) << 6
+          exponent_byte = exponent + 97
+          b1 = (is_positive ? 0x40 : 0) | 0x80 | (exponent_byte >> 2)
+          b2 = ((exponent_byte & 0x03) << 6) | (mantissa >> 48)
+
+          iou_bytes = [
+            b1, b2,
+            (mantissa >> 40) & 0xff,
+            (mantissa >> 32) & 0xff,
+            (mantissa >> 24) & 0xff,
+            (mantissa >> 16) & 0xff,
+            (mantissa >> 8) & 0xff,
+            mantissa & 0xff
+          ]
+          return Amount.new(iou_bytes + currency_inst.to_bytes + issuer_inst.to_bytes)
         end
+      end
 
-        currency = Currency.from(value[:currency]).to_bytes
-        issuer = AccountId.from(value[:issuer]).to_bytes
-
-        return Amount.new(amount + currency + issuer)
+      if value.is_a?(Integer)
+        Amount.assert_xrp_is_valid(value.to_s)
+        amount_bytes = int_to_bytes(value, 8)
+        amount_bytes[0] |= 0x40
+        return Amount.new(amount_bytes)
       end
 
+      raise ArgumentError, "Cannot construct Amount from the value given"
     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)
+    # @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
 
@@ -107,9 +128,13 @@ module BinaryCodec
     # The JSON representation of this Amount
     #
     # @return [Hash, String] The JSON interpretation of this.bytes
-    def to_json
+    # 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 # Duplicate the bytes to avoid mutation
+        bytes = @bytes.dup
         is_positive = (bytes[0] & 0x40) != 0
         sign = is_positive ? '' : '-'
         bytes[0] &= 0x3f
@@ -122,47 +147,54 @@ module BinaryCodec
       end
 
       if is_iou?
-        parser = BinaryParser.new(to_s)
-        mantissa = parser.read(8)
+        parser = BinaryParser.new(to_hex)
+        mantissa_bytes = parser.read(8)
         currency = Currency.from_parser(parser)
         issuer = AccountId.from_parser(parser)
 
-        b1 = mantissa[0]
-        b2 = mantissa[1]
+        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[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)
+        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 = mantissa * 10^exponent
+        value = BigDecimal(mantissa_int) * (BigDecimal(10)**exponent)
+        value = -value unless is_positive
+        
+        # Format the value string to match xrpl.js (stripping trailing .0)
+        formatted_value = value.to_s('F').sub(/\.0$/, '')
 
         return {
-          "value" => value.to_s('F'),
+          "value" => formatted_value,
           "currency" => currency.to_json,
           "issuer" => issuer.to_json
-        }.to_s
+        }
       end
 
       if is_mpt?
-        parser = BinaryParser.new(to_s)
+        parser = BinaryParser.new(to_hex)
         leading_byte = parser.read(1)
-        amount = parser.read(8)
+        amount_bytes = 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])
+        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_s
-        }.to_s
+          "value" => "#{sign}#{num}",
+          "mpt_issuance_id" => mpt_id.to_hex
+        }
       end
 
       raise 'Invalid amount to construct JSON'
@@ -172,17 +204,23 @@ module BinaryCodec
 
     # 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'
+      return false unless arg.is_a?(::Hash)
+      
+      # Handle both string and symbol keys
+      processed = arg.transform_keys(&:to_s)
+      
+      # Log for debugging
+      # puts "DEBUG: Checking if #{processed.keys.inspect} is IOU"
+
+      processed.key?('currency') &&
+        processed.key?('issuer') &&
+        processed.key?('value')
     end
 
     # Type guard for AmountObjectMPT
     def self.is_amount_object_mpt?(arg)
-      keys = arg.keys.sort
+      return false unless arg.is_a?(::Hash)
+      keys = arg.transform_keys(&:to_s).keys.sort
 
       keys.length == 2 &&
         keys[0] == 'mpt_issuance_id' &&
@@ -198,9 +236,9 @@ module BinaryCodec
         raise "#{amount} is an illegal amount"
       end
 
-      decimal = BigDecimal(amount)
+      decimal = amount.to_i
       unless decimal.zero?
-        if decimal < MIN_XRP || decimal > MAX_DROPS
+        if decimal < MIN_XRP_DROPS || decimal > MAX_XRP_DROPS
           raise "#{amount} is an illegal amount"
         end
       end
@@ -247,21 +285,25 @@ module BinaryCodec
     # 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.
+    # 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
+      # p is the number of significant digits
+      # e is the power of 10 to multiply by the mantissa to get the number
+      # BigDecimal('1.1234567891234567').precision => 17
+      if decimal.precision > MAX_IOU_PRECISION
+        raise ArgumentError, 'Decimal precision out of range'
+      end
     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
@@ -269,6 +311,8 @@ module BinaryCodec
     # 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
@@ -276,6 +320,8 @@ module BinaryCodec
     # 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

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

@@ -1,29 +1,38 @@
 # frozen_string_literal: true
 
-require_relative '../../core/core'
-
 module BinaryCodec
   class Blob < SerializedType
 
     def initialize(byte_buf = nil)
-      @bytes = byte_buf || Array.new(0)
+      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)
-        if value !~ /^[A-F0-9]*$/i
+        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)
-      Blob.new(parser.read(hint))
+      new(parser.read(hint))
     end
 
   end

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

@@ -15,8 +15,8 @@ module BinaryCodec
     @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)
+      super(byte_buf)
+      hex = to_hex
 
       if XRP_HEX_REGEX.match?(hex)
         @_iso = 'XRP'
@@ -27,20 +27,31 @@ module BinaryCodec
       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 Currency.new(bytes_from_representation(value))
+        return new(bytes_from_representation(value))
       end
 
-      raise StandardError, 'Cannot construct Currency from value given'
+      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?

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

@@ -2,24 +2,49 @@
 
 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, 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}"
+    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
 
-    def self.from(hex_string)
-      new(hex_to_bytes(hex_string))
+    # 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
@@ -42,15 +67,9 @@ module BinaryCodec
 
   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)
+      super(bytes)
     end
 
     def to_hex
@@ -62,43 +81,25 @@ module BinaryCodec
 
   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)
+      super(bytes)
     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)
+      super(bytes)
     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)
+      super(bytes)
     end
   end
 

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

@@ -0,0 +1,47 @@
+# 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, size_hint = nil)
+      bytes = []
+      return Issue.new(bytes) if parser.end?
+      bytes.concat(parser.read(20)) # Currency
+      unless parser.end? || (size_hint && size_hint <= 20)
+        bytes.concat(parser.read(20))
+      end
+      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
+    rescue
+      # Fallback for partial/invalid binary
+      { 'currency' => Currency.new(to_bytes[0, 20]).to_json }
+    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