xrpl-ruby 0.0.1 → 0.2.4

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'json'
+
+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
+
+    def self.instance
+      @@instance ||= new
+    end
+
+     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
+
+     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: (field_header.type << 16) | field_info.nth, # @type_ordinals[field_info.type],
+         name: field_name,
+         header: field_header,
+         associated_type: field_info.type # SerializedType::getTypeByName($this->type)::class;
+       )
+     end
+
+  end
+
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+
+  class FieldHeader
+
+    attr_reader :type, :nth
+
+    def initialize(type:, nth:)
+      @type = type
+      @nth = nth
+    end
+
+    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,145 @@
+# 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
+
+    def peek
+      if @bytes.empty?
+        raise StandardError.new
+      end
+      @bytes[0]
+    end
+
+    def skip(n)
+      if n > @bytes.length
+        raise StandardError.new
+      end
+      @bytes = @bytes[n..-1]
+    end
+
+    def read(n)
+      if n > @bytes.length
+        raise StandardError.new('End of byte stream reached')
+      end
+
+      slice = @bytes[0, n]
+      skip(n)
+      slice
+    end
+
+    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
+
+    def read_uint8
+      read_uint_n(1)
+    end
+
+    def read_uint16
+      read_uint_n(2)
+    end
+
+    def read_uint32
+      read_uint_n(4)
+    end
+
+    def size
+      @bytes.length
+    end
+
+    def end?(custom_end = nil)
+      length = @bytes.length
+      length == 0 || (!custom_end.nil? && length <= custom_end)
+    end
+
+    def read_variable_length
+      read(read_variable_length_length)
+    end
+
+    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
+
+    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
+
+    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
+
+    def read_type(type)
+      type.from_parser(self)
+    end
+
+    def type_for_field(field)
+      field.associated_type
+    end
+
+    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,82 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class BinarySerializer
+
+    def initialize(sink)
+      @sink = sink || BytesList.new
+    end
+
+    def write(value)
+      value.to_byte_sink(@sink)
+    end
+
+    def put(bytes)
+      @sink.put(bytes)
+    end
+
+    def write_type(type, value)
+      write(type.from(value))
+    end
+
+    def write_bytes_list(bytes_list)
+      bytes_list.to_byte_sink(@sink)
+    end
+
+    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
+
+      @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
+
+    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,36 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class BytesList
+
+    attr_reader :bytes_array
+
+    def initialize
+      @bytes_array = []
+    end
+
+    def get_length
+      @bytes_array.inject(0) { |sum, arr| sum + arr.length }
+    end
+
+    def put(bytes_arg)
+      bytes = bytes_arg.dup
+      @bytes_array << bytes
+      self # Allow chaining
+    end
+
+    def to_byte_sink(list)
+      list.put(to_bytes)
+    end
+
+    def to_bytes
+      @bytes_array.flatten # TODO: Uses concat in xrpl.js, maybe implement that instead
+    end
+
+    def to_hex
+      bytes_to_hex(to_bytes)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,79 @@
+require 'address-codec/address_codec'
+require 'address-codec/xrp_codec'
+
+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))
+        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
+        def self.from(value)
+            if value.is_a?(AccountId)
+                return value
+            end
+
+            if value.is_a?(String)
+                return AccountId.new if value.empty?
+
+                if valid_hex?(value)
+                    return AccountId.new(hex_to_bytes(value))
+                else
+                    return from_base58(value)
+                end
+            end
+
+            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
+        def self.from_base58(value)
+            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
+
+            AccountId.new(@address_codec.decode_account_id(value))
+        end
+
+        # Overload of to_json
+        #
+        # @return [String] The base58 string for this AccountID
+        def to_json
+            to_base58
+        end
+
+        # Defines how to encode AccountID into a base58 address
+        #
+        # @return [String] The base58 string defined by this.bytes
+        def to_base58
+            address_codec = AddressCodec::AddressCodec.new
+            address_codec.encode_account_id(@bytes)
+        end
+
+    end
+
+end