xrpl-ruby 0.2.4 → 0.5.0

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

data/lib/xrpl-ruby.rb

@@ -1,14 +1,38 @@
 # frozen_string_literal: true
 
+require_relative 'core/base_x'
+require_relative 'core/base_58_xrp'
 require_relative 'core/core'
+require_relative 'core/utilities'
 
 require_relative 'address-codec/codec'
 require_relative 'address-codec/xrp_codec'
 require_relative 'address-codec/address_codec'
 
+require_relative 'binary-codec/enums/constants'
+require_relative 'binary-codec/utilities'
 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/serdes/binary_serializer'
 require_relative 'binary-codec/types/serialized_type'
-require_relative 'binary-codec/types/hash'
+require_relative 'binary-codec/types/hash'
+require_relative 'binary-codec/types/uint'
+require_relative 'binary-codec/types/account_id'
+require_relative 'binary-codec/types/amount'
+require_relative 'binary-codec/types/blob'
+require_relative 'binary-codec/types/currency'
+require_relative 'binary-codec/types/st_array'
+require_relative 'binary-codec/types/st_object'
+require_relative 'binary-codec/types/vector256'
+require_relative 'binary-codec/types/path_set'
+require_relative 'binary-codec/types/issue'
+require_relative 'binary-codec/types/xchain_bridge'
+require_relative 'binary-codec/binary_codec'
+
+require_relative 'wallet/wallet'
+
+require_relative 'key-pairs/ed25519'
+require_relative 'key-pairs/secp256k1'
+require_relative 'key-pairs/key_pairs'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xrpl-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Alexander Busse
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-20 00:00:00.000000000 Z
+date: 2026-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: This gem provides a Ruby interface to interact with the XRP Ledger (XRPL)
   blockchain, allowing developers to easily integrate XRPL functionality into their
   Ruby applications.
@@ -77,13 +91,23 @@ files:
 - lib/binary-codec/types/blob.rb
 - lib/binary-codec/types/currency.rb
 - lib/binary-codec/types/hash.rb
+- lib/binary-codec/types/issue.rb
+- lib/binary-codec/types/path_set.rb
 - lib/binary-codec/types/serialized_type.rb
+- lib/binary-codec/types/st_array.rb
 - lib/binary-codec/types/st_object.rb
 - lib/binary-codec/types/uint.rb
+- lib/binary-codec/types/vector256.rb
+- lib/binary-codec/types/xchain_bridge.rb
 - lib/binary-codec/utilities.rb
 - lib/core/base_58_xrp.rb
 - lib/core/base_x.rb
 - lib/core/core.rb
+- lib/core/utilities.rb
+- lib/key-pairs/ed25519.rb
+- lib/key-pairs/key_pairs.rb
+- lib/key-pairs/secp256k1.rb
+- lib/wallet/wallet.rb
 - lib/xrpl-ruby.rb
 homepage: https://github.com/AlexanderBuzz/xrpl-ruby
 licenses: