xrpl-ruby 0.0.3 → 0.5.0

data/lib/binary-codec/utilities.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+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
+
+  # TODO: Marked for overhaul
+  def self.is_valid_x_address?(x_address)
+    return false unless x_address.is_a?(String) && x_address.start_with?('X')
+
+    begin
+      decoded = decode_x_address(x_address)
+      return false if decoded[:account_id].nil? || decoded[:account_id].length != 20
+
+      tag = decoded[:tag]
+      return false if tag && (tag < 0 || tag > MAX_32_BIT_UNSIGNED_INT)
+
+      true
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/core/base_58_xrp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Core
 
   class Base58XRP < BaseX

data/lib/core/base_x.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 module Core
 
   class BaseX
+    # Initializes a new BaseX instance with the given alphabet.
+    # @param alphabet [String] The alphabet to use for encoding and decoding.
     def initialize(alphabet)
       @alphabet = alphabet
       @base = alphabet.length
@@ -8,6 +12,9 @@ module Core
       alphabet.chars.each_with_index { |char, index| @alphabet_map[char] = index }
     end
 
+    # Encodes a byte array into a string using the alphabet.
+    # @param buffer [String] The byte string to encode.
+    # @return [String] The encoded string.
     def encode(buffer)
       return @alphabet[0] if buffer.empty?
 
@@ -30,6 +37,9 @@ module Core
       digits.reverse.map { |digit| @alphabet[digit] }.join
     end
 
+    # Decodes a string into a byte string using the alphabet.
+    # @param string [String] The string to decode.
+    # @return [String] The decoded byte string.
     def decode(string)
       return '' if string.empty?
 

data/lib/core/core.rb

@@ -1,23 +1,70 @@
-# @!attribute
-require_relative 'base_x'
-require_relative 'base_58_xrp'
+# frozen_string_literal: true
 
+require 'securerandom'
+
+# Returns a random byte array of the given size.
+# @param size [Integer] The number of bytes to generate.
+# @return [Array<Integer>] The generated random byte array.
+def random_bytes(size)
+  SecureRandom.random_bytes(size).bytes
+end
+
+# Converts a byte array to a hex string.
+# @param bytes [Array<Integer>] The byte array to convert.
+# @return [String] The hex string.
 def bytes_to_hex(bytes)
   bytes.pack('C*').unpack1('H*').upcase
 end
-
+# Converts a hex string to a byte array.
+# @param hex [String] The hex string to convert.
+# @return [Array<Integer>] The byte array.
 def hex_to_bytes(hex)
+  raise ArgumentError, 'Invalid hex string' unless valid_hex?(hex)
   [hex].pack('H*').bytes
 end
 
+# Converts a binary string to a hex string.
+# @param bin [String] The binary string to convert.
+# @return [String] The hex string.
+def bin_to_hex(bin)
+  bin.unpack("H*").first.upcase
+end
+
+# Converts a hex string to a binary string.
+# @param hex [String] The hex string to convert.
+# @return [String] The binary string.
 def hex_to_bin(hex)
+  raise ArgumentError, 'Invalid hex string' unless valid_hex?(hex)
   [hex].pack("H*")
 end
 
-def bin_to_hex(bin)
-  bin.unpack("H*").first.upcase
+# Converts a hex string to a string with the given encoding.
+# @param hex [String] The hex string to convert.
+# @param encoding [String] The encoding to use.
+# @return [String] The decoded string.
+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
 
+# Converts a string to a hex string.
+# @param string [String] The string to convert.
+# @return [String] The hex string.
+def string_to_hex(string)
+  string.unpack1('H*').upcase
+end
+
+# Checks if a string is a valid hex string.
+# @param str [String] The string to check.
+# @return [Boolean] True if the string is a valid hex string, false otherwise.
+def valid_hex?(str)
+  str =~ /\A[0-9a-fA-F]*\z/ && str.length.even?
+end
+
+# Checks if a byte array has the expected length.
+# @param bytes [Array<Integer>, String] The byte array or string to check.
+# @param expected_length [Integer] The expected length.
+# @return [Boolean] True if the length matches, false otherwise.
 def check_byte_length(bytes, expected_length)
   if bytes.respond_to?(:byte_length)
     bytes.byte_length == expected_length
@@ -26,12 +73,38 @@ def check_byte_length(bytes, expected_length)
   end
 end
 
+# Concatenates multiple arguments into a single array.
+# @param args [Array] The arguments to concatenate.
+# @return [Array] The concatenated array.
 def concat_args(*args)
   args.flat_map do |arg|
     is_scalar?(arg) ? [arg] : arg.to_a
   end
 end
 
+# Checks if a value is a scalar.
+# @param val [Object] The value to check.
+# @return [Boolean] True if the value is a numeric scalar, false otherwise.
 def is_scalar?(val)
   val.is_a?(Numeric)
+end
+
+# Converts an integer to a byte array.
+# @param number [Integer] The integer to convert.
+# @param width [Integer] The number of bytes in the result.
+# @param byteorder [Symbol] The byte order (:big or :little).
+# @return [Array<Integer>] The byte array.
+def int_to_bytes(number, width = 1, byteorder = :big)
+  bytes = []
+  while number > 0
+    bytes << (number & 0xFF)
+    number >>= 8
+  end
+
+  while bytes.size < width
+    bytes << 0
+  end
+
+  bytes.reverse! if byteorder == :big
+  bytes
 end

data/lib/core/utilities.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Core
+
+  class Utilities
+
+    @address_codec = nil
+
+    def initialize
+      @address_codec = AddressCodec.new
+    end
+
+    # Returns the singleton instance of the Utilities class.
+    # @return [Utilities] The singleton instance.
+    def self.instance
+      @@instance ||= new
+    end
+
+    # Checks if a string is a valid X-address.
+    # @param x_address [String] The X-address to check.
+    # @return [Boolean] True if the string is a valid X-address, false otherwise.
+    def is_x_address?(x_address)
+      return false unless x_address.is_a?(String) && x_address.start_with?('X')
+
+      begin
+        decoded = @address_codec.decode_x_address(x_address)
+        return false if decoded[:account_id].nil? || decoded[:account_id].length != 20
+
+        tag = decoded[:tag]
+        return false if tag && (tag < 0 || tag > MAX_32_BIT_UNSIGNED_INT)
+
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/key-pairs/ed25519.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'ed25519'
+
+module KeyPairs
+  # Ed25519 implementation for XRPL key pairs.
+  module Ed25519
+    # Derives a key pair from a seed.
+    # @param seed [Array<Integer>] 16 bytes of seed entropy.
+    # @return [Hash] A hash containing :public_key and :private_key (hex strings).
+    def self.derive_key_pair(seed)
+      # XRPL Ed25519 uses the SHA512 of the 16-byte seed as the 32-byte entropy for the signing key.
+      seed_bytes = seed.is_a?(Array) ? seed.pack('C*') : seed
+      hash = Digest::SHA512.digest(seed_bytes)[0...32]
+      signing_key = ::Ed25519::SigningKey.new(hash)
+      
+      # Public key in XRPL is 0xED followed by 32 bytes of public key.
+      public_key = [0xED].pack('C') + signing_key.verify_key.to_bytes
+      
+      # Private key in XRPL is the 32-byte hash.
+      {
+        public_key: public_key.unpack1('H*').upcase,
+        private_key: hash.unpack1('H*').upcase
+      }
+    end
+
+    # Signs a message with a private key.
+    # @param message [Array<Integer>, String] The message to sign.
+    # @param private_key [String] The private key (32-byte hash as hex).
+    # @return [String] The signature (hex string).
+    def self.sign(message, private_key)
+      msg_bytes = message.is_a?(String) ? [message].pack('H*') : message.pack('C*')
+      key_bytes = [private_key].pack('H*')
+      signing_key = ::Ed25519::SigningKey.new(key_bytes)
+      
+      signature = signing_key.sign(msg_bytes)
+      signature.unpack1('H*').upcase
+    end
+
+    # Verifies a signature.
+    # @param message [Array<Integer>, String] The message.
+    # @param signature [String] The signature (hex string).
+    # @param public_key [String] The public key (33-byte hex, starts with ED).
+    # @return [Boolean] True if the signature is valid.
+    def self.verify(message, signature, public_key)
+      msg_bytes = message.is_a?(String) ? hex_to_bin(message) : message.pack('C*')
+      sig_bytes = [signature].pack('H*')
+      
+      # Strip the 0xED prefix from the public key
+      pub_bytes = [public_key].pack('H*')
+      if pub_bytes[0].ord != 0xED
+        raise ArgumentError, "Invalid Ed25519 public key prefix"
+      end
+      
+      verify_key = ::Ed25519::VerifyKey.new(pub_bytes[1..-1])
+      begin
+        verify_key.verify(sig_bytes, msg_bytes)
+        true
+      rescue ::Ed25519::VerifyError
+        false
+      end
+    end
+  end
+end

data/lib/key-pairs/key_pairs.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module KeyPairs
+  # Main entry point for XRPL key pair operations.
+  class KeyPairs
+    def initialize
+      @address_codec = AddressCodec::AddressCodec.new
+    end
+
+    # Generates a new seed.
+    # @param entropy [Array<Integer>, nil] 16 bytes of entropy.
+    # @param type [String] The seed type ('secp256k1' or 'ed25519').
+    # @return [String] The encoded seed string.
+    def generate_seed(entropy = nil, type = 'secp256k1')
+      entropy ||= SecureRandom.random_bytes(16).bytes
+      @address_codec.encode_seed(entropy, type)
+    end
+
+    # Derives a key pair from an encoded seed.
+    # @param seed [String] The encoded seed string.
+    # @param options [Hash] Options including :account_index (for secp256k1).
+    # @return [Hash] A hash containing :public_key and :private_key (hex strings).
+    def derive_key_pair(seed, options = {})
+      decoded = @address_codec.decode_seed(seed)
+      type = decoded[:type]
+      entropy = decoded[:bytes]
+
+      if type == 'ed25519'
+        Ed25519.derive_key_pair(entropy)
+      else
+        # For secp256k1, we use the entropy as seed
+        Secp256k1.derive_key_pair(entropy)
+      end
+    end
+
+    # Signs a message with a private key.
+    # @param message [String] The message to sign as hex.
+    # @param private_key [String] The private key as hex.
+    # @param algorithm [String, nil] The algorithm to use ('secp256k1' or 'ed25519').
+    # @return [String] The signature as hex.
+    def sign(message, private_key, algorithm = nil)
+      if algorithm == 'ed25519' || (algorithm.nil? && private_key.length == 64)
+        # Heuristic: Ed25519 private keys in our lib are 32 bytes (64 hex chars).
+        # Secp256k1 are also 32 bytes, but Ed25519 is often explicitly requested.
+        # Actually, let's look at the prefix of the public key if we had it.
+        # Since we don't have the public key here, we rely on the caller or length.
+        # In XRPL-Ruby, Ed25519 private keys are 64 hex chars (32 bytes).
+        # Secp256k1 are also 64 hex chars. This is ambiguous!
+        # Let's try to see if it's explicitly 'ed25519'.
+        begin
+          return Ed25519.sign(message, private_key) if algorithm == 'ed25519'
+          return Secp256k1.sign(message, private_key)
+        rescue => e
+          # If secp fails and we didn't specify, maybe it was ed? 
+          # But that's dangerous.
+          raise e
+        end
+      else
+        Secp256k1.sign(message, private_key)
+      end
+    end
+
+    # Verifies a signature.
+    # @param message [String] The message as hex.
+    # @param signature [String] The signature as hex.
+    # @param public_key [String] The public key as hex.
+    # @return [Boolean] True if the signature is valid.
+    def verify(message, signature, public_key)
+      if public_key.start_with?('ED')
+        Ed25519.verify(message, signature, public_key)
+      else
+        Secp256k1.verify(message, signature, public_key)
+      end
+    end
+
+    # Derives an XRP address from a public key.
+    # @param public_key [String] The public key as hex.
+    # @return [String] The XRP address.
+    def derive_address(public_key)
+      public_key_bytes = [public_key].pack('H*')
+      # Account ID is RIPEMD160(SHA256(public_key))
+      sha256 = Digest::SHA256.digest(public_key_bytes)
+      # Ruby doesn't have RIPEMD160 in Digest by default sometimes, 
+      # but OpenSSL has it.
+      ripemd160 = OpenSSL::Digest.new('RIPEMD160').digest(sha256)
+      
+      @address_codec.encode_account_id(ripemd160.unpack('C*'))
+    end
+  end
+end

data/lib/key-pairs/secp256k1.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module KeyPairs
+  # Secp256k1 implementation for XRPL key pairs.
+  module Secp256k1
+    # Derives a key pair from a seed.
+    # @param seed [Array<Integer>] 16 bytes of seed entropy.
+    # @return [Hash] A hash containing :public_key and :private_key (hex strings).
+    def self.derive_key_pair(seed)
+      # XRPL Secp256k1 uses a specific derivation algorithm (seed -> family seed -> sequence 0 key).
+      # Seed is passed as a 16-byte array.
+      private_key = derive_private_key(seed)
+      public_key = derive_public_key(private_key)
+      
+      {
+        public_key: public_key.unpack1('H*').upcase,
+        private_key: private_key.unpack1('H*').upcase
+      }
+    end
+
+    # Signs a message with a private key.
+    # @param message [Array<Integer>, String] The message to sign.
+    # @param private_key [String] The private key (hex string).
+    # @return [String] The signature (hex string).
+    def self.sign(message, private_key)
+      msg_hash = message.is_a?(String) ? [message].pack('H*') : message.pack('C*')
+      
+      # Use the dsa_sign_asn1 method directly on a PKey::EC object.
+      # In OpenSSL 3.0, setting private_key might be blocked if not done carefully.
+      # We use a fresh object and set the key.
+      ec = OpenSSL::PKey::EC.new('secp256k1')
+      begin
+        # Use send to bypass potential visibility or immutability checks if any,
+        # but usually private_key= is public.
+        ec.private_key = OpenSSL::BN.new(private_key, 16)
+        ec.public_key = ec.group.generator.mul(ec.private_key)
+        
+        signature = ec.dsa_sign_asn1(msg_hash)
+        signature.unpack1('H*').upcase
+      rescue OpenSSL::PKey::PKeyError => e
+        # If OpenSSL 3.0 is too strict, we might be unable to sign without a dedicated gem.
+        # However, for the sake of completion, we'll try a fallback if it exists.
+        raise "Secp256k1 signing failed: #{e.message}. This might be due to OpenSSL 3.0 immutability."
+      end
+    end
+
+    # Verifies a signature.
+    # @param message [Array<Integer>, String] The message.
+    # @param signature [String] The signature (hex string).
+    # @param public_key [String] The public key (hex string).
+    # @return [Boolean] True if the signature is valid.
+    def self.verify(message, signature, public_key)
+      msg_hash = message.is_a?(String) ? [message].pack('H*') : message.pack('C*')
+      sig_bytes = [signature].pack('H*')
+      
+      ec = OpenSSL::PKey::EC.new('secp256k1')
+      ec.public_key = OpenSSL::PKey::EC::Point.new(ec.group, OpenSSL::BN.new(public_key, 16))
+      
+      ec.dsa_verify_asn1(msg_hash, sig_bytes)
+    end
+
+    private
+
+    # Derives the 32-byte private key from the 16-byte seed.
+    # This follows the Ripple seed derivation algorithm.
+    def self.derive_private_key(seed, account_index = 0)
+      ec_key = OpenSSL::PKey::EC.new('secp256k1')
+      order = ec_key.group.order
+      
+      # 1. Derive root private key from seed
+      root_private_key = derive_scalar(seed)
+      
+      # 2. Derive root public key from root private key
+      root_public_key = derive_root_public_key(root_private_key)
+      
+      # 3. Derive child scalar from root public key and account_index
+      child_scalar = derive_scalar(root_public_key, account_index)
+      
+      # 4. child_private_key = (root_private_key + child_scalar) % order
+      child_private_key = (OpenSSL::BN.new(root_private_key, 16) + OpenSSL::BN.new(child_scalar, 16)) % order
+      child_private_key.to_s(16).rjust(64, '0')
+    end
+
+    def self.derive_scalar(seed, sequence = nil)
+      seed_bytes = seed.is_a?(Array) ? seed.pack('C*') : seed
+      ec_key = OpenSSL::PKey::EC.new('secp256k1')
+      order = ec_key.group.order
+      loop_count = 0
+      loop do
+        data = sequence ? seed_bytes + [sequence].pack('N') : seed_bytes
+        data += [loop_count].pack('N')
+        hash = Digest::SHA512.digest(data)[0...32]
+        scalar = OpenSSL::BN.new(hash.unpack1('H*'), 16)
+        
+        if scalar > 0 && scalar < order
+          return scalar.to_s(16).rjust(64, '0')
+        end
+        loop_count += 1
+        raise "Too many loops" if loop_count > 100
+      end
+    end
+
+    def self.derive_root_public_key(private_key_hex)
+      group = OpenSSL::PKey::EC::Group.new('secp256k1')
+      key_bn = OpenSSL::BN.new(private_key_hex, 16)
+      pub_key_point = group.generator.mul(key_bn)
+      pub_key_point.to_octet_string(:compressed)
+    end
+
+    def self.derive_public_key(private_key_hex)
+      derive_root_public_key(private_key_hex)
+    end
+  end
+end

data/lib/wallet/wallet.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'openssl'
+
+module Wallet
+  # Represents an XRPL wallet, providing methods for signing and address derivation.
+  class Wallet
+    # @return [String] The public key as hex.
+    attr_reader :public_key
+    # @return [String] The private key as hex.
+    attr_reader :private_key
+    # @return [String] The encoded seed.
+    attr_reader :seed
+    # @return [String] The classic address.
+    attr_reader :classic_address
+    # @return [String] The algorithm used ('secp256k1' or 'ed25519').
+    attr_reader :algorithm
+
+    # Initializes a new Wallet instance.
+    # @param public_key [String] The public key as hex.
+    # @param private_key [String] The private key as hex.
+    # @param seed [String, nil] The encoded seed.
+    # @param classic_address [String, nil] The classic address (optional, derived if not provided).
+    def initialize(public_key, private_key, seed: nil, classic_address: nil)
+      @public_key = public_key
+      @private_key = private_key
+      @seed = seed
+      @algorithm = public_key.start_with?('ED') ? 'ed25519' : 'secp256k1'
+      @key_pairs = KeyPairs::KeyPairs.new
+      @classic_address = classic_address || @key_pairs.derive_address(public_key)
+    end
+
+    # Generates a new random wallet.
+    # @param algorithm [String] The algorithm to use ('secp256k1' or 'ed25519').
+    # @return [Wallet] A new Wallet instance.
+    def self.generate(algorithm = 'secp256k1')
+      kp = KeyPairs::KeyPairs.new
+      seed = kp.generate_seed(nil, algorithm)
+      from_seed(seed)
+    end
+
+    # Creates a wallet from a seed.
+    # @param seed [String] The encoded seed.
+    # @param options [Hash] Options for key derivation.
+    # @return [Wallet] A new Wallet instance.
+    def self.from_seed(seed, options = {})
+      kp = KeyPairs::KeyPairs.new
+      keys = kp.derive_key_pair(seed, options)
+      new(keys[:public_key], keys[:private_key], seed: seed)
+    end
+
+    # Creates a wallet from entropy.
+    # @param entropy [Array<Integer>] 16 bytes of entropy.
+    # @param algorithm [String] The algorithm to use ('secp256k1' or 'ed25519').
+    # @return [Wallet] A new Wallet instance.
+    def self.from_entropy(entropy, algorithm = 'secp256k1')
+      kp = KeyPairs::KeyPairs.new
+      seed = kp.generate_seed(entropy, algorithm)
+      from_seed(seed)
+    end
+
+    # Signs a message (hex string) with the wallet's private key.
+    # @param message [String, Hash] The message (hex string) or transaction (Hash) to sign.
+    # @param multisign [Boolean] Whether to sign for a multisigned transaction.
+    # @return [String] The signature as a hex string.
+    def sign(message, multisign: false)
+      algorithm = @algorithm
+      # Check if message is a Hash (transaction)
+      if message.is_a?(Hash)
+        prefix = multisign ? BinaryCodec::HASH_PREFIX[:transaction_multi_sig] : BinaryCodec::HASH_PREFIX[:transaction_sig]
+        signing_data = BinaryCodec.signing_data(message, prefix, signing_fields_only: true)
+        message = bytes_to_hex(signing_data)
+      end
+
+      @key_pairs.sign(message, @private_key, algorithm)
+    end
+
+    # Verifies a signature for a message.
+    # @param message [String] The message as a hex string.
+    # @param signature [String] The signature as a hex string.
+    # @return [Boolean] True if the signature is valid.
+    def verify(message, signature)
+      @key_pairs.verify(message, signature, @public_key)
+    end
+
+    # Verifies a signed transaction blob.
+    # @param signed_transaction [String] The signed transaction blob as a hex string.
+    # @return [Boolean] True if the transaction signature is valid.
+    def verify_transaction(signed_transaction)
+      decoded = BinaryCodec.binary_to_json(signed_transaction)
+      # The signing data is the transaction without the TxnSignature field,
+      # prefixed by 0x53545800 (STX\0).
+      
+      tx_for_signing = decoded.dup
+      signature = tx_for_signing.delete('TxnSignature')
+      return false unless signature
+
+      signing_data = BinaryCodec.signing_data(tx_for_signing)
+      @key_pairs.verify(bytes_to_hex(signing_data), signature, @public_key)
+    end
+
+    # Derives the X-address for this wallet.
+    # @param tag [Integer, false, nil] The destination tag.
+    # @param test_network [Boolean] Whether the address is for a test network.
+    # @return [String] The encoded X-address.
+    def get_x_address(tag: nil, test_network: false)
+      address_codec = AddressCodec::AddressCodec.new
+      address_codec.classic_address_to_x_address(@classic_address, tag, test_network)
+    end
+
+    # @return [String] String representation of the wallet.
+    def to_s
+      "Wallet(address: #{@classic_address}, public_key: #{@public_key})"
+    end
+  end
+end