xrpl-ruby 0.0.3 → 0.5.0

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+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)
+      @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
+
+    # Check if this is needed
+    def self.from_json(json)
+      raise NotImplementedError, 'from_parser not implemented'
+    end
+
+    # Check if this is needed
+    def self.from_hex(hex)
+      self.from_bytes(hex_to_bytes(hex))
+    end
+
+    # Check if this is needed
+    def self.from_bytes(bytes)
+      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
+
+    # Serialize the given value into bytes
+    # This method must be implemented in the subclasses
+    # @return [Array<Integer>] - Byte array representing the serialized data
+    def to_bytes
+      @bytes
+    end
+
+    # Convert to a hex string
+    # @return [String] - Hexadecimal representation of the serialized data
+    def to_hex
+      bytes_to_hex(to_bytes)
+    end
+
+    # Deserialize instance data and convert it to JSON string
+    #
+    # @param _definitions [Hash] - Definitions for serialization
+    # @param _field_name [String] - Field name for serialization
+    # @return [String] - JSON representation of the serialized data
+    def to_json(_definitions = nil, _field_name = nil)
+      to_hex
+    end
+
+    # 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)
+      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
+    end
+
+  end
+
+  class ComparableSerializedType < SerializedType
+
+    # Compare if `self` is less than `other`
+    def lt(other)
+      compare_to(other) < 0
+    end
+
+    # Compare if `self` is equal to `other`
+    def eq(other)
+      compare_to(other) == 0
+    end
+
+    # Compare if `self` is greater than `other`
+    def gt(other)
+      compare_to(other) > 0
+    end
+
+    # Compare if `self` is greater than or equal to `other`
+    def gte(other)
+      compare_to(other) >= 0
+    end
+
+    # Compare if `self` is less than or equal to `other`
+    def lte(other)
+      compare_to(other) <= 0
+    end
+
+    # Overload this method in subclasses to define comparison logic
+    #
+    # @param other [Object] - The object to compare `self` to
+    # @return [Integer] - Returns -1, 0, or 1 depending on the comparison
+    def compare_to(other)
+      raise NotImplementedError, "Cannot compare #{self} and #{other}"
+    end
+  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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class STObject < SerializedType
+
+    OBJECT_END_MARKER_BYTE = [225]
+    OBJECT_END_MARKER = 'ObjectEndMarker'.freeze
+    ST_OBJECT = 'STObject'.freeze
+    DESTINATION = 'Destination'.freeze
+    ACCOUNT = 'Account'.freeze
+    SOURCE_TAG = 'SourceTag'.freeze
+    DEST_TAG = 'DestinationTag'.freeze
+
+    # attr_reader :type, :bytes
+    #
+    def initialize(byte_buf = nil)
+      @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
+    # @param size_hint [Integer] Optional size hint for the object
+    # @return [STObject] A STObject object
+    def self.from_parser(parser, size_hint = nil)
+      list = BytesList.new
+      bytes = BinarySerializer.new(list)
+
+      until parser.end?
+        field = parser.read_field
+
+        break if field.name == OBJECT_END_MARKER
+
+        associated_value = parser.read_field_value(field)
+
+        bytes.write_field_and_value(field, associated_value)
+        bytes.put(OBJECT_END_MARKER_BYTE) if field.type == ST_OBJECT
+      end
+
+      STObject.new(list.to_bytes)
+    end
+
+    # Method to get the JSON interpretation of self.bytes
+    #
+    # @return [String] A stringified JSON object
+    def to_json(_definitions = nil, _field_name = nil)
+      parser = BinaryParser.new(to_hex)
+      accumulator = {}
+
+      until parser.end?
+        field = parser.read_field
+        break if field.name == OBJECT_END_MARKER # Break if the object end marker is reached
+        value = parser.read_field_value(field).to_json
+        value = JSON.parse(value) if field.type == ST_OBJECT || field.type == Amount
+        accumulator[field.name] = value
+      end
+
+      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

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+
+  class Uint < ComparableSerializedType
+    # Returns the width of the Uint type in bytes.
+    # @return [Integer] The width.
+    def self.width
+      @width
+    end
+
+    def initialize(byte_buf = nil)
+      super(byte_buf || Array.new(self.class.width, 0))
+    end
+
+    # Creates a new Uint instance from a value.
+    # @param value [Uint, String, Integer] The value to convert.
+    # @return [Uint] The created instance.
+    def self.from(value)
+      return value if value.is_a?(self)
+
+      if value.is_a?(String)
+        # Handle hex strings or numeric strings
+        if valid_hex?(value) && value.length == self.width * 2
+          return new(hex_to_bytes(value))
+        end
+        return new(int_to_bytes(value.to_i, width))
+      end
+
+      if value.is_a?(Integer)
+        return new(int_to_bytes(value, width))
+      end
+
+      raise StandardError, "Cannot construct #{self} from the value given"
+    end
+
+    # Creates a Uint instance from a parser.
+    # @param parser [BinaryParser] The parser to read from.
+    # @param _hint [Integer, nil] Unused hint.
+    # @return [Uint] The created instance.
+    def self.from_parser(parser, _hint = nil)
+      new(parser.read(width))
+    end
+
+    # Returns the numeric value of the Uint.
+    # @return [Integer] The numeric value.
+    def value_of
+      @bytes.reduce(0) { |acc, byte| (acc << 8) + byte }
+    end
+
+    # Compares this Uint to another Uint.
+    # @param other [Uint] The other Uint to compare to.
+    # @return [Integer] Comparison result (-1, 0, or 1).
+    def compare_to(other)
+      value_of <=> other.value_of
+    end
+  end
+
+  class Uint8 < Uint
+    # Uint8 is a 1-byte unsigned integer
+    @width = 1
+  end
+
+  class Uint16 < Uint
+    # Uint16 is a 2-byte unsigned integer
+    @width = 2
+  end
+
+  class Uint32 < Uint
+    # Uint32 is a 4-byte unsigned integer
+    @width = 4
+  end
+
+  class Uint64 < Uint
+    # Uint64 is an 8-byte unsigned integer
+    @width = 8
+  end
+
+  class Uint96 < Uint
+    # Uint96 is a 12-byte unsigned integer
+    @width = 12
+  end
+
+  class Uint128 < Uint
+    # Uint128 is a 16-byte unsigned integer
+    @width = 16
+  end
+
+  class Uint160 < Uint
+    # Uint160 is a 20-byte unsigned integer
+    @width = 20
+  end
+
+  class Uint192 < Uint
+    # Uint192 is a 24-byte unsigned integer
+    @width = 24
+  end
+
+  class Uint256 < Uint
+    # Uint256 is a 32-byte unsigned integer
+    @width = 32
+  end
+
+  class Uint384 < Uint
+    # Uint384 is a 48-byte unsigned integer
+    @width = 48
+  end
+
+  class Uint512 < Uint
+    # Uint512 is a 64-byte unsigned integer
+    @width = 64
+  end
+
+  class Int32 < Uint
+    @width = 4
+    # Returns the numeric value of the Int32.
+    # @return [Integer] The signed 32-bit value.
+    def value_of
+      val = super
+      val > 0x7FFFFFFF ? val - 0x100000000 : val
+    end
+
+    # Creates a new Int32 instance from a value.
+    # @param value [Int32, Integer] The value to convert.
+    # @return [Int32] The created instance.
+    def self.from(value)
+      return value if value.is_a?(self)
+      if value.is_a?(Integer)
+        # Ensure it fits in 32-bit signed
+        if value < -2147483648 || value > 2147483647
+          raise StandardError, "Value #{value} out of range for Int32"
+        end
+        # Convert to unsigned 32-bit for storage
+        u_val = value < 0 ? value + 0x100000000 : value
+        return new(int_to_bytes(u_val, 4))
+      end
+      super(value)
+    end
+  end
+
+  class Int64 < Uint
+    @width = 8
+    # Returns the numeric value of the Int64.
+    # @return [Integer] The signed 64-bit value.
+    def value_of
+      val = super
+      val > 0x7FFFFFFFFFFFFFFF ? val - 0x10000000000000000 : val
+    end
+
+    # Creates a new Int64 instance from a value.
+    # @param value [Int64, Integer] The value to convert.
+    # @return [Int64] The created instance.
+    def self.from(value)
+      return value if value.is_a?(self)
+      if value.is_a?(Integer)
+        if value < -9223372036854775808 || value > 9223372036854775807
+          raise StandardError, "Value #{value} out of range for Int64"
+        end
+        u_val = value < 0 ? value + 0x10000000000000000 : value
+        return new(int_to_bytes(u_val, 8))
+      end
+      super(value)
+    end
+  end
+
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class Vector256 < SerializedType
+    def initialize(bytes = nil)
+      super(bytes || [])
+    end
+
+    # Creates a new Vector256 instance from a value.
+    # @param value [Vector256, String, Array<String>] The value to convert.
+    # @return [Vector256] The created instance.
+    def self.from(value)
+      return value if value.is_a?(Vector256)
+
+      if value.is_a?(String)
+        return Vector256.new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Array)
+        bytes = []
+        value.each do |item|
+          hash = Hash256.from(item)
+          bytes.concat(hash.to_bytes)
+        end
+        return Vector256.new(bytes)
+      end
+
+      raise StandardError, "Cannot construct Vector256 from #{value.class}"
+    end
+
+    # Creates a Vector256 instance from a parser.
+    # @param parser [BinaryParser] The parser to read from.
+    # @param size_hint [Integer] The expected total size in bytes.
+    # @return [Vector256] The created instance.
+    def self.from_parser(parser, size_hint = nil)
+      bytes = []
+      num_hashes = size_hint / 32
+      num_hashes.times do
+        bytes.concat(parser.read(32))
+      end
+      Vector256.new(bytes)
+    end
+
+    def to_json(_definitions = nil, _field_name = nil)
+      parser = BinaryParser.new(to_hex)
+      result = []
+      until parser.end?
+        result << bytes_to_hex(parser.read(32))
+      end
+      result
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class XChainBridge < SerializedType
+    def initialize(bytes = nil)
+      super(bytes || [])
+    end
+
+    def self.from(value)
+      return value if value.is_a?(XChainBridge)
+
+      if value.is_a?(String)
+        return XChainBridge.new(hex_to_bytes(value))
+      end
+
+      if value.is_a?(Hash)
+        bytes = []
+        bytes.concat(AccountId.from(value['LockingChainDoor']).to_bytes)
+        bytes.concat(Issue.from(value['LockingChainIssue']).to_bytes)
+        bytes.concat(AccountId.from(value['IssuingChainDoor']).to_bytes)
+        bytes.concat(Issue.from(value['IssuingChainIssue']).to_bytes)
+        return XChainBridge.new(bytes)
+      end
+
+      raise StandardError, "Cannot construct XChainBridge from #{value.class}"
+    end
+
+    def self.from_parser(parser, _hint = nil)
+      bytes = []
+      bytes.concat(parser.read(20)) # LockingChainDoor
+      bytes.concat(Issue.from_parser(parser).to_bytes) # LockingChainIssue
+      bytes.concat(parser.read(20)) # IssuingChainDoor
+      bytes.concat(Issue.from_parser(parser).to_bytes) # IssuingChainIssue
+      XChainBridge.new(bytes)
+    end
+
+    def to_json(_definitions = nil, _field_name = nil)
+      parser = BinaryParser.new(to_hex)
+      result = {}
+      result['LockingChainDoor'] = AccountId.from_parser(parser).to_json
+      result['LockingChainIssue'] = Issue.from_parser(parser).to_json
+      result['IssuingChainDoor'] = AccountId.from_parser(parser).to_json
+      result['IssuingChainIssue'] = Issue.from_parser(parser).to_json
+      result
+    end
+  end
+end