eth 0.4.17 → 0.4.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d50d2e45f9d5e59e5d56cc1a5f43fd96d892fa991c3479d9f7b74623cc288593
-  data.tar.gz: 519efad7ad2cc42e2402910ad298166dfa9266c552c579232715f8a7fa3b6a8b
+  metadata.gz: 2cfb1dbda97ae8033690aeb0ffe7410e2db112dbb3d2c78f34bad15db7dcbf45
+  data.tar.gz: '039a0fc3b15cd132f1409fc8636f32d501f237e338628c63672f21fed81047af'
 SHA512:
-  metadata.gz: 7e38450c7a46789421250fe0f34900d4a1066c500744ba04cf76feddb52cba26bf9c94bc981c7979f07568e74799b3e31e4e887195ae235f29d7a33e3620dae2
-  data.tar.gz: 0c3822f4a19288a63cb73fad38bab8cea19db5873c98ebc78aa5882ff921371617df97c728656ac0144aec2a13ab6c980be516036dfe0895ca6fb4b0a9c0fbb0
+  metadata.gz: e69bf16bccb10f673673c8f45167817930549813a3e9fa33b64e868a618f6bbd810c23a8512c1a0f535a18d38238b71ab18afdfd438e6ebd8cffb2deb5256a79
+  data.tar.gz: 67c6de579f25a7b9cdecd8fee97f5df927d8f0145c03b9604c324e86925ba905f6e98b42e49b1487178842ea25efe3a8f0ea35162ee96666db85345bf0281bd4

data/.github/workflows/build.yml

@@ -11,16 +11,26 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        ruby: ['2.7', '3.0']
     steps:
     - uses: actions/checkout@v2
     - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Brew Automake
+      run: |
+        brew install automake
+      if: startsWith(matrix.os, 'macOS')
     - name: Install Dependencies
       run: |
         git submodule update --init
         bundle install
     - name: Run Tests
       run: |
-        rspec
+        bundle exec rspec

data/.github/workflows/codeql.yml

@@ -8,9 +8,6 @@ on:
   push:
     branches:
       - develop
-  schedule:
-    -
-      cron: "45 1 * * 3"
 
 jobs:
   analyze:
@@ -36,3 +33,12 @@ jobs:
         uses: github/codeql-action/autobuild@v1
       - name: "Perform CodeQL Analysis"
         uses: github/codeql-action/analyze@v1
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '2.7'
+          bundler-cache: true
+      - name: "Run rufo code formatting checks"
+        run: |
+          gem install rufo
+          rufo --check ./lib
+          rufo --check ./spec

data/.github/workflows/docs.yml

@@ -0,0 +1,26 @@
+---
+name: Docs
+
+on:
+  push:
+    branches:
+      - develop
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '2.7'
+        bundler-cache: true
+    - name: Run Yard Doc
+      run: |
+        gem install yard
+        yard doc
+    - name: Deploy GH Pages
+      uses: JamesIves/github-pages-deploy-action@4.1.7
+      with:
+          branch: gh-pages
+          folder: doc/

data/Gemfile

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-source 'https://rubygems.org'
+# ref: https://github.com/GemHQ/money-tree/issues/50
+gem "money-tree", git: "https://github.com/GemHQ/money-tree.git"
+
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in eth.gemspec
 gemspec

data/eth.gemspec

@@ -1,46 +1,47 @@
 # frozen_string_literal: true
 # coding: utf-8
 
-lib = File.expand_path('lib', __dir__).freeze
+lib = File.expand_path("lib", __dir__).freeze
 $LOAD_PATH.unshift lib unless $LOAD_PATH.include? lib
 
-require 'eth/version'
+require "eth/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "eth"
-  spec.version       = Eth::VERSION
-  spec.authors       = ["Steve Ellis", "Afri Schoedon"]
-  spec.email         = ["email@steveell.is", "ruby@q9f.cc"]
+  spec.name = "eth"
+  spec.version = Eth::VERSION
+  spec.authors = ["Steve Ellis", "Afri Schoedon"]
+  spec.email = ["email@steveell.is", "ruby@q9f.cc"]
 
-  spec.summary       = %q{Simple API to sign Ethereum transactions.}
-  spec.description   = %q{Library to build, parse, and sign Ethereum transactions.}
-  spec.homepage      = "https://github.com/se3000/ruby-eth"
-  spec.license       = "MIT"
+  spec.summary = %q{Simple API to sign Ethereum transactions.}
+  spec.description = %q{Library to build, parse, and sign Ethereum transactions.}
+  spec.homepage = "https://github.com/se3000/ruby-eth"
+  spec.license = "MIT"
 
   spec.metadata = {
-    'homepage_uri'    => 'https://github.com/se3000/ruby-eth',
-    'source_code_uri' => 'https://github.com/se3000/ruby-eth',
-    'github_repo'     => 'https://github.com/se3000/ruby-eth',
-    'bug_tracker_uri' => 'https://github.com/se3000/ruby-eth/issues',
+    "homepage_uri" => "https://github.com/se3000/ruby-eth",
+    "source_code_uri" => "https://github.com/se3000/ruby-eth",
+    "github_repo" => "https://github.com/se3000/ruby-eth",
+    "bug_tracker_uri" => "https://github.com/se3000/ruby-eth/issues",
   }.freeze
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.test_files    = spec.files.grep %r{^(test|spec|features)/}
+  spec.test_files = spec.files.grep %r{^(test|spec|features)/}
 
-  spec.add_dependency 'keccak', '~> 1.3'
-  spec.add_dependency 'ffi', '~> 1.15'
-  spec.add_dependency 'money-tree', '~> 0.10'
-  spec.add_dependency 'rlp', '~> 0.7'
-  spec.add_dependency 'scrypt', '~> 3.0'
+  spec.add_dependency "keccak", "~> 1.3"
+  spec.add_dependency "ffi", "~> 1.15"
+  spec.add_dependency "money-tree", "~> 0.11"
+  spec.add_dependency "openssl", "~> 3.0"
+  spec.add_dependency "rlp", "~> 0.7"
+  spec.add_dependency "scrypt", "~> 3.0"
 
   spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = ">= 2.2", "< 4.0"
+  spec.required_ruby_version = ">= 2.6", "< 4.0"
 
-  spec.add_development_dependency 'bundler', '~> 2.2'
-  spec.add_development_dependency 'pry', '~> 0.14'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.10'
+  spec.add_development_dependency "bundler", "~> 2.2"
+  spec.add_development_dependency "pry", "~> 0.14"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.10"
 end

data/lib/eth/address.rb

@@ -1,6 +1,5 @@
 module Eth
   class Address
-
     def initialize(address)
       @address = Utils.prefix_hex(address)
     end
@@ -25,7 +24,6 @@ module Eth
       Utils.prefix_hex(cased.join)
     end
 
-
     private
 
     attr_reader :address
@@ -57,6 +55,5 @@ module Eth
     def unprefixed
       Utils.remove_hex_prefix address
     end
-
   end
 end

data/lib/eth/gas.rb

@@ -1,9 +1,7 @@
 module Eth
   class Gas
-
     GTXCOST = 21000       # TX BASE GAS COST
     GTXDATANONZERO = 68   # TX DATA NON ZERO BYTE GAS COST
     GTXDATAZERO = 4       # TX DATA ZERO BYTE GAS COST
-
   end
 end

data/lib/eth/key/decrypter.rb

@@ -1,5 +1,5 @@
-require 'json'
-require 'scrypt'
+require "json"
+require "scrypt"
 
 class Eth::Key::Decrypter
   include Eth::Utils
@@ -19,16 +19,15 @@ class Eth::Key::Decrypter
     bin_to_hex decrypted_data
   end
 
-
   private
 
   attr_reader :data, :key, :password
 
   def derive_key(password)
     case kdf
-    when 'pbkdf2'
+    when "pbkdf2"
       @key = OpenSSL::PKCS5.pbkdf2_hmac(password, salt, iterations, key_length, digest)
-    when 'scrypt'
+    when "scrypt"
       # OpenSSL 1.1 inclues OpenSSL::KDF.scrypt, but it is not available usually, otherwise we could do: OpenSSL::KDF.scrypt(password, salt: salt, N: n, r: r, p: p, length: key_length)
       @key = SCrypt::Engine.scrypt(password, salt, n, r, p, key_length)
     else
@@ -37,8 +36,8 @@ class Eth::Key::Decrypter
   end
 
   def check_macs
-    mac1 = keccak256(key[(key_length/2), key_length] + ciphertext)
-    mac2 = hex_to_bin crypto_data['mac']
+    mac1 = keccak256(key[(key_length / 2), key_length] + ciphertext)
+    mac2 = hex_to_bin crypto_data["mac"]
 
     if mac1 != mac2
       raise "Message Authentications Codes do not match!"
@@ -50,11 +49,11 @@ class Eth::Key::Decrypter
   end
 
   def crypto_data
-    @crypto_data ||= data['crypto'] || data['Crypto']
+    @crypto_data ||= data["crypto"] || data["Crypto"]
   end
 
   def ciphertext
-    hex_to_bin crypto_data['ciphertext']
+    hex_to_bin crypto_data["ciphertext"]
   end
 
   def cipher_name
@@ -64,41 +63,41 @@ class Eth::Key::Decrypter
   def cipher
     @cipher ||= OpenSSL::Cipher.new(cipher_name).tap do |cipher|
       cipher.decrypt
-      cipher.key = key[0, (key_length/2)]
+      cipher.key = key[0, (key_length / 2)]
       cipher.iv = iv
     end
   end
 
   def iv
-    hex_to_bin crypto_data['cipherparams']['iv']
+    hex_to_bin crypto_data["cipherparams"]["iv"]
   end
 
   def salt
-    hex_to_bin crypto_data['kdfparams']['salt']
+    hex_to_bin crypto_data["kdfparams"]["salt"]
   end
 
   def iterations
-    crypto_data['kdfparams']['c'].to_i
+    crypto_data["kdfparams"]["c"].to_i
   end
 
   def kdf
-    crypto_data['kdf']
+    crypto_data["kdf"]
   end
 
   def key_length
-    crypto_data['kdfparams']['dklen'].to_i
+    crypto_data["kdfparams"]["dklen"].to_i
   end
 
   def n
-    crypto_data['kdfparams']['n'].to_i
+    crypto_data["kdfparams"]["n"].to_i
   end
 
   def r
-    crypto_data['kdfparams']['r'].to_i
+    crypto_data["kdfparams"]["r"].to_i
   end
 
   def p
-    crypto_data['kdfparams']['p'].to_i
+    crypto_data["kdfparams"]["p"].to_i
   end
 
   def digest
@@ -108,6 +107,4 @@ class Eth::Key::Decrypter
   def digest_name
     "sha256"
   end
-  
-
 end

data/lib/eth/key/encrypter.rb

@@ -1,5 +1,5 @@
-require 'json'
-require 'securerandom'
+require "json"
+require "securerandom"
 
 class Eth::Key::Encrypter
   include Eth::Utils
@@ -48,7 +48,6 @@ class Eth::Key::Encrypter
     @id ||= options[:id] || SecureRandom.uuid
   end
 
-
   private
 
   attr_reader :derived_key, :encrypted_key, :key, :options
@@ -57,7 +56,7 @@ class Eth::Key::Encrypter
     @cipher ||= OpenSSL::Cipher.new(cipher_name).tap do |cipher|
       cipher.encrypt
       cipher.iv = iv
-      cipher.key = derived_key[0, (key_length/2)]
+      cipher.key = derived_key[0, (key_length / 2)]
     end
   end
 
@@ -74,7 +73,7 @@ class Eth::Key::Encrypter
   end
 
   def mac
-    keccak256(derived_key[(key_length/2), key_length] + encrypted_key)
+    keccak256(derived_key[(key_length / 2), key_length] + encrypted_key)
   end
 
   def cipher_name
@@ -107,22 +106,21 @@ class Eth::Key::Encrypter
 
   def salt
     @salt ||= if options[:salt]
-      hex_to_bin options[:salt]
-    else
-      SecureRandom.random_bytes(salt_length)
-    end
+        hex_to_bin options[:salt]
+      else
+        SecureRandom.random_bytes(salt_length)
+      end
   end
 
   def iv
     @iv ||= if options[:iv]
-      hex_to_bin options[:iv]
-    else
-      SecureRandom.random_bytes(iv_length)
-    end
+        hex_to_bin options[:iv]
+      else
+        SecureRandom.random_bytes(iv_length)
+      end
   end
 
   def address
     Eth::Key.new(priv: key).address
   end
-
 end

data/lib/eth/key.rb

@@ -1,7 +1,7 @@
 module Eth
   class Key
-    autoload :Decrypter, 'eth/key/decrypter'
-    autoload :Encrypter, 'eth/key/encrypter'
+    autoload :Decrypter, "eth/key/decrypter"
+    autoload :Encrypter, "eth/key/encrypter"
 
     attr_reader :private_key, :public_key
 
@@ -17,7 +17,7 @@ module Eth
     end
 
     def self.personal_recover(message, signature)
-      bin_signature = Utils.hex_to_bin(signature).bytes.rotate(-1).pack('c*')
+      bin_signature = Utils.hex_to_bin(signature).bytes.rotate(-1).pack("c*")
       OpenSsl.recover_compact(Utils.keccak256(Utils.prefix_message(message)), bin_signature)
     end
 
@@ -41,6 +41,7 @@ module Eth
     def address
       Utils.public_key_to_address public_hex
     end
+
     alias_method :to_address, :address
 
     def sign(message)
@@ -60,10 +61,9 @@ module Eth
     end
 
     def personal_sign(message)
-      Utils.bin_to_hex(sign(Utils.prefix_message(message)).bytes.rotate(1).pack('c*'))
+      Utils.bin_to_hex(sign(Utils.prefix_message(message)).bytes.rotate(1).pack("c*"))
     end
 
-
     private
 
     def message_hash(message)
@@ -72,8 +72,7 @@ module Eth
 
     def valid_s?(signature)
       s_value = Utils.v_r_s_for(signature).last
-      s_value <= Secp256k1::N/2 && s_value != 0
+      s_value <= Secp256k1::N / 2 && s_value != 0
     end
-
   end
 end

data/lib/eth/open_ssl.rb

@@ -1,28 +1,22 @@
 # originally lifted from https://github.com/lian/bitcoin-ruby
 # thanks to everyone there for figuring this out
 
+# encoding: ascii-8bit
+
+require "openssl"
+require "ffi"
+
 module Eth
   class OpenSsl
     extend FFI::Library
 
-    if FFI::Platform.windows?
-      ffi_lib 'libeay32', 'ssleay32'
-    else
-      ffi_lib [
-        'libssl.so.1.1.0', 'libssl.so.1.1',
-        'libssl.so.1.0.0', 'libssl.so.10',
-        'ssl'
-      ]
-    end
+    # Use the library loaded by the extension require above.
+    ffi_lib FFI::CURRENT_PROCESS
 
     NID_secp256k1 = 714
     POINT_CONVERSION_COMPRESSED = 2
     POINT_CONVERSION_UNCOMPRESSED = 4
 
-    # OpenSSL 1.1.0 version as a numerical version value as defined in:
-    # https://www.openssl.org/docs/man1.1.0/man3/OpenSSL_version.html
-    VERSION_1_1_0_NUM = 0x10100000
-
     # OpenSSL 1.1.0 engine constants, taken from:
     # https://github.com/openssl/openssl/blob/2be8c56a39b0ec2ec5af6ceaf729df154d784a43/include/openssl/crypto.h
     OPENSSL_INIT_ENGINE_RDRAND = 0x00000200
@@ -30,13 +24,11 @@ module Eth
     OPENSSL_INIT_ENGINE_CRYPTODEV = 0x00001000
     OPENSSL_INIT_ENGINE_CAPI = 0x00002000
     OPENSSL_INIT_ENGINE_PADLOCK = 0x00004000
-    OPENSSL_INIT_ENGINE_ALL_BUILTIN = (
-      OPENSSL_INIT_ENGINE_RDRAND |
-      OPENSSL_INIT_ENGINE_DYNAMIC |
-      OPENSSL_INIT_ENGINE_CRYPTODEV |
-      OPENSSL_INIT_ENGINE_CAPI |
-      OPENSSL_INIT_ENGINE_PADLOCK
-    )
+    OPENSSL_INIT_ENGINE_ALL_BUILTIN = (OPENSSL_INIT_ENGINE_RDRAND |
+                                       OPENSSL_INIT_ENGINE_DYNAMIC |
+                                       OPENSSL_INIT_ENGINE_CRYPTODEV |
+                                       OPENSSL_INIT_ENGINE_CAPI |
+                                       OPENSSL_INIT_ENGINE_PADLOCK)
 
     # OpenSSL 1.1.0 load strings constant, taken from:
     # https://github.com/openssl/openssl/blob/c162c126be342b8cd97996346598ecf7db56130f/include/openssl/ssl.h
@@ -50,215 +42,354 @@ module Eth
       attach_function :SSLeay, [], :long
     end
 
-    # Returns the version of SSL present.
-    #
-    # @return [Integer] version number as an integer.
-    def self.version
-      if self.respond_to?(:OpenSSL_version_num)
-        OpenSSL_version_num()
-      else
-        SSLeay()
-      end
-    end
-
-    if version >= VERSION_1_1_0_NUM
+    begin
       # Initialization procedure for the library was changed in OpenSSL 1.1.0
       attach_function :OPENSSL_init_ssl, [:uint64, :pointer], :int
-    else
+    rescue FFI::NotFoundError
       attach_function :SSL_library_init, [], :int
       attach_function :ERR_load_crypto_strings, [], :void
       attach_function :SSL_load_error_strings, [], :void
     end
 
     attach_function :RAND_poll, [], :int
+
     attach_function :BN_CTX_free, [:pointer], :int
     attach_function :BN_CTX_new, [], :pointer
-    attach_function :BN_add, [:pointer, :pointer, :pointer], :int
-    attach_function :BN_bin2bn, [:pointer, :int, :pointer], :pointer
-    attach_function :BN_bn2bin, [:pointer, :pointer], :int
-    attach_function :BN_cmp, [:pointer, :pointer], :int
+    attach_function :BN_add, %i[pointer pointer pointer], :int
+    attach_function :BN_bin2bn, %i[pointer int pointer], :pointer
+    attach_function :BN_bn2bin, %i[pointer pointer], :int
+    attach_function :BN_cmp, %i[pointer pointer], :int
     attach_function :BN_dup, [:pointer], :pointer
     attach_function :BN_free, [:pointer], :int
-    attach_function :BN_mod_inverse, [:pointer, :pointer, :pointer, :pointer], :pointer
-    attach_function :BN_mod_mul, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
-    attach_function :BN_mod_sub, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
-    attach_function :BN_mul_word, [:pointer, :int], :int
+    attach_function :BN_mod_inverse, %i[pointer pointer pointer pointer], :pointer
+    attach_function :BN_mod_mul, %i[pointer pointer pointer pointer pointer], :int
+    attach_function :BN_mod_sub, %i[pointer pointer pointer pointer pointer], :int
+    attach_function :BN_mul_word, %i[pointer int], :int
     attach_function :BN_new, [], :pointer
-    attach_function :BN_num_bits, [:pointer], :int
-    attach_function :BN_rshift, [:pointer, :pointer, :int], :int
-    attach_function :BN_set_word, [:pointer, :int], :int
-    attach_function :ECDSA_SIG_free, [:pointer], :void
-    attach_function :ECDSA_do_sign, [:pointer, :uint, :pointer], :pointer
-    attach_function :EC_GROUP_get_curve_GFp, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :BN_rshift, %i[pointer pointer int], :int
+    attach_function :BN_rshift1, %i[pointer pointer], :int
+    attach_function :BN_set_word, %i[pointer int], :int
+    attach_function :BN_sub, %i[pointer pointer pointer], :int
+    attach_function :EC_GROUP_get_curve_GFp, %i[pointer pointer pointer pointer pointer], :int
     attach_function :EC_GROUP_get_degree, [:pointer], :int
-    attach_function :EC_GROUP_get_order, [:pointer, :pointer, :pointer], :int
+    attach_function :EC_GROUP_get_order, %i[pointer pointer pointer], :int
     attach_function :EC_KEY_free, [:pointer], :int
     attach_function :EC_KEY_get0_group, [:pointer], :pointer
+    attach_function :EC_KEY_get0_private_key, [:pointer], :pointer
     attach_function :EC_KEY_new_by_curve_name, [:int], :pointer
-    attach_function :EC_KEY_set_conv_form, [:pointer, :int], :void
-    attach_function :EC_KEY_set_private_key, [:pointer, :pointer], :int
-    attach_function :EC_KEY_set_public_key,  [:pointer, :pointer], :int
+    attach_function :EC_KEY_set_conv_form, %i[pointer int], :void
+    attach_function :EC_KEY_set_private_key, %i[pointer pointer], :int
+    attach_function :EC_KEY_set_public_key, %i[pointer pointer], :int
     attach_function :EC_POINT_free, [:pointer], :int
-    attach_function :EC_POINT_mul, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :EC_POINT_mul, %i[pointer pointer pointer pointer pointer pointer], :int
     attach_function :EC_POINT_new, [:pointer], :pointer
-    attach_function :EC_POINT_set_compressed_coordinates_GFp, [:pointer, :pointer, :pointer, :int, :pointer], :int
-    attach_function :i2o_ECPublicKey, [:pointer, :pointer], :uint
+    attach_function :EC_POINT_set_compressed_coordinates_GFp,
+                    %i[pointer pointer pointer int pointer], :int
+    attach_function :i2o_ECPublicKey, %i[pointer pointer], :uint
+    attach_function :ECDSA_do_sign, %i[pointer uint pointer], :pointer
+    attach_function :BN_num_bits, [:pointer], :int
+    attach_function :ECDSA_SIG_free, [:pointer], :void
+    attach_function :EC_POINT_add, %i[pointer pointer pointer pointer pointer], :int
+    attach_function :EC_POINT_point2hex, %i[pointer pointer int pointer], :string
+    attach_function :EC_POINT_hex2point, %i[pointer string pointer pointer], :pointer
+    attach_function :d2i_ECDSA_SIG, %i[pointer pointer long], :pointer
+    attach_function :i2d_ECDSA_SIG, %i[pointer pointer], :int
+    attach_function :OPENSSL_free, :CRYPTO_free, [:pointer], :void
+
+    def self.BN_num_bytes(ptr) # rubocop:disable Naming/MethodName
+      (BN_num_bits(ptr) + 7) / 8
+    end
 
-    class << self
-      def BN_num_bytes(ptr)
-        (BN_num_bits(ptr) + 7) / 8
+    # resolve public from private key, using ffi and libssl.so
+    # example:
+    #   keypair = Bitcoin.generate_key; Bitcoin::OpenSSL_EC.regenerate_key(keypair.first) == keypair
+    def self.regenerate_key(private_key)
+      private_key = [private_key].pack("H*") if private_key.bytesize >= (32 * 2)
+      private_key_hex = private_key.unpack("H*")[0]
+
+      group = OpenSSL::PKey::EC::Group.new("secp256k1")
+      key = OpenSSL::PKey::EC.new(group)
+      key.private_key = OpenSSL::BN.new(private_key_hex, 16)
+      key.public_key = group.generator.mul(key.private_key)
+
+      priv_hex = key.private_key.to_bn.to_s(16).downcase.rjust(64, "0")
+      if priv_hex != private_key_hex
+        raise "regenerated wrong private_key, raise here before generating a faulty public_key too!"
       end
 
-      def sign_compact(hash, private_key, public_key_hex)
-        private_key = [private_key].pack("H*") if private_key.bytesize >= 64
-        pubkey_compressed = false
+      [priv_hex, key.public_key.to_bn.to_s(16).downcase]
+    end
 
-        init_ffi_ssl
-        eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
-        priv_key = BN_bin2bn(private_key, private_key.bytesize, BN_new())
+    # Given the components of a signature and a selector value, recover and
+    # return the public key that generated the signature according to the
+    # algorithm in SEC1v2 section 4.1.6.
+    #
+    # rec_id is an index from 0 to 3 that indicates which of the 4 possible
+    # keys is the correct one. Because the key recovery operation yields
+    # multiple potential keys, the correct key must either be stored alongside
+    # the signature, or you must be willing to try each rec_id in turn until
+    # you find one that outputs the key you are expecting.
+    #
+    # If this method returns nil, it means recovery was not possible and rec_id
+    # should be iterated.
+    #
+    # Given the above two points, a correct usage of this method is inside a
+    # for loop from 0 to 3, and if the output is nil OR a key that is not the
+    # one you expect, you try again with the next rec_id.
+    #
+    #   message_hash = hash of the signed message.
+    #   signature = the R and S components of the signature, wrapped.
+    #   rec_id = which possible key to recover.
+    #   is_compressed = whether or not the original pubkey was compressed.
+    def self.recover_public_key_from_signature(message_hash, signature, rec_id, is_compressed)
+      return nil if rec_id < 0 || signature.bytesize != 65
+      init_ffi_ssl
+
+      signature = FFI::MemoryPointer.from_string(signature)
+      # signature_bn = BN_bin2bn(signature, 65, BN_new())
+      r = BN_bin2bn(signature[1], 32, BN_new())
+      s = BN_bin2bn(signature[33], 32, BN_new())
+
+      i = rec_id / 2
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+
+      EC_KEY_set_conv_form(eckey, POINT_CONVERSION_COMPRESSED) if is_compressed
+
+      group = EC_KEY_get0_group(eckey)
+      order = BN_new()
+      EC_GROUP_get_order(group, order, nil)
+      x = BN_dup(order)
+      BN_mul_word(x, i)
+      BN_add(x, x, r)
+
+      field = BN_new()
+      EC_GROUP_get_curve_GFp(group, field, nil, nil, nil)
+
+      if BN_cmp(x, field) >= 0
+        [r, s, order, x, field].each { |item| BN_free(item) }
+        EC_KEY_free(eckey)
+        return nil
+      end
 
-        group, order, ctx = EC_KEY_get0_group(eckey), BN_new(), BN_CTX_new()
-        EC_GROUP_get_order(group, order, ctx)
+      big_r = EC_POINT_new(group)
+      EC_POINT_set_compressed_coordinates_GFp(group, big_r, x, rec_id % 2, nil)
+
+      big_q = EC_POINT_new(group)
+      n = EC_GROUP_get_degree(group)
+      e = BN_bin2bn(message_hash, message_hash.bytesize, BN_new())
+      BN_rshift(e, e, 8 - (n & 7)) if 8 * message_hash.bytesize > n
+
+      ctx = BN_CTX_new()
+      zero = BN_new()
+      rr = BN_new()
+      sor = BN_new()
+      eor = BN_new()
+      BN_set_word(zero, 0)
+      BN_mod_sub(e, zero, e, order, ctx)
+      BN_mod_inverse(rr, r, order, ctx)
+      BN_mod_mul(sor, s, rr, order, ctx)
+      BN_mod_mul(eor, e, rr, order, ctx)
+      EC_POINT_mul(group, big_q, eor, big_r, sor, ctx)
+      EC_KEY_set_public_key(eckey, big_q)
+      BN_CTX_free(ctx)
+
+      [r, s, order, x, field, e, zero, rr, sor, eor].each { |item| BN_free(item) }
+      [big_r, big_q].each { |item| EC_POINT_free(item) }
+
+      length = i2o_ECPublicKey(eckey, nil)
+      buf = FFI::MemoryPointer.new(:uint8, length)
+      ptr = FFI::MemoryPointer.new(:pointer).put_pointer(0, buf)
+      pub_hex = buf.read_string(length).unpack("H*")[0] if i2o_ECPublicKey(eckey, ptr) == length
+
+      EC_KEY_free(eckey)
+
+      pub_hex
+    end
 
-        pub_key = EC_POINT_new(group)
-        EC_POINT_mul(group, pub_key, priv_key, nil, nil, ctx)
-        EC_KEY_set_private_key(eckey, priv_key)
-        EC_KEY_set_public_key(eckey, pub_key)
+    # Regenerate a DER-encoded signature such that the S-value complies with the BIP62
+    # specification.
+    #
+    def self.signature_to_low_s(signature)
+      init_ffi_ssl
+
+      buf = FFI::MemoryPointer.new(:uint8, 34)
+      temp = signature.unpack("C*")
+      length_r = temp[3]
+      length_s = temp[5 + length_r]
+      sig = FFI::MemoryPointer.from_string(signature)
+
+      # Calculate the lower s value
+      s = BN_bin2bn(sig[6 + length_r], length_s, BN_new())
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+      group = EC_KEY_get0_group(eckey)
+      order = BN_new()
+      halforder = BN_new()
+      ctx = BN_CTX_new()
+
+      EC_GROUP_get_order(group, order, ctx)
+      BN_rshift1(halforder, order)
+      BN_sub(s, order, s) if BN_cmp(s, halforder) > 0
+
+      BN_free(halforder)
+      BN_free(order)
+      BN_CTX_free(ctx)
+
+      length_s = BN_bn2bin(s, buf)
+      # p buf.read_string(length_s).unpack("H*")
+
+      # Re-encode the signature in DER format
+      sig = [0x30, 0, 0x02, length_r]
+      sig.concat(temp.slice(4, length_r))
+      sig << 0x02
+      sig << length_s
+      sig.concat(buf.read_string(length_s).unpack("C*"))
+      sig[1] = sig.size - 2
+
+      BN_free(s)
+      EC_KEY_free(eckey)
+
+      sig.pack("C*")
+    end
 
-        signature = ECDSA_do_sign(hash, hash.bytesize, eckey)
+    def self.sign_compact(hash, private_key, public_key_hex = nil, pubkey_compressed = nil)
+      msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hash)
 
-        BN_free(order)
-        BN_CTX_free(ctx)
-        EC_POINT_free(pub_key)
-        BN_free(priv_key)
-        EC_KEY_free(eckey)
+      private_key = [private_key].pack("H*") if private_key.bytesize >= 64
+      private_key_hex = private_key.unpack("H*")[0]
 
-        buf, rec_id, head = FFI::MemoryPointer.new(:uint8, 32), nil, nil
-        r, s = signature.get_array_of_pointer(0, 2).map{|i| BN_bn2bin(i, buf); buf.read_string(BN_num_bytes(i)).rjust(32, "\x00") }
+      public_key_hex ||= regenerate_key(private_key_hex).last
+      pubkey_compressed ||= public_key_hex[0..1] != "04"
 
-        if signature.get_array_of_pointer(0, 2).all?{|i| BN_num_bits(i) <= 256 }
-          4.times{|i|
-            head = [ Eth.v_base + i ].pack("C")
-            if public_key_hex == recover_public_key_from_signature(hash, [head, r, s].join, i, pubkey_compressed)
-              rec_id = i; break
-            end
-          }
-        end
+      init_ffi_ssl
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+      priv_key = BN_bin2bn(private_key, private_key.bytesize, BN_new())
 
-        ECDSA_SIG_free(signature)
+      group = EC_KEY_get0_group(eckey)
+      order = BN_new()
+      ctx = BN_CTX_new()
+      EC_GROUP_get_order(group, order, ctx)
 
-        [ head, [r,s] ].join if rec_id
-      end
+      pub_key = EC_POINT_new(group)
+      EC_POINT_mul(group, pub_key, priv_key, nil, nil, ctx)
+      EC_KEY_set_private_key(eckey, priv_key)
+      EC_KEY_set_public_key(eckey, pub_key)
 
-      def recover_public_key_from_signature(message_hash, signature, rec_id, is_compressed)
-        return nil if rec_id < 0 or signature.bytesize != 65
-        init_ffi_ssl
+      signature = ECDSA_do_sign(msg32, msg32.size, eckey)
 
-        signature = FFI::MemoryPointer.from_string(signature)
-        r = BN_bin2bn(signature[1], 32, BN_new())
-        s = BN_bin2bn(signature[33], 32, BN_new())
+      BN_free(order)
+      BN_CTX_free(ctx)
+      EC_POINT_free(pub_key)
+      BN_free(priv_key)
+      EC_KEY_free(eckey)
 
-        _n, i = 0, rec_id / 2
-        eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+      buf = FFI::MemoryPointer.new(:uint8, 32)
+      head = nil
+      r, s = signature.get_array_of_pointer(0, 2).map do |i|
+        BN_bn2bin(i, buf)
+        buf.read_string(BN_num_bytes(i)).rjust(32, "\x00")
+      end
 
-        EC_KEY_set_conv_form(eckey, POINT_CONVERSION_COMPRESSED) if is_compressed
+      rec_id = nil
+      if signature.get_array_of_pointer(0, 2).all? { |i| BN_num_bits(i) <= 256 }
+        4.times do |i|
+          head = [27 + i + (pubkey_compressed ? 4 : 0)].pack("C")
+          recovered_key = recover_public_key_from_signature(
+            msg32.read_string(32), [head, r, s].join, i, pubkey_compressed
+          )
+          if public_key_hex == recovered_key
+            rec_id = i
+            break
+          end
+        end
+      end
 
-        group = EC_KEY_get0_group(eckey)
-        order = BN_new()
-        EC_GROUP_get_order(group, order, nil)
-        x = BN_dup(order)
-        BN_mul_word(x, i)
-        BN_add(x, x, r)
+      ECDSA_SIG_free(signature)
 
-        field = BN_new()
-        EC_GROUP_get_curve_GFp(group, field, nil, nil, nil)
+      [head, [r, s]].join if rec_id
+    end
 
-        if BN_cmp(x, field) >= 0
-          bn_free_each r, s, order, x, field
-          EC_KEY_free(eckey)
-          return nil
-        end
+    def self.recover_compact(hash, signature)
+      return false if signature.bytesize != 65
+      msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hash)
+
+      version = signature.unpack("C")[0]
 
-        big_r = EC_POINT_new(group)
-        EC_POINT_set_compressed_coordinates_GFp(group, big_r, x, rec_id % 2, nil)
-
-        big_q = EC_POINT_new(group)
-        n = EC_GROUP_get_degree(group)
-        e = BN_bin2bn(message_hash, message_hash.bytesize, BN_new())
-        BN_rshift(e, e, 8 - (n & 7)) if 8 * message_hash.bytesize > n
-
-        ctx = BN_CTX_new()
-        zero, rr, sor, eor = BN_new(), BN_new(), BN_new(), BN_new()
-        BN_set_word(zero, 0)
-        BN_mod_sub(e, zero, e, order, ctx)
-        BN_mod_inverse(rr, r, order, ctx)
-        BN_mod_mul(sor, s, rr, order, ctx)
-        BN_mod_mul(eor, e, rr, order, ctx)
-        EC_POINT_mul(group, big_q, eor, big_r, sor, ctx)
-        EC_KEY_set_public_key(eckey, big_q)
-        BN_CTX_free(ctx)
-
-        bn_free_each r, s, order, x, field, e, zero, rr, sor, eor
-        [big_r, big_q].each{|j| EC_POINT_free(j) }
-
-        recover_public_hex eckey
+      # Version of signature should be 27 or 28, but 0 and 1 are also possible versions
+      # which can show up in Ledger hardwallet signings
+      if version < 27
+        version += 27
       end
 
-      def recover_compact(hash, signature)
-        return false if signature.bytesize != 65
+      return false if version < 27 || version > 34
 
-        version = signature.unpack('C')[0]
+      compressed = version >= 31
+      version -= 4 if compressed
 
-        # Version of signature should be 27 or 28, but 0 and 1 are also possible versions
-        # which can show up in Ledger hardwallet signings
-        if version < 27
-          version += 27
-        end
+      recover_public_key_from_signature(msg32.read_string(32), signature, version - 27, compressed)
+    end
 
-        v_base = Eth.replayable_v?(version) ? Eth.replayable_chain_id : Eth.v_base
+    # lifted from https://github.com/GemHQ/money-tree
+    def self.ec_add(point0, point1)
+      init_ffi_ssl
 
-        return false if version < v_base
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+      group = EC_KEY_get0_group(eckey)
 
-        recover_public_key_from_signature(hash, signature, (version - v_base), false)
-      end
+      point_0_hex = point0.to_bn.to_s(16)
+      point_0_pt = EC_POINT_hex2point(group, point_0_hex, nil, nil)
+      point_1_hex = point1.to_bn.to_s(16)
+      point_1_pt = EC_POINT_hex2point(group, point_1_hex, nil, nil)
 
-      def init_ffi_ssl
-        return if @ssl_loaded
-        if version >= VERSION_1_1_0_NUM
-          OPENSSL_init_ssl(
-            OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_ENGINE_ALL_BUILTIN,
-            nil
-          )
-        else
-          SSL_library_init()
-          ERR_load_crypto_strings()
-          SSL_load_error_strings()
-        end
+      sum_point = EC_POINT_new(group)
+      EC_POINT_add(group, sum_point, point_0_pt, point_1_pt, nil)
+      hex = EC_POINT_point2hex(group, sum_point, POINT_CONVERSION_UNCOMPRESSED, nil)
+      EC_KEY_free(eckey)
+      EC_POINT_free(sum_point)
+      hex
+    end
 
-        RAND_poll()
-        @ssl_loaded = true
-      end
+    # repack signature for OpenSSL 1.0.1k handling of DER signatures
+    # https://github.com/bitcoin/bitcoin/pull/5634/files
+    def self.repack_der_signature(signature)
+      init_ffi_ssl
 
+      return false if signature.empty?
 
-      private
+      # New versions of OpenSSL will reject non-canonical DER signatures. de/re-serialize first.
+      norm_der = FFI::MemoryPointer.new(:pointer)
+      sig_ptr = FFI::MemoryPointer.new(:pointer).put_pointer(
+        0, FFI::MemoryPointer.from_string(signature)
+      )
 
-      def bn_free_each(*list)
-        list.each{|j| BN_free(j) }
-      end
+      norm_sig = d2i_ECDSA_SIG(nil, sig_ptr, signature.bytesize)
 
-      def recover_public_hex(eckey)
-        length = i2o_ECPublicKey(eckey, nil)
-        buf = FFI::MemoryPointer.new(:uint8, length)
-        ptr = FFI::MemoryPointer.new(:pointer).put_pointer(0, buf)
-        pub_hex = if i2o_ECPublicKey(eckey, ptr) == length
-          buf.read_string(length).unpack("H*")[0]
-        end
+      derlen = i2d_ECDSA_SIG(norm_sig, norm_der)
+      ECDSA_SIG_free(norm_sig)
+      return false if derlen <= 0
 
-        EC_KEY_free(eckey)
+      ret = norm_der.read_pointer.read_string(derlen)
+      OPENSSL_free(norm_der.read_pointer)
 
-        pub_hex
-      end
+      ret
     end
 
+    def self.init_ffi_ssl
+      @ssl_loaded ||= false
+      return if @ssl_loaded
+
+      if self.method_defined?(:OPENSSL_init_ssl)
+        OPENSSL_init_ssl(
+          OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_ENGINE_ALL_BUILTIN,
+          nil
+        )
+      else
+        SSL_library_init()
+        ERR_load_crypto_strings()
+        SSL_load_error_strings()
+      end
+
+      RAND_poll()
+      @ssl_loaded = true
+    end
   end
 end

data/lib/eth/secp256k1.rb

@@ -1,7 +1,5 @@
 module Eth
   class Secp256k1
-
     N = 115792089237316195423570985008687907852837564279074904382605163141518161494337
-
   end
 end

data/lib/eth/sedes.rb

@@ -35,6 +35,5 @@ module Eth
     def binary
       RLP::Sedes.binary
     end
-
   end
 end

data/lib/eth/tx.rb

@@ -1,6 +1,5 @@
 module Eth
   class Tx
-
     include RLP::Sedes::Serializable
     extend Sedes
 
@@ -13,7 +12,7 @@ module Eth
       data_bin: binary,
       v: big_endian_int,
       r: big_endian_int,
-      s: big_endian_int
+      s: big_endian_int,
     })
 
     attr_writer :signature
@@ -28,7 +27,7 @@ module Eth
     end
 
     def initialize(params)
-      fields = {v: 0, r: 0, s: 0}.merge params
+      fields = { v: 0, r: 0, s: 0 }.merge params
       fields[:to] = Utils.normalize_address(fields[:to])
 
       self.chain_id = (params[:chain_id]) ? params.delete(:chain_id) : Eth.chain_id
@@ -105,6 +104,7 @@ module Eth
     def hash
       "0x#{Utils.bin_to_hex Utils.keccak256_rlp(self)}"
     end
+
     alias_method :id, :hash
 
     def data_hex
@@ -120,7 +120,7 @@ module Eth
     end
 
     def data=(string)
-      Eth.tx_data_hex? ? self.data_hex=(string) : self.data_bin=(string)
+      Eth.tx_data_hex? ? self.data_hex = (string) : self.data_bin = (string)
     end
 
     def chain_id
@@ -190,7 +190,6 @@ module Eth
         UnsignedTx
       end
     end
-
   end
 
   UnsignedTx = Tx.exclude([:v, :r, :s])

data/lib/eth/utils.rb

@@ -3,11 +3,11 @@ module Eth
     extend self
 
     def normalize_address(address)
-      if address.nil? || address == ''
-        ''
+      if address.nil? || address == ""
+        ""
       elsif address.size == 40
         hex_to_bin address
-      elsif address.size == 42 && address[0..1] == '0x'
+      elsif address.size == 42 && address[0..1] == "0x"
         hex_to_bin address[2..-1]
       else
         address
@@ -23,7 +23,7 @@ module Eth
     end
 
     def base256_to_int(str)
-      RLP::Sedes.big_endian_int.deserialize str.sub(/\A(\x00)+/, '')
+      RLP::Sedes.big_endian_int.deserialize str.sub(/\A(\x00)+/, "")
     end
 
     def int_to_base256(int)
@@ -43,7 +43,7 @@ module Eth
     end
 
     def remove_hex_prefix(s)
-      s[0,2] == '0x' ? s[2..-1] : s
+      s[0, 2] == "0x" ? s[2..-1] : s
     end
 
     def bin_to_prefixed_hex(binary)
@@ -89,14 +89,14 @@ module Eth
     end
 
     def zunpad(x)
-      x.sub(/\A\x00+/, '')
+      x.sub(/\A\x00+/, "")
     end
 
-    def zpad_int(n, l=32)
+    def zpad_int(n, l = 32)
       zpad encode_int(n), l
     end
 
-    def zpad_hex(s, l=32)
+    def zpad_hex(s, l = 32)
       zpad decode_hex(s), l
     end
 
@@ -108,8 +108,6 @@ module Eth
       Address.new(address).checksummed
     end
 
-
-
     private
 
     def lpad(x, symbol, l)
@@ -124,6 +122,5 @@ module Eth
 
       int_to_base256 n
     end
-
   end
 end

data/lib/eth/version.rb

@@ -1,3 +1,3 @@
 module Eth
-  VERSION = "0.4.17"
+  VERSION = "0.4.18"
 end

data/lib/eth.rb

@@ -1,20 +1,20 @@
-require 'digest/keccak'
-require 'ffi'
-require 'money-tree'
-require 'rlp'
+require "digest/keccak"
+require "ffi"
+require "money-tree"
+require "rlp"
 
 module Eth
   BYTE_ZERO = "\x00".freeze
-  UINT_MAX = 2**256 - 1
+  UINT_MAX = 2 ** 256 - 1
 
-  autoload :Address, 'eth/address'
-  autoload :Gas, 'eth/gas'
-  autoload :Key, 'eth/key'
-  autoload :OpenSsl, 'eth/open_ssl'
-  autoload :Secp256k1, 'eth/secp256k1'
-  autoload :Sedes, 'eth/sedes'
-  autoload :Tx, 'eth/tx'
-  autoload :Utils, 'eth/utils'
+  autoload :Address, "eth/address"
+  autoload :Gas, "eth/gas"
+  autoload :Key, "eth/key"
+  autoload :OpenSsl, "eth/open_ssl"
+  autoload :Secp256k1, "eth/secp256k1"
+  autoload :Sedes, "eth/sedes"
+  autoload :Tx, "eth/tx"
+  autoload :Utils, "eth/utils"
 
   class << self
     def configure

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eth
 version: !ruby/object:Gem::Version
-  version: 0.4.17
+  version: 0.4.18
 platform: ruby
 authors:
 - Steve Ellis
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-01 00:00:00.000000000 Z
+date: 2022-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: keccak
@@ -45,14 +45,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rlp
   requirement: !ruby/object:Gem::Requirement
@@ -147,6 +161,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/build.yml"
 - ".github/workflows/codeql.yml"
+- ".github/workflows/docs.yml"
 - ".gitignore"
 - ".gitmodules"
 - ".rspec"
@@ -186,7 +201,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.6'
   - - "<"
     - !ruby/object:Gem::Version
       version: '4.0'
@@ -196,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.31
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Simple API to sign Ethereum transactions.