xrpl-ruby 0.2.4 → 0.5.0

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,50 @@
+# 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, _hint = nil)
+      bytes = []
+      bytes.concat(parser.read(20)) # Currency
+      # If there are more bytes in this field, it might have an issuer?
+      # Actually Issue is often fixed length 20 or 40.
+      # For XChainBridge it uses Issue.
+      # Let's see how much we should read. 
+      # Usually if it's an Issue in a field, we might know the size.
+      # For now, let's assume it can be 20 or 40.
+      # But wait, how does the parser know?
+      # If it's not variable length, it must have a fixed width or be the rest of the object.
+      # Definitions.json says Issue is type 24.
+      bytes.concat(parser.read(20)) unless parser.end? # Try reading issuer
+      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
+    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

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

@@ -1,20 +1,27 @@
 # frozen_string_literal: true
 
-require_relative '../../core/core'
-
 module BinaryCodec
   class SerializedType
 
     attr_reader :bytes
 
+    # Initializes a new SerializedType instance.
+    # @param bytes [Array<Integer>, nil] The byte array representing the serialized data.
     def initialize(bytes = nil)
-      raise NotImplementedError, "#{self.class} is an abstract class and cannot be instantiated"
+      @bytes = bytes
     end
 
+    # Creates a new instance of the type from a value.
+    # @param value [Object] The value to convert.
+    # @return [SerializedType] The created instance.
     def self.from(value)
       raise NotImplementedError, 'from not implemented'
     end
 
+    # Creates an instance of the type from a parser.
+    # @param parser [BinaryParser] The parser to read from.
+    # @param size_hint [Integer, nil] Optional size hint.
+    # @return [SerializedType] The created instance.
     def self.from_parser(parser, size_hint = nil)
       raise NotImplementedError, 'from_parser not implemented'
     end
@@ -34,6 +41,8 @@ module BinaryCodec
       new(bytes)
     end
 
+    # Puts the serialized data into a byte sink.
+    # @param sink [Object] The sink to put bytes into.
     def to_byte_sink(sink)
       sink.put(to_bytes)
     end
@@ -60,36 +69,51 @@ module BinaryCodec
       to_hex
     end
 
-    # Represent object as a string (hexadecimal form)
-    def to_s
-      to_hex
+    # Returns the value of the serialized type
+    # @return [Object] - The value of the serialized type
+    def value_of
+      @bytes
     end
 
+    # Returns the class for a given type name.
+    # @param name [String] The name of the type.
+    # @return [Class] The class associated with the type name.
     def self.get_type_by_name(name)
-      type_map = {
-        "AccountID" => AccountId,
-        "Amount" => Amount,
-        "Blob" => Blob,
-        "Currency" => Currency,
-        "Hash128" => Hash128,
-        "Hash160" => Hash160,
-        "Hash256" => Hash256,
-        #"PathSet" => PathSet,
-        #"STArray" => STArray,
-        "STObject" => STObject,
-        "UInt8" => Uint8,
-        "UInt16" => Uint16,
-        "UInt32" => Uint32,
-        "UInt64" => Uint64,
-        #"Vector256" => Vector256
-      }
-
-      unless type_map.key?(name)
+      case name
+      when "AccountID" then AccountId
+      when "Amount" then Amount
+      when "Blob" then Blob
+      when "Currency" then Currency
+      when "Hash128" then Hash128
+      when "Hash160" then Hash160
+      when "Hash192" then Hash192
+      when "Hash256" then Hash256
+      when "STArray" then STArray
+      when "STObject" then STObject
+      when "UInt8" then Uint8
+      when "UInt16" then Uint16
+      when "UInt32" then Uint32
+      when "UInt64" then Uint64
+      when "UInt96" then Uint96
+      when "UInt128" then Uint128
+      when "UInt160" then Uint160
+      when "UInt192" then Uint192
+      when "UInt256" then Uint256
+      when "UInt384" then Uint384
+      when "UInt512" then Uint512
+      when "Int32" then Int32
+      when "Int64" then Int64
+      when "PathSet" then PathSet
+      when "Vector256" then Vector256
+      when "XChainBridge" then XChainBridge
+      when "Issue" then Issue
+      when "Transaction" then Blob
+      when "LedgerEntry" then Blob
+      when "Validation" then Blob
+      when "Metadata" then Blob
+      else
         raise "unsupported type #{name}"
       end
-
-      # Return class
-      type_map[name]
     end
 
   end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class STArray < SerializedType
+    def initialize(byte_buf = nil)
+      super(byte_buf || [])
+    end
+
+    # Creates a new STArray instance from a value.
+    # @param value [STArray, String, Array<Hash>] The value to convert.
+    # @param definitions [Definitions, nil] Optional definitions.
+    # @return [STArray] The created instance.
+    def self.from(value, definitions = nil)
+      return value if value.is_a?(STArray)
+      definitions ||= Definitions.instance
+
+      if value.is_a?(String)
+        return STArray.new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Array)
+        bytes = []
+        value.each do |item|
+          obj = STObject.from(item, nil, definitions)
+          bytes.concat(obj.to_bytes)
+          bytes.concat([0xF1]) # ArrayItemEndMarker
+        end
+        bytes.concat([0xF1]) # ArrayEndMarker
+        return STArray.new(bytes)
+      end
+
+      raise StandardError, "Cannot construct STArray from #{value.class}"
+    end
+
+    # Creates an STArray instance from a parser.
+    # @param parser [BinaryParser] The parser to read from.
+    # @param _hint [Integer, nil] Unused hint.
+    # @return [STArray] The created instance.
+    def self.from_parser(parser, _hint = nil)
+      bytes = []
+      until parser.end?(1) # Look ahead for end marker
+        obj = STObject.from_parser(parser)
+        bytes.concat(obj.to_bytes)
+        bytes.concat(parser.read(1)) # Should be 0xF1 (ArrayItemEndMarker)
+      end
+      parser.read(1) # Consume 0xF1 (ArrayEndMarker)
+      STArray.new(bytes)
+    end
+
+    # Returns the JSON representation of the STArray.
+    # @param _definitions [Definitions, nil] Unused.
+    # @param _field_name [String, nil] Unused.
+    # @return [Array<Hash>] The JSON representation.
+    def to_json(_definitions = nil, _field_name = nil)
+      parser = BinaryParser.new(to_hex)
+      result = []
+      until parser.end?
+        obj = STObject.from_parser(parser)
+        result << JSON.parse(obj.to_json)
+        # In xrpl.js, array items are STObjects. 
+        # After each STObject, there might be an ArrayItemEndMarker if we're not at the end.
+        # But wait, STObject.from_parser already reads until ObjectEndMarker.
+        # STArray in XRPL is a list of objects, each ending with ObjectEndMarker.
+        # The whole array ends with ArrayEndMarker (0xF1).
+        # Actually, standard XRPL STArray: [FieldHeader][STObject][FieldHeader][STObject]...[0xF1]
+        # Wait, I need to check how xrpl.js handles STArray.
+      end
+      result
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module BinaryCodec
-  class STObject  < SerializedType
+  class STObject < SerializedType
 
     OBJECT_END_MARKER_BYTE = [225]
     OBJECT_END_MARKER = 'ObjectEndMarker'.freeze
@@ -15,6 +17,68 @@ module BinaryCodec
       @bytes = byte_buf || Array.new(0)
     end
 
+    # Creates a new STObject instance from a value.
+    # @param value [STObject, String, Array<Integer>, Hash] The value to convert.
+    # @param filter [Proc, nil] Optional filter for fields.
+    # @param definitions [Definitions, nil] Optional definitions.
+    # @return [STObject] The created instance.
+    def self.from(value, filter = nil, definitions = nil)
+      return value if value.is_a?(STObject)
+      definitions ||= Definitions.instance
+
+      if value.is_a?(String)
+        return STObject.new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Array)
+        return STObject.new(value)
+      end
+
+      list = BytesList.new
+      serializer = BinarySerializer.new(list)
+      is_unl_modify = false
+
+      # Handle X-Addresses and check for duplicate tags
+      processed_value = value.each_with_object({}) do |(key, val), acc|
+        if val && val.is_a?(String) && AddressCodec::AddressCodec.new.valid_x_address?(val)
+          handled = handle_x_address(key.to_s, val)
+          check_for_duplicate_tags(handled, value)
+          acc.merge!(handled)
+        else
+          acc[key.to_s] = val
+        end
+      end
+
+      sorted_fields = processed_value.keys.map do |field_name|
+        field = definitions.get_field_instance(field_name)
+        raise "Field #{field_name} is not defined" if field.nil?
+        field
+      end.select(&:is_serialized).sort_by(&:ordinal)
+
+      if filter
+        sorted_fields = sorted_fields.select { |f| filter.call(f.name) }
+      end
+
+      sorted_fields.each do |field|
+        associated_value = processed_value[field.name]
+        next if associated_value.nil?
+
+        # Special handling for UNLModify
+        if field.name == 'UNLModify' # This might need more specific check depending on value
+           is_unl_modify = true
+        end
+        is_unl_modify_workaround = (field.name == 'Account' && is_unl_modify)
+
+        serializer.write_field_and_value(field, associated_value, is_unl_modify_workaround)
+
+        if field.type == 'STObject'
+          serializer.put(OBJECT_END_MARKER_BYTE)
+        end
+      end
+
+      STObject.new(list.to_bytes)
+    end
+
     # Construct a STObject from a BinaryParser
     #
     # @param parser [BinaryParser] BinaryParser to read STObject from
@@ -41,8 +105,8 @@ module BinaryCodec
     # Method to get the JSON interpretation of self.bytes
     #
     # @return [String] A stringified JSON object
-    def to_json()
-      parser = BinaryParser.new(to_s)
+    def to_json(_definitions = nil, _field_name = nil)
+      parser = BinaryParser.new(to_hex)
       accumulator = {}
 
       until parser.end?
@@ -56,5 +120,38 @@ module BinaryCodec
       JSON.generate(accumulator)
     end
 
+    private
+
+    # Break down an X-Address into an account and a tag
+    #
+    # @param field [String] Name of the field
+    # @param x_address [String] X-Address corresponding to the field
+    # @return [Hash] A hash with the classic address and tag (if present)
+    def handle_x_address(field, x_address)
+      address_codec = AddressCodec::AddressCodec.new
+      decoded = address_codec.x_address_to_classic_address(x_address)
+
+      tag_name = if field == 'Destination'
+                   'DestinationTag'
+                 elsif field == 'Account'
+                   'SourceTag'
+                 elsif decoded[:tag]
+                   raise "#{field} cannot have an associated tag"
+                 end
+
+      decoded[:tag] ? { field => decoded[:classic_address], tag_name => decoded[:tag] } : { field => decoded[:classic_address] }
+    end
+
+    def self.check_for_duplicate_tags(obj1, obj2)
+      if obj1['SourceTag'] && obj2['SourceTag']
+        raise 'Cannot have Account X-Address and SourceTag'
+      end
+
+      if obj1['DestinationTag'] && obj2['DestinationTag']
+        raise 'Cannot have Destination X-Address and DestinationTag'
+      end
+    end
+
+
   end
 end