xrpl-ruby 0.2.4 → 0.6.0

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'json'
+require 'digest'
 
 module BinaryCodec
 
@@ -30,10 +31,12 @@ module BinaryCodec
           is_signing_field: field[1]['isSigningField'],
           type: field[1]['type']
         )
-        field_header = FieldHeader.new(type: @type_ordinals[field_info.type], nth: field_info.nth)
+        type_ordinal = @type_ordinals[field_info.type]
+        field_header = FieldHeader.new(type: type_ordinal, nth: field_info.nth)
 
         @field_info_map[field_name] = field_info
-        @field_id_name_map[Digest::MD5.hexdigest(Marshal.dump(field_header))] = field_name
+        key = (type_ordinal << 16) | field_info.nth
+        @field_id_name_map[key] = field_name
         @field_header_map[field_name] = field_header
       end
 
@@ -44,19 +47,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)
-       @field_id_name_map[Digest::MD5.hexdigest(Marshal.dump(field_header))]
-     end
+    # 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[(field_header.type << 16) | field_header.nth]
+    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 +80,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
@@ -20,7 +22,7 @@ module BinaryCodec
           header.push(type << 4, nth)
         end
       elsif nth < 16
-        header.push(nth,type)
+        header.push(nth, type)
       else
         header.push(0, type, nth)
       end

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,43 +108,52 @@ 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
-      type >>= 4
+      first_byte = read_uint8
+      type = first_byte >> 4
+      nth = first_byte & 15
 
       if type == 0
         type = read_uint8
-        if type == 0 || type < 16
-          raise StandardError.new("Cannot read FieldOrdinal, type_code #{type} out of range")
-        end
       end
 
       if nth == 0
         nth = read_uint8
-        if nth == 0 || nth < 16
-          raise StandardError.new("Cannot read FieldOrdinal, field_code #{nth} out of range")
-        end
       end
 
-      FieldHeader.new(type: type, nth: nth) # (type << 16) | nth for read_field_ordinal
+      FieldHeader.new(type: type, nth: nth)
     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)
+      
+      raise "Unknown field for header: type=#{field_header.type}, nth=#{field_header.nth}" if field_name.nil?
 
       @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,40 +7,63 @@ 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'
+      # Special case for Blob fields that are empty (e.g., SigningPubKey = "")
+      # In Ruby, Blob.from("") returns an empty Blob.
+      # If we want to force 0x00 length prefix, we handle it here.
+      if field.type == 'Blob' && (value == "" || (value.is_a?(Array) && value.empty?))
+        @sink.put(field.header.to_bytes)
+        @sink.put([0]) # length 0
+        return
       end
 
+      field_header = field.header
+      associated_value = field.associated_type.from(value)
+
       @sink.put(field_header.to_bytes)
 
       if field.is_variable_length_encoded
         write_length_encoded(associated_value, is_unl_modify_workaround)
       else
         associated_value.to_byte_sink(@sink)
+        if field.type == 'STObject'
+          @sink.put([0xE1]) # ObjectEndMarker
+        end
       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>, Integer] The bytes to add.
+    # @return [BytesList] self for chaining.
     def put(bytes_arg)
-      bytes = bytes_arg.dup
+      bytes = bytes_arg.is_a?(Integer) ? [bytes_arg] : 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