xrpl-ruby 0.0.3 → 0.5.0

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require 'json'
+require 'digest'
+
+module BinaryCodec
+
+  class Definitions
+
+    @@instance = nil
+
+     def initialize
+      file_path = File.join(__dir__, 'definitions.json') #
+      contents = File.read(file_path)
+      @definitions = JSON.parse(contents)
+
+      @type_ordinals = @definitions['TYPES']
+      @ledger_entry_types = @definitions['LEDGER_ENTRY_TYPES']
+      @transaction_results = @definitions['TRANSACTION_RESULTS']
+      @transaction_types = @definitions['TRANSACTION_TYPES']
+
+      @field_info_map = {}
+      @field_id_name_map = {}
+      @field_header_map = {}
+
+      @definitions['FIELDS'].each do |field|
+        field_name = field[0]
+        field_info = FieldInfo.new(
+          nth: field[1]['nth'],
+          is_vl_encoded: field[1]['isVLEncoded'],
+          is_serialized: field[1]['isSerialized'],
+          is_signing_field: field[1]['isSigningField'],
+          type: field[1]['type']
+        )
+        field_header = FieldHeader.new(type: @type_ordinals[field_info.type], nth: field_info.nth)
+
+        @field_info_map[field_name] = field_info
+        @field_id_name_map[Digest::MD5.hexdigest(Marshal.dump(field_header))] = field_name
+        @field_header_map[field_name] = field_header
+      end
+
+    rescue Errno::ENOENT
+      raise "Error: The file '#{file_path}' was not found. Please ensure the file exists."
+    rescue JSON::ParserError => e
+      raise "Error: The file '#{file_path}' contains invalid JSON: #{e.message}"
+
+     end
+
+    # Returns the singleton instance of the Definitions class.
+    # @return [Definitions] The singleton instance.
+    def self.instance
+      @@instance ||= new
+    end
+
+    # 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
+
+    # 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
+
+    # 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)
+
+       FieldInstance.new(
+         nth: field_info.nth,
+         is_variable_length_encoded: field_info.is_vl_encoded,
+         is_serialized: field_info.is_serialized,
+         is_signing_field: field_info.is_signing_field,
+         type: field_info.type,
+         ordinal: (@type_ordinals[field_info.type] << 16) | field_info.nth,
+         name: field_name,
+         header: field_header,
+         associated_type: SerializedType.get_type_by_name(field_info.type)
+       )
+     end
+
+  end
+
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+
+  class FieldHeader
+
+    attr_reader :type, :nth
+
+    def initialize(type:, nth:)
+      @type = type
+      @nth = nth
+    end
+
+    # Converts the field header to a byte array.
+    # @return [Array<Integer>] The byte array.
+    def to_bytes
+      header = []
+      if type < 16
+        if nth < 16
+          header.push((type << 4) | nth)
+        else
+          header.push(type << 4, nth)
+        end
+      elsif nth < 16
+        header.push(nth,type)
+      else
+        header.push(0, type, nth)
+      end
+
+      header
+    end
+
+  end
+  class FieldInfo
+
+    attr_reader :nth, :is_vl_encoded, :is_serialized, :is_signing_field, :type
+
+    def initialize(nth:, is_vl_encoded:, is_serialized:, is_signing_field:, type:)
+      @nth = nth
+      @is_vl_encoded = is_vl_encoded
+      @is_serialized = is_serialized
+      @is_signing_field = is_signing_field
+      @type = type
+    end
+
+  end
+
+  class FieldInstance
+
+    attr_reader :nth, :is_variable_length_encoded, :is_serialized, :is_signing_field, :type, :ordinal, :name, :header, :associated_type
+
+    def initialize(nth:, is_variable_length_encoded:, is_serialized:, is_signing_field:, type:, ordinal:, name:, header:, associated_type:)
+      @nth = nth
+      @is_variable_length_encoded = is_variable_length_encoded
+      @is_serialized = is_serialized
+      @is_signing_field = is_signing_field
+      @type = type
+      @ordinal = ordinal
+      @name = name
+      @header = header
+      @associated_type = associated_type
+    end
+
+  end
+
+  # TODO: See if this makes sense or if Ruby hashes are just fine
+  class FieldLookup
+    def initialize(fields:, types:)
+      @fields_hash = {}
+
+      fields.each do |name, field_info|
+        type_ordinal = types[field_info.type]
+        field = build_field([name, field_info], type_ordinal) # Store the built field
+        @fields_hash[name] = field                           # Map field by name
+        @fields_hash[field.ordinal.to_s] = field             # Map field by ordinal
+      end
+    end
+
+    # Method to retrieve a FieldInstance by its string key
+    def from_string(value)
+      @fields_hash[value]
+    end
+
+    private
+
+    # Dummy build_field method (must be implemented elsewhere)
+    def build_field(field, type_ordinal)
+      field_header = FieldHeader.new(type: field[1].type, nth: field[1].nth)
+      FieldInstance.new(
+        nth: field[1].nth,
+        is_variable_length_encoded: field[1].is_vl_encoded,
+        is_serialized: field[1].is_serialized,
+        is_signing_field: field[1].is_signing_field,
+        type: field[1].type,
+        ordinal: type_ordinal,
+        name: field[0],
+        header: field_header,
+        associated_type: SerializedType
+        #associated_type: SerializedType.get_type_by_name(field[1].type)
+      )
+    end
+  end
+
+end

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+
+  class BinaryParser
+
+    attr_reader :definitions
+
+    def initialize(hex_bytes = '')
+      @bytes = hex_to_bytes(hex_bytes)
+      @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
+      end
+      @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
+      end
+      @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')
+      end
+
+      slice = @bytes[0, n]
+      skip(n)
+      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')
+      end
+      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
+        b1
+      elsif b1 <= 240
+        b2 = read_uint8
+        193 + (b1 - 193) * 256 + b2
+      elsif b1 <= 254
+        b2 = read_uint8
+        b3 = read_uint8
+        12481 + (b1 - 241) * 65536 + b2 * 256 + b3
+      else
+        raise StandardError.new('Invalid variable length indicator')
+      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
+
+      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
+    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)
+
+      @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)
+
+      if type.nil?
+        raise StandardError.new("unsupported: (#{field.name}, #{field.type.name})")
+      end
+
+      size_hint = field.is_variable_length_encoded ? read_variable_length_length : nil
+      value = type.from_parser(self, size_hint)
+
+      if value.nil?
+        raise StandardError.new("from_parser for (#{field.name}, #{field.type.name}) -> nil")
+      end
+
+      value
+    end
+
+    # get_size
+    # read_field_and_value
+
+  end
+
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class BinarySerializer
+
+    def initialize(sink)
+      @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 = 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)
+      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
+
+      unless is_unl_modify_workaround
+        # This part doesn't happen for the Account field in a UNLModify transaction
+        value.to_byte_sink(bytes)
+      end
+
+      self.put(encode_variable_length(bytes.get_length))
+      write_bytes_list(bytes)
+    end
+
+    private
+
+    def encode_variable_length(length)
+      len_bytes = [0, 0, 0] # Create an array to hold 3 bytes (default 0)
+
+      if length <= 192
+        len_bytes[0] = length
+        return len_bytes[0, 1] # Equivalent to slice(0, 1)
+      elsif length <= 12480
+        length -= 193
+        len_bytes[0] = 193 + (length >> 8) # Equivalent to length >>> 8 in TypeScript
+        len_bytes[1] = length & 0xff
+        return len_bytes[0, 2] # Equivalent to slice(0, 2)
+      elsif length <= 918744
+        length -= 12481
+        len_bytes[0] = 241 + (length >> 16)
+        len_bytes[1] = (length >> 8) & 0xff
+        len_bytes[2] = length & 0xff
+        return len_bytes[0, 3] # Equivalent to slice(0, 3)
+      end
+
+      raise 'Overflow error'
+    end
+
+  end
+
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class BytesList
+
+    attr_reader :bytes_array
+
+    def initialize
+      @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
+
+  end
+
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+    class AccountId < Hash160
+        @width = 20
+
+        def initialize(bytes = nil)
+            super(bytes)
+        end
+
+        # 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)
+            return value if value.is_a?(AccountId)
+
+            if value.is_a?(String)
+                return new if value.empty?
+
+                if valid_hex?(value)
+                    return new(hex_to_bytes(value))
+                else
+                    return from_base58(value)
+                end
+            end
+
+            raise 'Cannot construct AccountID from the value provided'
+        end
+
+        # 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)
+            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'
+                end
+
+                value = classic[:classic_address]
+            end
+
+            new(address_codec.decode_account_id(value))
+        end
+
+        def to_json(_definitions = nil, _field_name = nil)
+            to_base58
+        end
+
+        # 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