xrpl-ruby 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe5e22e400d255c2c834133232433c9c8a513d3c1fba93dc06f46e18d90b1c3d
-  data.tar.gz: 0512e71a026bef8893fa8855c702ccdb09e18ce219f286c3cea33b2b5d477e38
+  metadata.gz: 601db38742606f9188b1f301ca9e6800308d7650ec4d6c7dd655db9eed6bab27
+  data.tar.gz: 188e2ff1112b079a7aed430882fe0c0599a839946dd9ed5842d6e55df964c5e8
 SHA512:
-  metadata.gz: c7b52d5c38ead6d5d5910cbd5132be7ea783e24b8c21f452d56138c9e806d016d9186d3213913372b3d5cb8d1c0bdca9c6acf8f7c9de1c5416571bf9d0873b2e
-  data.tar.gz: '00914805ec76c9fe7a2b475881efde3408f6f609f3ffaedc30d21fe845d3dd247051158561c29fe69af688238d4c86fb5a4124747c806bfe6a64f4c31a244020'
+  metadata.gz: 4e819838c6ada42db05efebc7fec715ce22dd890911c7a40242a2945bacde3b832f9fbf4139cee2ffbc384a662a0cbda36336cf8e659eebf69820deae25797f0
+  data.tar.gz: 46f08dc1d555d518ce8b98760881e94f29871b1a32c49b6d1003a1197a0e7bd354ec09d415e2ccf4f85f343add4ccb742fdd3587dfabd0f764ed4f397cb47a9a

data/lib/address-codec/address_codec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+module AddressCodec
+
+  class AddressCodec < XrpCodec
+
+    PREFIX_BYTES = {
+      main: [0x05, 0x44],
+      test: [0x04, 0x93]
+    }
+
+    MAX_32_BIT_UNSIGNED_INT = 4294967295
+
+    def classic_address_to_x_address(classic_address, tag, test)
+      account_id = decode_account_id(classic_address)
+      encode_x_address(account_id, tag, test)
+    end
+
+    def encode_x_address(account_id, tag, test)
+      if account_id.length != 20
+        # RIPEMD160 -> 160 Bits = 20 Bytes
+        raise 'Account ID must be 20 bytes'
+      end
+      if tag != false && tag > MAX_32_BIT_UNSIGNED_INT
+        raise 'Invalid tag'
+      end
+      the_tag = tag || 0
+      flag = tag == false || tag.nil? ? 0 : 1
+
+      bytes = concat_args(
+        test ? PREFIX_BYTES[:test] : PREFIX_BYTES[:main],
+        account_id,
+        [
+          flag,
+          the_tag & 0xff,
+          (the_tag >> 8) & 0xff,
+          (the_tag >> 16) & 0xff,
+          (the_tag >> 24) & 0xff,
+          0,
+          0,
+          0,
+          0
+        ]
+      )
+
+      encode_checked(bytes)
+    end
+
+    def x_address_to_classic_address(x_address)
+      decoded = decode_x_address(x_address)
+      account_id = decoded[:account_id]
+      tag = decoded[:tag]
+      test = decoded[:test]
+      classic_address = encode_account_id(account_id)
+      {
+        classic_address: classic_address,
+        tag: tag,
+        test: test
+      }
+    end
+
+    def decode_x_address(x_address)
+      decoded = decode_checked(x_address)
+      test = is_uint8_array_for_test_address(decoded)
+      account_id = decoded[2, 20]
+      tag = tag_from_uint8_array(decoded)
+      {
+        account_id: account_id,
+        tag: tag,
+        test: test
+      }
+    end
+
+    def valid_x_address?(x_address)
+      begin
+        decode_x_address(x_address)
+      rescue
+        return false
+      end
+      true
+    end
+
+    private
+
+    def is_uint8_array_for_test_address(buf)
+      decoded_prefix = buf[0, 2]
+      if decoded_prefix == PREFIX_BYTES[:main]
+        return false
+      end
+      if decoded_prefix == PREFIX_BYTES[:test]
+        return true
+      end
+
+      raise 'Invalid X-address: bad prefix'
+    end
+
+    def tag_from_uint8_array(bytes)
+      flag = bytes[22]
+      if flag >= 2
+        # Keine Unterstützung für 64-Bit-Tags zu diesem Zeitpunkt
+        raise 'Unsupported X-address'
+      end
+      if flag == 1
+        # Little-endian zu Big-endian
+        return bytes[23] + bytes[24] * 0x100 + bytes[25] * 0x10000 + bytes[26] * 0x1000000
+      end
+      if flag != 0
+        raise 'flag must be zero to indicate no tag'
+      end
+      if '0000000000000000' !=  bytes_to_hex(bytes[23, 8])
+        raise 'remaining bytes must be zero'
+      end
+      false
+    end
+
+  end
+
+end

data/lib/address-codec/codec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'digest'
+
+require_relative "../core/core"
+
+module AddressCodec
+  class Codec
+
+    def initialize
+      @codec = Core::Base58XRP.new
+    end
+
+    def encode(bytes, opts)
+      versions = opts[:versions]
+      encode_versioned(bytes, versions, opts[:expected_length])
+    end
+
+    def decode(base58string, opts)
+      versions = opts[:versions]
+      types = opts[:version_types]
+
+      without_sum = decode_checked(base58string)
+
+      if versions.length > 1 && !opts[:expected_length]
+        raise 'expected_length is required because there are >= 2 possible versions'
+      end
+
+      version_length_guess = versions[0].is_a?(Numeric) ? 1 : versions[0].length
+      payload_length = opts[:expected_length] || without_sum.length - version_length_guess
+      version_bytes = without_sum[0...-payload_length]
+      payload = without_sum[-payload_length..-1]
+
+      versions.each_with_index do |version, i|
+        version = Array(version)
+        if version_bytes == version
+          return {
+            version: version,
+            bytes: payload,
+            type: types ? types[i] : nil
+          }
+        end
+      end
+
+      raise 'version_invalid: version bytes do not match any of the provided version(s)'
+    end
+
+    def encode_checked(bytes)
+      check = sha256(sha256(bytes))[0, 4]
+      encode_raw(bytes + check)
+    end
+
+    def decode_checked(base58string)
+      bytes = decode_raw(base58string)
+
+      if bytes.length < 5
+        raise 'invalid_input_size: decoded data must have length >= 5'
+      end
+
+      unless verify_check_sum(bytes)
+        raise 'checksum_invalid'
+      end
+
+      bytes[0...-4]
+    end
+
+    private
+
+    def encode_versioned(bytes, versions, expected_length)
+      unless check_byte_length(bytes, expected_length)
+        raise 'unexpected_payload_length: bytes.length does not match expected_length. Ensure that the bytes are a Uint8Array.'
+      end
+
+      encode_checked(concat_args(versions, bytes))
+    end
+
+    def encode_raw(bytes)
+      @codec.encode(bytes.pack('C*'))
+    end
+
+    def decode_raw(base58string)
+      @codec.decode(base58string).unpack('C*')
+    end
+
+    def sha256(bytes)
+      binary_value = bytes.pack('C*')
+      binary_hash = Digest::SHA256.digest(binary_value)
+      binary_hash.unpack('C*')
+    end
+
+    def verify_check_sum(bytes)
+      computed = sha256(sha256(bytes[0...-4]))[0, 4]
+      checksum = bytes[-4, 4]
+      computed == checksum
+    end
+
+  end
+
+end

data/lib/address-codec/xrp_codec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../core/core"
+
+module AddressCodec
+
+  class XrpCodec < Codec
+
+    # base58 encodings: https://xrpl.org/base58-encodings.html
+    ACCOUNT_ID = 0            # Account address (20 bytes)
+    ACCOUNT_PUBLIC_KEY = 0x23 # Account public key (33 bytes)
+    FAMILY_SEED = 0x21        # 33; Seed value (for secret keys) (16 bytes)
+    NODE_PUBLIC = 0x1c        # 28; Validation public key (33 bytes)
+    ED25519_SEED = [0x01, 0xe1, 0x4b].freeze # [1, 225, 75]
+
+    def encode_seed(entropy, type = nil)
+      unless check_byte_length(entropy, 16)
+        raise 'entropy must have length 16'
+      end
+
+      opts = {
+        expected_length: 16,
+        versions: type == 'ed25519' ? ED25519_SEED : [FAMILY_SEED]
+      }
+
+      # prefixes entropy with version bytes
+      encode(entropy, opts)
+    end
+
+    def decode_seed(seed, opts = {
+          version_types: ['ed25519', 'secp256k1'],
+          versions: [ED25519_SEED, FAMILY_SEED],
+          expected_length: 16
+        })
+      decode(seed, opts)
+    end
+
+    def encode_account_id(bytes)
+      opts = { versions: [ACCOUNT_ID], expected_length: 20 }
+      encode(bytes, opts)
+    end
+
+    def decode_account_id(account_id)
+      opts = { versions: [ACCOUNT_ID], expected_length: 20 }
+      decode(account_id, opts)[:bytes]
+    end
+
+    def decode_node_public(base58string)
+      opts = { versions: [NODE_PUBLIC], expected_length: 33 }
+      decode(base58string, opts)[:bytes]
+    end
+
+    def encode_node_public(bytes)
+      opts = { versions: [NODE_PUBLIC], expected_length: 33 }
+      encode(bytes, opts)
+    end
+
+    def encode_account_public(bytes)
+      opts = { versions: [ACCOUNT_PUBLIC_KEY], expected_length: 33 }
+      encode(bytes, opts)
+    end
+
+    def decode_account_public(base58string)
+      opts = { versions: [ACCOUNT_PUBLIC_KEY], expected_length: 33 }
+      decode(base58string, opts)[:bytes]
+    end
+
+    def valid_classic_address?(address)
+      begin
+        decode_account_id(address)
+      rescue
+        return false
+      end
+      true
+    end
+
+  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,37 @@
 # @!attribute
-require_relative 'base_x'
+require_relative 'base_x'
+require_relative 'base_58_xrp'
+
+def bytes_to_hex(bytes)
+  bytes.pack('C*').unpack1('H*').upcase
+end
+
+def hex_to_bytes(hex)
+  [hex].pack('H*').bytes
+end
+
+def hex_to_bin(hex)
+  [hex].pack("H*")
+end
+
+def bin_to_hex(bin)
+  bin.unpack("H*").first.upcase
+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

data/lib/xrpl-ruby.rb

@@ -1,3 +1,7 @@
 # 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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xrpl-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Alexander Busse
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-05 00:00:00.000000000 Z
+date: 2024-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,6 +61,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/address-codec/address_codec.rb
+- lib/address-codec/codec.rb
+- lib/address-codec/xrp_codec.rb
+- lib/core/base_58_xrp.rb
 - lib/core/base_x.rb
 - lib/core/core.rb
 - lib/xrpl-ruby.rb