xrpl-ruby 0.2.4 → 0.5.0

data/lib/binary-codec/enums/definitions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'json'
+require 'digest'
 
 module BinaryCodec
 
@@ -44,19 +45,30 @@ module BinaryCodec
 
      end
 
+    # Returns the singleton instance of the Definitions class.
+    # @return [Definitions] The singleton instance.
     def self.instance
       @@instance ||= new
     end
 
-     def get_field_header_from_name(field_name)
+    # Returns the field header for a given field name.
+    # @param field_name [String] The name of the field.
+    # @return [FieldHeader] The field header.
+    def get_field_header_from_name(field_name)
        @field_header_map[field_name]
      end
 
-     def get_field_name_from_header(field_header)
+    # Returns the field name for a given field header.
+    # @param field_header [FieldHeader] The field header.
+    # @return [String] The name of the field.
+    def get_field_name_from_header(field_header)
        @field_id_name_map[Digest::MD5.hexdigest(Marshal.dump(field_header))]
      end
 
-     def get_field_instance(field_name)
+    # Returns a FieldInstance for a given field name.
+    # @param field_name [String] The name of the field.
+    # @return [FieldInstance] The field instance.
+    def get_field_instance(field_name)
        field_info = @field_info_map[field_name]
        field_header = get_field_header_from_name(field_name)
 
@@ -66,10 +78,10 @@ module BinaryCodec
          is_serialized: field_info.is_serialized,
          is_signing_field: field_info.is_signing_field,
          type: field_info.type,
-         ordinal: (field_header.type << 16) | field_info.nth, # @type_ordinals[field_info.type],
+         ordinal: (@type_ordinals[field_info.type] << 16) | field_info.nth,
          name: field_name,
          header: field_header,
-         associated_type: field_info.type # SerializedType::getTypeByName($this->type)::class;
+         associated_type: SerializedType.get_type_by_name(field_info.type)
        )
      end
 

data/lib/binary-codec/enums/fields.rb

@@ -11,6 +11,8 @@ module BinaryCodec
       @nth = nth
     end
 
+    # Converts the field header to a byte array.
+    # @return [Array<Integer>] The byte array.
     def to_bytes
       header = []
       if type < 16

data/lib/binary-codec/serdes/binary_parser.rb

@@ -11,6 +11,8 @@ module BinaryCodec
       @definitions = Definitions.instance
     end
 
+    # Returns the first byte in the stream without consuming it.
+    # @return [Integer] The first byte.
     def peek
       if @bytes.empty?
         raise StandardError.new
@@ -18,6 +20,8 @@ module BinaryCodec
       @bytes[0]
     end
 
+    # Consumes n bytes from the stream.
+    # @param n [Integer] The number of bytes to skip.
     def skip(n)
       if n > @bytes.length
         raise StandardError.new
@@ -25,6 +29,9 @@ module BinaryCodec
       @bytes = @bytes[n..-1]
     end
 
+    # Reads n bytes from the stream.
+    # @param n [Integer] The number of bytes to read.
+    # @return [Array<Integer>] The read bytes.
     def read(n)
       if n > @bytes.length
         raise StandardError.new('End of byte stream reached')
@@ -35,6 +42,9 @@ module BinaryCodec
       slice
     end
 
+    # Reads n bytes and converts them to an unsigned integer.
+    # @param n [Integer] The number of bytes to read (1-4).
+    # @return [Integer] The resulting integer.
     def read_uint_n(n)
       if n <= 0 || n > 4
         raise StandardError.new('invalid n')
@@ -42,31 +52,46 @@ module BinaryCodec
       read(n).reduce(0) { |a, b| (a << 8) | b }
     end
 
+    # Reads a 1-byte unsigned integer.
+    # @return [Integer] The 8-bit integer.
     def read_uint8
       read_uint_n(1)
     end
 
+    # Reads a 2-byte unsigned integer.
+    # @return [Integer] The 16-bit integer.
     def read_uint16
       read_uint_n(2)
     end
 
+    # Reads a 4-byte unsigned integer.
+    # @return [Integer] The 32-bit integer.
     def read_uint32
       read_uint_n(4)
     end
 
+    # Returns the number of bytes remaining in the stream.
+    # @return [Integer] The remaining size.
     def size
       @bytes.length
     end
 
+    # Checks if the end of the stream has been reached.
+    # @param custom_end [Integer, nil] Optional offset to check against.
+    # @return [Boolean] True if at the end, false otherwise.
     def end?(custom_end = nil)
       length = @bytes.length
       length == 0 || (!custom_end.nil? && length <= custom_end)
     end
 
+    # Reads variable length data from the stream.
+    # @return [Array<Integer>] The read bytes.
     def read_variable_length
       read(read_variable_length_length)
     end
 
+    # Reads the length of a variable length data segment.
+    # @return [Integer] The length.
     def read_variable_length_length
       b1 = read_uint8
       if b1 <= 192
@@ -83,6 +108,8 @@ module BinaryCodec
       end
     end
 
+    # Reads a field header from the stream.
+    # @return [FieldHeader] The field header.
     def read_field_header
       type = read_uint8
       nth = type & 15
@@ -105,6 +132,8 @@ module BinaryCodec
       FieldHeader.new(type: type, nth: nth) # (type << 16) | nth for read_field_ordinal
     end
 
+    # Reads a field instance from the stream.
+    # @return [FieldInstance] The field instance.
     def read_field
       field_header = read_field_header
       field_name = @definitions.get_field_name_from_header(field_header)
@@ -112,14 +141,23 @@ module BinaryCodec
       @definitions.get_field_instance(field_name)
     end
 
+    # Reads a value of the specified type from the stream.
+    # @param type [Class] The class of the type to read (subclass of SerializedType).
+    # @return [SerializedType] The read value.
     def read_type(type)
       type.from_parser(self)
     end
 
+    # Returns the associated type for a given field.
+    # @param field [FieldInstance] The field instance.
+    # @return [Class] The associated SerializedType subclass.
     def type_for_field(field)
       field.associated_type
     end
 
+    # Reads the value of a specific field from the stream.
+    # @param field [FieldInstance] The field to read.
+    # @return [SerializedType] The read value.
     def read_field_value(field)
       type = SerializedType.get_type_by_name(field.type)
 

data/lib/binary-codec/serdes/binary_serializer.rb

@@ -7,30 +7,38 @@ module BinaryCodec
       @sink = sink || BytesList.new
     end
 
+    # Serializes a value into the sink.
+    # @param value [SerializedType] The value to write.
     def write(value)
       value.to_byte_sink(@sink)
     end
 
+    # Adds raw bytes to the sink.
+    # @param bytes [Array<Integer>] The bytes to add.
     def put(bytes)
       @sink.put(bytes)
     end
 
+    # Serializes a value of a given type.
+    # @param type [Class] The class of the type (subclass of SerializedType).
+    # @param value [Object] The value to serialize.
     def write_type(type, value)
       write(type.from(value))
     end
 
+    # Writes a BytesList into the sink.
+    # @param bytes_list [BytesList] The bytes list to write.
     def write_bytes_list(bytes_list)
       bytes_list.to_byte_sink(@sink)
     end
 
+    # Writes a field and its value into the sink.
+    # @param field [FieldInstance] The field to write.
+    # @param value [Object] The value of the field.
+    # @param is_unl_modify_workaround [Boolean] Whether to apply the UNLModify workaround.
     def write_field_and_value(field, value, is_unl_modify_workaround = false)
-      field_header = FieldHeader.new(type: field.header.type, nth: field.nth)
-      type_class = SerializedType.get_type_by_name(field.type)
-      associated_value = type_class.from(value)
-
-      if !associated_value.respond_to?(:to_byte_sink) || field.name.nil?
-        raise 'Error'
-      end
+      field_header = field.header
+      associated_value = field.associated_type.from(value)
 
       @sink.put(field_header.to_bytes)
 
@@ -41,6 +49,9 @@ module BinaryCodec
       end
     end
 
+    # Writes a value with its length encoded prefix.
+    # @param value [SerializedType] The value to write.
+    # @param is_unl_modify_workaround [Boolean] Whether to apply the UNLModify workaround.
     def write_length_encoded(value, is_unl_modify_workaround = false)
       bytes = BytesList.new
 

data/lib/binary-codec/serdes/bytes_list.rb

@@ -9,24 +9,35 @@ module BinaryCodec
       @bytes_array = []
     end
 
+    # Returns the total length of all bytes in the list.
+    # @return [Integer] The total length.
     def get_length
       @bytes_array.inject(0) { |sum, arr| sum + arr.length }
     end
 
+    # Adds bytes to the list.
+    # @param bytes_arg [Array<Integer>] The bytes to add.
+    # @return [BytesList] self for chaining.
     def put(bytes_arg)
       bytes = bytes_arg.dup
       @bytes_array << bytes
       self # Allow chaining
     end
 
+    # Puts the bytes into another byte sink.
+    # @param list [Object] The sink to put bytes into.
     def to_byte_sink(list)
       list.put(to_bytes)
     end
 
+    # Returns all bytes as a single flat array.
+    # @return [Array<Integer>] The flattened byte array.
     def to_bytes
       @bytes_array.flatten # TODO: Uses concat in xrpl.js, maybe implement that instead
     end
 
+    # Returns the hex representation of all bytes in the list.
+    # @return [String] The hex string.
     def to_hex
       bytes_to_hex(to_bytes)
     end

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

@@ -1,38 +1,24 @@
-require 'address-codec/address_codec'
-require 'address-codec/xrp_codec'
+# frozen_string_literal: true
 
 module BinaryCodec
     class AccountId < Hash160
-
-        # Create a single instance of AddressCodec for use in static functions
-        @address_codec = AddressCodec::AddressCodec.new
-
-        attr_reader :bytes
-
         @width = 20
 
         def initialize(bytes = nil)
-            super(bytes || Array.new(20, 0))
+            super(bytes)
         end
 
-        #def self.address_codec
-        #    @address_codec ||= AddressCodec::AddressCodec.new
-        #end
-
-        # Defines how to construct an AccountID
-        #
-        # @param value [AccountID, String] Either an existing AccountID, a hex string, or a base58 r-Address
-        # @return [AccountID] An AccountID object
+        # Creates a new AccountId instance from a value.
+        # @param value [AccountId, String] The value to convert (hex or base58 address).
+        # @return [AccountId] The created instance.
         def self.from(value)
-            if value.is_a?(AccountId)
-                return value
-            end
+            return value if value.is_a?(AccountId)
 
             if value.is_a?(String)
-                return AccountId.new if value.empty?
+                return new if value.empty?
 
                 if valid_hex?(value)
-                    return AccountId.new(hex_to_bytes(value))
+                    return new(hex_to_bytes(value))
                 else
                     return from_base58(value)
                 end
@@ -41,13 +27,13 @@ module BinaryCodec
             raise 'Cannot construct AccountID from the value provided'
         end
 
-        # Defines how to build an AccountID from a base58 r-Address
-        #
-        # @param value [String] A base58 r-Address
-        # @return [AccountID] An AccountID object
+        # Creates an AccountId instance from a base58 address.
+        # @param value [String] The classic or X-address.
+        # @return [AccountId] The created instance.
         def self.from_base58(value)
-            if @address_codec.valid_x_address?(value)
-                classic = @address_codec.x_address_to_classic_address(value)
+            address_codec = AddressCodec::AddressCodec.new
+            if address_codec.valid_x_address?(value)
+                classic = address_codec.x_address_to_classic_address(value)
 
                 if classic[:tag] != false
                     raise 'Only allowed to have tag on Account or Destination'
@@ -56,24 +42,19 @@ module BinaryCodec
                 value = classic[:classic_address]
             end
 
-            AccountId.new(@address_codec.decode_account_id(value))
+            new(address_codec.decode_account_id(value))
         end
 
-        # Overload of to_json
-        #
-        # @return [String] The base58 string for this AccountID
-        def to_json
+        def to_json(_definitions = nil, _field_name = nil)
             to_base58
         end
 
-        # Defines how to encode AccountID into a base58 address
-        #
-        # @return [String] The base58 string defined by this.bytes
+        # Returns the base58 representation of the account ID.
+        # @return [String] The base58 address.
         def to_base58
             address_codec = AddressCodec::AddressCodec.new
             address_codec.encode_account_id(@bytes)
         end
-
     end
 
 end

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

@@ -3,8 +3,6 @@
 require 'bigdecimal'
 require 'bigdecimal/util'
 
-require_relative '../utilities'
-
 module BinaryCodec
   class Amount < SerializedType
 
@@ -31,6 +29,9 @@ 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)
 
@@ -93,8 +94,12 @@ module BinaryCodec
     # 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 +112,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 +131,52 @@ 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}")
+        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'),
+          "value" => value.to_s('F').sub(/\.0$/, ''),
           "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'
@@ -247,7 +261,7 @@ 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
@@ -262,6 +276,8 @@ module BinaryCodec
     # 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 +285,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 +294,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?