xrpl-ruby 0.0.1 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe5e22e400d255c2c834133232433c9c8a513d3c1fba93dc06f46e18d90b1c3d
-  data.tar.gz: 0512e71a026bef8893fa8855c702ccdb09e18ce219f286c3cea33b2b5d477e38
+  metadata.gz: 6895a3507b4f4d76bb12cd9c150c2f395a35e44146ee45dea5579076c780fc56
+  data.tar.gz: a641537d7f0ce171f7ddf5380b0e3ab0d396a5a2ec5f884e090fe12ba1b49eb6
 SHA512:
-  metadata.gz: c7b52d5c38ead6d5d5910cbd5132be7ea783e24b8c21f452d56138c9e806d016d9186d3213913372b3d5cb8d1c0bdca9c6acf8f7c9de1c5416571bf9d0873b2e
-  data.tar.gz: '00914805ec76c9fe7a2b475881efde3408f6f609f3ffaedc30d21fe845d3dd247051158561c29fe69af688238d4c86fb5a4124747c806bfe6a64f4c31a244020'
+  metadata.gz: 453610629153989c93ff0ac3e504dfd4fa8fb90ccc3adbbac104522dee5b03192a7a6ba1d4206424f17174080ece7b897fc02b5bd513432979269df0dba7768b
+  data.tar.gz: ca5696e3df36e747e395f351043223d81a7445970db5d8b40d3cd398f9a1c70bff3495f926dea412920bb81cdfdbb78a825c9b3afa13e6b381ba84ea04ecfec4

data/lib/address-codec/address_codec.rb

@@ -0,0 +1,118 @@
+# 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/binary-codec/binary_codec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  class BinaryCodec
+
+    # from here: https://github.com/XRPLF/xrpl.js/blob/main/packages/ripple-binary-codec/src/binary.ts
+
+    def make_parser(bytes, definitions = nil)
+      BinaryParser.new(bytes.is_a?(String) ? bytes : bytes_to_hex(bytes))
+    end
+
+    #def read_json(parser, definitions = DEFAULT_DEFINITIONS)
+    def read_json(parser)
+      # parser.read_type(core_types[:STObject]).to_json(definitions)
+      parser.read_type(core_types[:STObject]).to_json()
+    end
+
+    def binary_to_json(hex)
+      parser = make_parser(hex)
+      read_json(parser)
+    end
+
+    def serialize_object(obj, definitions = nil)
+      BytesList.new.put_type(core_types[:STObject], obj)
+    end
+
+    def signing_data(transaction, prefix = HashPrefix[:transaction_sig], opts = {})
+      serialize_object(
+        transaction,
+        prefix: prefix,
+        signing_fields_only: true,
+        definitions: opts[:definitions]
+      )
+    end
+
+  end
+
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module BinaryCodec
+  TYPE_WIDTH = 2
+  LEDGER_ENTRY_WIDTH = 2
+  TRANSACTION_TYPE_WIDTH = 2
+  TRANSACTION_RESULT_WIDTH = 1
+end