xrpl-ruby 0.0.1 → 0.2.4

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+
+  class Uint < ComparableSerializedType
+    class << self
+      attr_reader :width
+    end
+
+    def initialize(byte_buf = nil)
+      @bytes = byte_buf || Array.new(self.class.width, 0)
+    end
+
+    def self.from(value)
+      return value if value.is_a?(self)
+
+      if value.is_a?(String)
+        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
+
+    def value_of
+      @bytes.reduce(0) { |acc, byte| (acc << 8) + byte }
+    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
+
+end

data/lib/binary-codec/utilities.rb

@@ -0,0 +1,80 @@
+module BinaryCodec
+
+  # Write an 8-bit unsigned integer
+  def self.write_uint8(array, value, offset = 0)
+    array[offset] = value & 0xFF
+  end
+
+  # Read an unsigned 16-bit integer in big-endian format
+  def self.read_uint16be(array, offset = 0)
+    (array[offset] << 8) + array[offset + 1]
+  end
+
+  # Write a 16-bit unsigned integer in big-endian format
+  def self.write_uint16be(array, value, offset = 0)
+    array[offset] = (value >> 8) & 0xFF
+    array[offset + 1] = value & 0xFF
+  end
+
+  # Read an unsigned 32-bit integer in big-endian format
+  def self.read_uint32be(array, offset = 0)
+    (array[offset] << 24) + (array[offset + 1] << 16) +
+      (array[offset + 2] << 8) + array[offset + 3]
+  end
+
+  # Write an unsigned 32-bit integer to a buffer in big-endian format
+  def self.write_uint32be(buffer, value, offset = 0)
+    buffer[offset] = (value >> 24) & 0xFF
+    buffer[offset + 1] = (value >> 16) & 0xFF
+    buffer[offset + 2] = (value >> 8) & 0xFF
+    buffer[offset + 3] = value & 0xFF
+  end
+
+  # Compare two byte arrays
+  def self.equal(array1, array2)
+    return false unless array1.length == array2.length
+    array1 == array2
+  end
+
+  # Compare two arrays of any type
+  def self.compare(array1, array2)
+    raise 'Cannot compare arrays of different length' if array1.length != array2.length
+
+    array1.each_with_index do |value, i|
+      return 1 if value > array2[i]
+      return -1 if value < array2[i]
+    end
+
+    0
+  end
+
+  # Compares two 8-bit aligned arrays
+  def self.compare8(array1, array2)
+    compare(array1, array2)
+  end
+
+  # Compares two 16-bit aligned arrays
+  def self.compare16(array1, array2)
+    raise 'Array lengths must be even for 16-bit alignment' unless (array1.length % 2).zero? && (array2.length % 2).zero?
+
+    array1.pack('C*').unpack('n*') <=> array2.pack('C*').unpack('n*')
+  end
+
+  # Compares two 32-bit aligned arrays
+  def self.compare32(array1, array2)
+    raise 'Array lengths must be divisible by 4 for 32-bit alignment' unless (array1.length % 4).zero? && (array2.length % 4).zero?
+
+    array1.pack('C*').unpack('N*') <=> array2.pack('C*').unpack('N*')
+  end
+
+  # Determine if an array is 16-bit aligned
+  def self.aligned16?(array)
+    (array.length % 2).zero?
+  end
+
+  # Determine if an array is 32-bit aligned
+  def self.aligned32?(array)
+    (array.length % 4).zero?
+  end
+
+end

data/lib/core/base_58_xrp.rb

@@ -0,0 +1,12 @@
+module Core
+
+  class Base58XRP < BaseX
+
+    XRP_ALPHABET = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"
+
+    def initialize
+      super(XRP_ALPHABET)
+    end
+  end
+
+end

data/lib/core/base_x.rb

@@ -1,4 +1,5 @@
 module Core
+
   class BaseX
     def initialize(alphabet)
       @alphabet = alphabet

data/lib/core/core.rb

@@ -1,2 +1,72 @@
 # @!attribute
-require_relative 'base_x'
+require_relative 'base_x'
+require_relative 'base_58_xrp'
+require 'securerandom'
+
+def random_bytes(size)
+  SecureRandom.random_bytes(size).bytes
+end
+
+def bytes_to_hex(bytes)
+  bytes.pack('C*').unpack1('H*').upcase
+end
+def hex_to_bytes(hex)
+  raise ArgumentError, 'Invalid hex string' unless valid_hex?(hex)
+  [hex].pack('H*').bytes
+end
+
+def bin_to_hex(bin)
+  bin.unpack("H*").first.upcase
+end
+
+def hex_to_bin(hex)
+  raise ArgumentError, 'Invalid hex string' unless valid_hex?(hex)
+  [hex].pack("H*")
+end
+
+def hex_to_string(hex, encoding = 'utf-8')
+  raise ArgumentError, 'Invalid hex string' unless valid_hex?(hex)
+  hex_to_bin(hex).force_encoding(encoding).encode('utf-8')
+end
+
+def string_to_hex(string)
+  string.unpack1('H*').upcase
+end
+
+def valid_hex?(str)
+  str =~ /\A[0-9a-fA-F]*\z/ && str.length.even?
+end
+
+def check_byte_length(bytes, expected_length)
+  if bytes.respond_to?(:byte_length)
+    bytes.byte_length == expected_length
+  else
+    bytes.length == expected_length
+  end
+end
+
+def concat_args(*args)
+  args.flat_map do |arg|
+    is_scalar?(arg) ? [arg] : arg.to_a
+  end
+end
+
+def is_scalar?(val)
+  val.is_a?(Numeric)
+end
+
+def int_to_bytes(number, width = 1, byteorder = :big)
+  bytes = []
+  while number > 0
+    bytes << (number & 0xFF) # Extract the lowest 8 bits (1 byte)
+    number >>= 8             # Shift the number 8 bits to the right
+  end
+
+  # Ensure the result has at least `width` bytes (pad with zeroes if necessary)
+  while bytes.size < width
+    bytes << 0
+  end
+
+  bytes.reverse! if byteorder == :big
+  bytes
+end

data/lib/xrpl-ruby.rb

@@ -1,3 +1,14 @@
 # frozen_string_literal: true
 
-require_relative 'core/core'
+require_relative 'core/core'
+
+require_relative 'address-codec/codec'
+require_relative 'address-codec/xrp_codec'
+require_relative 'address-codec/address_codec'
+
+require_relative 'binary-codec/enums/fields'
+require_relative 'binary-codec/enums/definitions'
+require_relative 'binary-codec/serdes/binary_parser'
+require_relative 'binary-codec/serdes/bytes_list'
+require_relative 'binary-codec/types/serialized_type'
+require_relative 'binary-codec/types/hash'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xrpl-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.4
 platform: ruby
 authors:
 - Alexander Busse
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-05 00:00:00.000000000 Z
+date: 2025-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,6 +61,27 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/address-codec/address_codec.rb
+- lib/address-codec/codec.rb
+- lib/address-codec/xrp_codec.rb
+- lib/binary-codec/binary_codec.rb
+- lib/binary-codec/enums/constants.rb
+- lib/binary-codec/enums/definitions.json
+- lib/binary-codec/enums/definitions.rb
+- lib/binary-codec/enums/fields.rb
+- lib/binary-codec/serdes/binary_parser.rb
+- lib/binary-codec/serdes/binary_serializer.rb
+- lib/binary-codec/serdes/bytes_list.rb
+- lib/binary-codec/types/account_id.rb
+- lib/binary-codec/types/amount.rb
+- lib/binary-codec/types/blob.rb
+- lib/binary-codec/types/currency.rb
+- lib/binary-codec/types/hash.rb
+- lib/binary-codec/types/serialized_type.rb
+- lib/binary-codec/types/st_object.rb
+- lib/binary-codec/types/uint.rb
+- lib/binary-codec/utilities.rb
+- lib/core/base_58_xrp.rb
 - lib/core/base_x.rb
 - lib/core/core.rb
 - lib/xrpl-ruby.rb
@@ -83,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: A Ruby library to interact with the XRP Ledger (XRPL) blockchain