bitcoin-ruby 0.0.18 → 0.0.19

data/spec/unit/bitcoin/contracthash_spec.rb

@@ -0,0 +1,52 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# https://github.com/aalness/contracthashtool-ruby
+# ruby port of https://github.com/Blockstream/contracthashtool
+describe 'Bitcoin::ContractHash' do
+  it 'should generate and claim' do
+    Bitcoin.network = :testnet3
+
+    # Example parameters from the original tool's usage().
+    redeem_script_template = '5121038695b28f1649c711aedb1fec8df54874334cfb7d' \
+                             'df31ba3132a94d00bdc9715251ae'
+    payee_address = 'mqWkEAFeQdrQvyaWNRn5vijPJeiQAjtxL2'
+    nonce_hex = '3a11be476485a6273fad4a0e09117d42'
+    private_key_wif = 'cMcpaCT6pHkyS4347i4rSmecaQtLiu1eH28NWmBiePn8bi6N4kzh'
+
+    # Someone wanting to send funds to the sidechain would call this to
+    # calculate a P2SH address to send to. They would then send the MDFs
+    # (mutually distrusting functionaries) the target address and nonce so they
+    # are able to locate the subsequent transaction.  The caller would then send
+    # the desired amount of coin to the P2SH address to initiate the peg
+    # protocol.
+    nonce, redeem_script, p2sh_address = Bitcoin::ContractHash.generate(
+      redeem_script_template, payee_address, nonce_hex
+    )
+
+    expect(nonce).to eq('3a11be476485a6273fad4a0e09117d42')
+    expect(p2sh_address).to eq('2MvGPFfDXbJZyH79u187VNZbuCgyRBhcdsw')
+    expect(redeem_script)
+      .to eq('512102944aba05d40d8df1724f8ab2f5f3a58d052d26aedc93e175534cb782b' \
+             'ecc8ff751ae')
+
+    # Each MDF would call this to derive a private key to redeem the locked
+    # transaction.
+    key = Bitcoin::ContractHash.claim(
+      private_key_wif, payee_address, nonce
+    )
+    expect(key.to_base58)
+      .to eq('cSBD8yM62R82RfbugiGK8Lui9gdMB81NtZBckxe5YxRsDSKySwHK')
+
+    # Verify homomorphic derivation was successful.
+    message = 'derp'
+    signature = key.sign_message(message)
+    script = Bitcoin::Script.new([redeem_script].pack('H*'))
+    pubkey = Bitcoin::Key.new(
+      nil, script.get_multisig_pubkeys.first.unpack('H*').first
+    )
+    expect(pubkey.verify_message(signature, message)).to be true
+  end
+end

data/spec/unit/bitcoin/ext_key_spec.rb

@@ -0,0 +1,281 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# BIP-32 test
+# https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#Test_Vectors
+describe Bitcoin::ExtKey do
+  describe 'Test Vector 1' do
+    let(:master_key) do
+      Bitcoin::ExtKey.generate_master('000102030405060708090a0b0c0d0e0f'.htb)
+    end
+
+    it 'Chain m' do
+      expect(master_key.depth).to eq(0)
+      expect(master_key.number).to eq(0)
+      expect(master_key.fingerprint).to eq('3442193e')
+      expect(master_key.chain_code.bth)
+        .to eq('873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508')
+      expect(master_key.priv)
+        .to eq('e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35')
+      expect(master_key.addr).to eq('15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma')
+      expect(master_key.pub)
+        .to eq('0339a36013301597daef41fbe593a02cc513d0b55527ec2df1050e2e8ff49c85c2')
+      expect(master_key.to_base58)
+        .to eq('xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiCh' \
+               'kVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi')
+      expect(master_key.ext_pubkey.to_base58)
+        .to eq('xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ' \
+               '29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8')
+      expect(master_key.ext_pubkey.pub)
+        .to eq('0339a36013301597daef41fbe593a02cc513d0b55527ec2df1050e2e8ff49c85c2')
+      expect(master_key.ext_pubkey.addr)
+        .to eq('15mKKb2eos1hWa6tisdPwwDC1a5J1y9nma')
+    end
+
+    it 'Chain m/0H' do
+      key = master_key.derive(2**31)
+      expect(key.depth).to eq(1)
+      expect(key.fingerprint).to eq('5c1bd648')
+      expect(key.chain_code.bth)
+        .to eq('47fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad16282c7ae6236141')
+      expect(key.priv_key.priv)
+        .to eq('edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d911a0afea')
+      expect(key.to_base58)
+        .to eq('xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4c' \
+               'V1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6' \
+               'LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw')
+    end
+
+    it 'Chain m/0H/1' do
+      key = master_key.derive(2**31).derive(1)
+      expect(key.depth).to eq(2)
+      expect(key.fingerprint).to eq('bef5a2f9')
+      expect(key.chain_code.bth)
+        .to eq('2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19')
+      expect(key.priv_key.priv)
+        .to eq('3c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de9319dc93368')
+      expect(key.to_base58)
+        .to eq('xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxq' \
+               'u53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHK' \
+               'kNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ')
+
+      # pubkey derivation
+      ext_pubkey = master_key.derive(2**31).ext_pubkey.derive(1)
+      expect(ext_pubkey.to_base58)
+        .to eq('xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHK' \
+               'kNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ')
+    end
+
+    it 'Chain m/0H/1/2H' do
+      key = master_key.derive(2**31).derive(1).derive(2**31 + 2)
+      expect(key.depth).to eq(3)
+      expect(key.fingerprint).to eq('ee7ab90c')
+      expect(key.chain_code.bth)
+        .to eq('04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f')
+      expect(key.priv_key.priv)
+        .to eq('cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59fa424dca')
+      expect(key.to_base58)
+        .to eq('xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT' \
+               '7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJ' \
+               'PMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5')
+    end
+
+    it 'Chain m/0H/1/2H/2' do
+      key = master_key.derive(2**31).derive(1).derive(2**31 + 2).derive(2)
+      expect(key.depth).to eq(4)
+      expect(key.fingerprint).to eq('d880d7d8')
+      expect(key.chain_code.bth)
+        .to eq('cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac1275ac822a3edd')
+      expect(key.priv_key.priv)
+        .to eq('0f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a2a764ef4')
+      expect(key.to_base58)
+        .to eq('xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8' \
+               'RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAy' \
+               'iLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV')
+    end
+
+    it 'Chain m/0H/1/2H/2/1000000000' do
+      key = master_key
+            .derive(2**31).derive(1).derive(2**31 + 2).derive(2)
+            .derive(1_000_000_000)
+      expect(key.depth).to eq(5)
+      expect(key.fingerprint).to eq('d69aa102')
+      expect(key.chain_code.bth)
+        .to eq('c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548a8b078e65e9e')
+      expect(key.priv_key.priv)
+        .to eq('471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6c3e6e7c8')
+      expect(key.to_base58)
+        .to eq('xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8k' \
+               'mHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTE' \
+               'cYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy')
+    end
+  end
+
+  describe 'Test Vector 2' do
+    let(:master_key) do
+      Bitcoin::ExtKey.generate_master(
+        'fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c' \
+        '999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542'.htb
+      )
+    end
+
+    it 'Chain m' do
+      expect(master_key.depth).to eq(0)
+      expect(master_key.number).to eq(0)
+      expect(master_key.to_base58)
+        .to eq('xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3' \
+               'pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U')
+      expect(master_key.ext_pubkey.to_base58)
+        .to eq('xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu' \
+               '8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB')
+    end
+
+    it 'Chain m/0' do
+      key = master_key.derive(0)
+      expect(key.depth).to eq(1)
+      expect(key.number).to eq(0)
+      expect(key.to_base58)
+        .to eq('xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3d' \
+               'KYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXU' \
+               'bC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH')
+    end
+
+    it 'Chain m/0/2147483647H' do
+      key = master_key.derive(0).derive(2**31 + 2_147_483_647)
+      expect(key.depth).to eq(2)
+      expect(key.number).to eq(2**31 + 2_147_483_647)
+      expect(key.to_base58)
+        .to eq('xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeE' \
+               'g2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85' \
+               'ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a')
+    end
+
+    it 'Chain m/0/2147483647H/1' do
+      key = master_key.derive(0).derive(2**31 + 2_147_483_647).derive(1)
+      expect(key.depth).to eq(3)
+      expect(key.number).to eq(1)
+      expect(key.to_base58)
+        .to eq('xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25' \
+               'UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVv' \
+               'mdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon')
+    end
+
+    it 'Chain m/0/2147483647H/1/2147483646H' do
+      key =
+        master_key
+        .derive(0).derive(2**31 + 2_147_483_647).derive(1)
+        .derive(2**31 + 2_147_483_646)
+      expect(key.depth).to eq(4)
+      expect(key.number).to eq(2**31 + 2_147_483_646)
+      expect(key.to_base58)
+        .to eq('xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7i' \
+               'Axn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZ' \
+               'RkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL')
+    end
+
+    it 'Chain m/0/2147483647H/1/2147483646H/2' do
+      key = master_key
+            .derive(0).derive(2**31 + 2_147_483_647).derive(1)
+            .derive(2**31 + 2_147_483_646).derive(2)
+      expect(key.depth).to eq(5)
+      expect(key.number).to eq(2)
+      expect(key.to_base58)
+        .to eq('xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7n' \
+               'adnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbd' \
+               'pq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt')
+
+      ext_pubkey = master_key
+                   .derive(0).derive(2**31 + 2_147_483_647).derive(1)
+                   .derive(2**31 + 2_147_483_646).ext_pubkey.derive(2)
+      expect(ext_pubkey.to_base58)
+        .to eq('xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbd' \
+               'pq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt')
+    end
+  end
+
+  describe 'import from base58 address' do
+    it 'import private key' do
+      # normal key
+      key = Bitcoin::ExtKey.from_base58(
+        'xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1Um' \
+        'YPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs'
+      )
+      expect(key.depth).to eq(2)
+      expect(key.number).to eq(1)
+      expect(key.chain_code.bth)
+        .to eq('2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19')
+      expect(key.priv_key.priv)
+        .to eq('3c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de9319dc93368')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKk' \
+               'NAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ')
+
+      # hardended key
+      key = Bitcoin::ExtKey.from_base58(
+        'xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG' \
+        '3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM'
+      )
+      expect(key.depth).to eq(3)
+      expect(key.number).to eq(2**31 + 2)
+      expect(key.fingerprint).to eq('ee7ab90c')
+      expect(key.chain_code.bth)
+        .to eq('04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f')
+      expect(key.priv_key.priv)
+        .to eq('cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59fa424dca')
+      expect(key.to_base58)
+        .to eq('xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT' \
+               '7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM')
+      expect(key.ext_pubkey.to_base58)
+        .to eq('xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJ' \
+               'PMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5')
+    end
+
+    it 'import public key' do
+      # normal key
+      key = Bitcoin::ExtPubkey.from_base58(
+        'xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMi' \
+        'Gj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ'
+      )
+      expect(key.depth).to eq(2)
+      expect(key.number).to eq(1)
+      expect(key.chain_code.bth)
+        .to eq('2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19')
+      expect(key.to_base58)
+        .to eq('xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKk' \
+               'NAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ')
+
+      # hardended key
+      key = Bitcoin::ExtPubkey.from_base58(
+        'xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2' \
+        'dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5'
+      )
+      expect(key.depth).to eq(3)
+      expect(key.number).to eq(2**31 + 2)
+      expect(key.fingerprint).to eq('ee7ab90c')
+      expect(key.chain_code.bth)
+        .to eq('04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f')
+    end
+  end
+end

data/spec/unit/bitcoin/key_spec.rb

@@ -0,0 +1,457 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Bitcoin::Key do
+  let(:key_data) do
+    {
+      priv: '2ebd3738f59ae4fd408d717bf325b4cb979a409b0153f6d3b4b91cdfe046fb1e',
+      pub: '035fcb2fb2802b024f371cc22bc392268cc579e47e7936e0d1f05064e6e1103b8a'
+    }
+  end
+  let(:key) do
+    Bitcoin::Key.new(key_data[:priv], key_data[:pub], false)
+  end
+
+  it 'should generate a key' do
+    k = Bitcoin::Key.generate
+    expect(k.priv.size).to eq(64)
+    expect(k.pub.size).to eq(66)
+    expect(k.compressed).to be true
+
+    k = Bitcoin::Key.generate(compressed: true)
+    expect(k.priv.size).to eq(64)
+    expect(k.pub.size).to eq(66)
+    expect(k.compressed).to be true
+
+    k = Bitcoin::Key.generate(true)
+    expect(k.priv.size).to eq(64)
+    expect(k.pub.size).to eq(66)
+    expect(k.compressed).to be true
+
+    k = Bitcoin::Key.generate(compressed: false)
+    expect(k.priv.size).to eq(64)
+    expect(k.pub.size).to eq(130)
+    expect(k.compressed).to be false
+
+    k = Bitcoin::Key.generate(false)
+    expect(k.priv.size).to eq(64)
+    expect(k.pub.size).to eq(130)
+    expect(k.compressed).to be false
+  end
+
+  it 'should create empty key' do
+    k = Bitcoin::Key.new
+    expect(k.priv).to be_nil
+    expect(k.pub).to be_nil
+    expect(k.compressed).to be true
+  end
+
+  it 'should create key from priv + pub' do
+    k = Bitcoin::Key.new(key_data[:priv], key_data[:pub])
+    expect(k.priv).to eq(key_data[:priv])
+    expect(k.pub).to eq(key_data[:pub])
+  end
+
+  it 'should create key from only priv' do
+    k = Bitcoin::Key.new(key_data[:priv])
+    expect(k.priv).to eq(key_data[:priv])
+    expect(k.pub).to eq(key_data[:pub])
+  end
+
+  it 'should create key from only pub' do
+    k = Bitcoin::Key.new(nil, key_data[:pub])
+    expect(k.pub).to eq(key_data[:pub])
+  end
+
+  it 'should set public key' do
+    k = Bitcoin::Key.new
+    k.pub = key_data[:pub]
+    expect(k.pub).to eq(key_data[:pub])
+  end
+
+  it 'should set private key' do
+    k = Bitcoin::Key.new
+    k.priv = key_data[:priv]
+    expect(k.priv).to eq(key_data[:priv])
+    expect(k.pub).to eq(key_data[:pub])
+  end
+
+  it 'should get addr' do
+    expect(key.addr).to eq('19CyxBz6CUBogxTdSXUrbRHo7T7eLCMgbr')
+    key.instance_eval { @pubkey_compressed = false }
+    expect(key.addr).to eq('1JbYZRKyysprVjSSBobs8LX6QVjzsscQNU')
+  end
+
+  it 'should sign data' do
+    expect(key.sign('foobar').size).to be >= 69
+  end
+
+  it 'should verify signature using public key' do
+    sig = key.sign('foobar')
+    new_key = Bitcoin::Key.new(nil, key.pub)
+    expect(new_key.verify('foobar', sig)).to be true
+  end
+
+  it 'should verify signature using private key' do
+    sig = key.sign('foobar')
+    new_key = Bitcoin::Key.new(key.priv)
+    expect(new_key.verify('foobar', sig)).to be true
+  end
+
+  it 'recovers public keys from compact signatures' do
+    tests = [
+      # normal
+      {
+        address: '16vqGo3KRKE9kTsTZxKoJKLzwZGTodK3ce',
+        signature: 'HPDs1TesA48a9up4QORIuub67VHBM37X66skAYz0Esg23gdfMuCTYDF' \
+                   'ORc6XGpKZ2/flJ2h/DUF569FJxGoVZ50=',
+        message: 'test message',
+        expected: true
+      },
+      # different message
+      {
+        address: '16vqGo3KRKE9kTsTZxKoJKLzwZGTodK3ce',
+        signature: 'HPDs1TesA48a9up4QORIuub67VHBM37X66skAYz0Esg23gdfMuCTYDF' \
+                   'ORc6XGpKZ2/flJ2h/DUF569FJxGoVZ50=',
+        message: 'not what I signed',
+        expected: false
+      },
+      # different address
+      {
+        address: '1JbYZRKyysprVjSSBobs8LX6QVjzsscQNU',
+        signature: 'HPDs1TesA48a9up4QORIuub67VHBM37X66skAYz0Esg23gdfMuCTYDF' \
+                   'ORc6XGpKZ2/flJ2h/DUF569FJxGoVZ50=',
+        message: 'test message',
+        expected: false
+      },
+      # compressed
+      {
+        address: '18uitB5ARAhyxmkN2Sa9TbEuoGN1he83BX',
+        signature: 'IMAtT1SjRyP6bz6vm5tKDTTTNYS6D8w2RQQyKD3VGPq2i2txGd2ar18' \
+                   'L8/nvF1+kAMo5tNc4x0xAOGP0HRjKLjc=',
+        message: 'testtest',
+        expected: true
+      }
+    ]
+
+    tests.each do |test|
+      key = Bitcoin::Key.recover_compact_signature_to_key(
+        test[:message], test[:signature]
+      )
+      expect(key.addr == test[:address]).to eq(test[:expected])
+    end
+  end
+
+  it 'should export private key in base58 format' do
+    Bitcoin.network = :bitcoin
+    str = Bitcoin::Key.new(
+      'e9873d79c6d87dc0fb6a5778633389f4453213303da61f20bd67fc233aa33262',
+      nil,
+      false
+    ).to_base58
+    expect(str).to eq('5Kb8kLf9zgWQnogidDA76MzPL6TsZZY36hWXMssSzNydYXYB9KF')
+
+    Bitcoin.network = :testnet
+    str = Bitcoin::Key.new(
+      'd21fa2c7ad710ffcd9bcc22a9f96357bda1a2521ca7181dd610140ecea2cecd8',
+      nil,
+      false
+    ).to_base58
+    expect(str).to eq('93BTVFoqffueSaC5fqjLjLyn29S41JzvAZm2hC35SYMoYDXT1bY')
+  end
+
+  it 'should import private key in base58 format' do
+    Bitcoin.network = :bitcoin
+    key = Bitcoin::Key.from_base58(
+      '5Kb8kLf9zgWQnogidDA76MzPL6TsZZY36hWXMssSzNydYXYB9KF'
+    )
+    expect(key.priv)
+      .to eq('e9873d79c6d87dc0fb6a5778633389f4453213303da61f20bd67fc233aa33262')
+    expect(key.addr)
+      .to eq('1CC3X2gu58d6wXUWMffpuzN9JAfTUWu4Kj')
+
+    Bitcoin.network = :testnet
+    key = Bitcoin::Key.from_base58(
+      '93BTVFoqffueSaC5fqjLjLyn29S41JzvAZm2hC35SYMoYDXT1bY'
+    )
+    expect(key.priv)
+      .to eq('d21fa2c7ad710ffcd9bcc22a9f96357bda1a2521ca7181dd610140ecea2cecd8')
+    expect(key.addr)
+      .to eq('n3eH91H14mSnGx4Va2ngtLFCeLPRyYymRg')
+  end
+
+  it 'should export private key in compressed base58 format' do
+    Bitcoin.network = :bitcoin
+    key = Bitcoin::Key.new(
+      '98e4483a197fb686fe9afb51389f329aabc67964b1d0e0a5340c962a0d63c44a',
+      nil,
+      true
+    ).to_base58
+    expect(key).to eq('L2LusdhGSagfUVvNWrUuPDygn5mdAhxUDEANfABvBj36Twn1mKgQ')
+
+    Bitcoin.network = :testnet3
+    key = Bitcoin::Key.new(
+      'e3ff5d7e592669d0c1714f1496b260815edd0c3a00186e896dc7f36ede914dd2',
+      nil,
+      true
+    ).to_base58
+    expect(key).to eq('cVDu6aXUWHTM2vpztZW14BMnKkCcd5th6177VnCsa8XozoMyp73C')
+  end
+
+  it 'should import private key in compressed base58 format' do
+    Bitcoin.network = :bitcoin
+    key = Bitcoin::Key.from_base58(
+      'L2LusdhGSagfUVvNWrUuPDygn5mdAhxUDEANfABvBj36Twn1mKgQ'
+    )
+    expect(key.priv)
+      .to eq('98e4483a197fb686fe9afb51389f329aabc67964b1d0e0a5340c962a0d63c44a')
+    expect(key.pub)
+      .to eq('02e054ee811165ac294c992ff410067db6491228725fe09db2a415493c897973a8')
+    expect(key.compressed).to be true
+    expect(key.addr).to eq('1C7Ni4zuV3zfLs8T1S7s29wNAtRoDHHnpw')
+
+    Bitcoin.network = :testnet3
+    key = Bitcoin::Key.from_base58(
+      'cVDu6aXUWHTM2vpztZW14BMnKkCcd5th6177VnCsa8XozoMyp73C'
+    )
+    expect(key.priv)
+      .to eq('e3ff5d7e592669d0c1714f1496b260815edd0c3a00186e896dc7f36ede914dd2')
+    expect(key.pub)
+      .to eq('0390bb61c062266a1e8460ec902379749ae30f569013d82bd448a61591f20b8ee2')
+    expect(key.addr)
+      .to eq('mjh9RgZh14FfJQ2pFpRSqEQ5BH1nHo5To7')
+  end
+
+  it 'should handle compressed and uncompressed pubkeys' do
+    compressed =
+      '0351efb6e91a31221652105d032a2508275f374cea63939ad72f1b1e02f477da78'
+    uncompressed =
+      '0451efb6e91a31221652105d032a2508275f374cea63939ad72f1b1e02f477da78' \
+      '7f71a2e8ac5aacedab47904d4bd42f636429e9ce069ebcb99f675aad31306a53'
+
+    expect(Bitcoin::Key.new(nil, compressed).compressed).to be true
+    expect(Bitcoin::Key.new(nil, compressed).pub).to eq(compressed)
+    expect(Bitcoin::Key.new(nil, compressed).addr)
+      .to eq('1NdB761LmTmrJixxp93nz7pEiCx5cKPW44')
+    expect(Bitcoin::Key.new(nil, uncompressed).compressed).to be false
+    expect(Bitcoin::Key.new(nil, uncompressed).pub).to eq(uncompressed)
+    expect(Bitcoin::Key.new(nil, uncompressed).addr)
+      .to eq('19FBCg9295EBQ4P6bSLTGyz2BdbbPcqQD')
+
+    new_key = Bitcoin::Key.new(nil, compressed)
+    expect(new_key.pub_compressed).to eq(compressed)
+    expect(new_key.pub_uncompressed).to eq(uncompressed)
+
+    msg = 'foobar'
+    sig = key.sign(msg)
+    expect(Bitcoin::Key.new(nil, key.pub_compressed).verify(msg, sig))
+      .to be true
+    expect(Bitcoin::Key.new(nil, key.pub_uncompressed).verify(msg, sig))
+      .to be true
+
+    compressed =
+      '02f01984446a994a9e422c9ba9c6f33f1f40c01d9d872064a49679d702fae33064'
+    expect(Bitcoin::Key.new(nil, compressed).pub).to eq(compressed)
+    expect(Bitcoin::Key.new(nil, compressed).addr)
+      .to eq('18TWywxjESkg4pzJqBYNDo39S2QMPaWWJ5')
+
+    k = Bitcoin::Key.new(nil, nil)
+    k.instance_eval do
+      set_pub(
+        '02f01984446a994a9e422c9ba9c6f33f1f40c01d9d872064a49679d702fae33064'
+      )
+    end
+    expect(k.compressed).to be true
+
+    k = Bitcoin::Key.new(nil, nil)
+    k.instance_eval do
+      set_pub(
+        '0351efb6e91a31221652105d032a2508275f374cea63939ad72f1b1e02f477da78'
+      )
+    end
+    expect(k.compressed).to be true
+
+    k = Bitcoin::Key.new(nil, nil)
+    k.instance_eval do
+      set_pub(
+        '0451efb6e91a31221652105d032a2508275f374cea63939ad72f1b1e02f477da787' \
+        'f71a2e8ac5aacedab47904d4bd42f636429e9ce069ebcb99f675aad31306a53'
+      )
+    end
+    expect(k.compressed).to be false
+  end
+
+  it 'should handle private key in bip38 (non-ec-multiply) format' do
+    k = Bitcoin::Key.from_base58(
+      '5KN7MzqK5wt2TP1fQCYyHBtDrXdJuXbUzm4A9rKAteGu3Qi5CVR'
+    )
+    expect(k.to_bip38('TestingOneTwoThree'))
+      .to eq('6PRVWUbkzzsbcVac2qwfssoUJAN1Xhrg6bNk8J7Nzm5H7kxEbn2Nh2ZoGg')
+
+    k = Bitcoin::Key.from_bip38(
+      '6PRVWUbkzzsbcVac2qwfssoUJAN1Xhrg6bNk8J7Nzm5H7kxEbn2Nh2ZoGg',
+      'TestingOneTwoThree'
+    )
+    expect(k.to_base58)
+      .to eq('5KN7MzqK5wt2TP1fQCYyHBtDrXdJuXbUzm4A9rKAteGu3Qi5CVR')
+
+    k = Bitcoin::Key.from_base58(
+      '5HtasZ6ofTHP6HCwTqTkLDuLQisYPah7aUnSKfC7h4hMUVw2gi5'
+    )
+    expect(k.to_bip38('Satoshi'))
+      .to eq('6PRNFFkZc2NZ6dJqFfhRoFNMR9Lnyj7dYGrzdgXXVMXcxoKTePPX1dWByq')
+
+    k = Bitcoin::Key.from_bip38(
+      '6PRNFFkZc2NZ6dJqFfhRoFNMR9Lnyj7dYGrzdgXXVMXcxoKTePPX1dWByq',
+      'Satoshi'
+    )
+    expect(k.to_base58)
+      .to eq('5HtasZ6ofTHP6HCwTqTkLDuLQisYPah7aUnSKfC7h4hMUVw2gi5')
+
+    k = Bitcoin::Key.from_base58(
+      'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP'
+    )
+    expect(k.to_bip38('TestingOneTwoThree'))
+      .to eq('6PYNKZ1EAgYgmQfmNVamxyXVWHzK5s6DGhwP4J5o44cvXdoY7sRzhtpUeo')
+
+    k = Bitcoin::Key.from_bip38(
+      '6PYNKZ1EAgYgmQfmNVamxyXVWHzK5s6DGhwP4J5o44cvXdoY7sRzhtpUeo',
+      'TestingOneTwoThree'
+    )
+    expect(k.to_base58)
+      .to eq('L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP')
+
+    k = Bitcoin::Key.from_base58(
+      'KwYgW8gcxj1JWJXhPSu4Fqwzfhp5Yfi42mdYmMa4XqK7NJxXUSK7'
+    )
+    expect(k.to_bip38('Satoshi'))
+      .to eq('6PYLtMnXvfG3oJde97zRyLYFZCYizPU5T3LwgdYJz1fRhh16bU7u6PPmY7')
+
+    k = Bitcoin::Key.from_bip38(
+      '6PYLtMnXvfG3oJde97zRyLYFZCYizPU5T3LwgdYJz1fRhh16bU7u6PPmY7',
+      'Satoshi'
+    )
+    expect(k.to_base58)
+      .to eq('KwYgW8gcxj1JWJXhPSu4Fqwzfhp5Yfi42mdYmMa4XqK7NJxXUSK7')
+  end
+
+  it 'should generate private key from warp format' do
+    k = Bitcoin::Key.from_warp('ER8FT+HFjk0', '7DpniYifN6c')
+    expect(k.addr).to eq('1J32CmwScqhwnNQ77cKv9q41JGwoZe2JYQ')
+    expect(k.to_base58)
+      .to eq('5JfEekYcaAexqcigtFAy4h2ZAY95vjKCvS1khAkSG8ATo1veQAD')
+
+    k = Bitcoin::Key.from_warp('YqIDBApDYME', 'G34HqIgjrIc')
+    expect(k.addr).to eq('19aKBeXe2mi4NbQRpYUrCLZtRDHDUs9J7J')
+    expect(k.to_base58)
+      .to eq('5KUJA5iZ2zS7AXkU2S8BiBVY3xj6F8GspLfWWqL9V7CajXumBQV')
+
+    k = Bitcoin::Key.from_warp('FPdAxCygMJg', 'X+qaSwhUYXw')
+    expect(k.addr).to eq('14Pqeo9XNRxjtKFFYd6TvRrJuZxVpciS81')
+    expect(k.to_base58)
+      .to eq('5JBAonQ4iGKFJxENExZghDtAS6YB8BsCw5mwpHSvZvP3Q2UxmT1')
+  end
+
+  it 'should raise error for private key out of range.' do
+    expect do
+      Bitcoin::Key.new(
+        'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141'
+      )
+    end.to raise_error(RuntimeError, 'private key is not on curve')
+
+    expect do
+      Bitcoin::Key.new('00')
+    end.to raise_error(RuntimeError, 'private key is not on curve')
+
+    Bitcoin::Key.new(
+      'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140'
+    )
+    Bitcoin::Key.new('01')
+  end
+
+  describe 'Bitcoin::OpenSSL_EC' do
+    it 'resolves public from private key' do
+      privkey = [
+        '56e28a425a7b588973b5db962a09b1aca7bdc4a7268cdd671d03c52a997255dc'
+      ].pack('H*')
+      pubkey = [
+        '04324c6ebdcf079db6c9209a6b715b955622561262cde13a8a1df8ae0ef030ea' \
+        'a1552e31f8be90c385e27883a9d82780283d19507d7fa2e1e71a1d11bc3a52caf3'
+      ].pack('H*')
+
+      expect(Bitcoin::OpenSSL_EC.regenerate_key(privkey))
+        .to eq([privkey, pubkey].map { |i| i.unpack('H*')[0] })
+
+      [
+        [
+          'b51386f8275d49d8d30287d7b1afa805790bdd1fe8b13d22d25928c67ea55d02',
+          '0470305ae5278a22499980286d9c513861d89e7b7317c8b891c554d5c8fdd256' \
+          'b03daa0340be4104f8c84cfa98f0da8f16567fcdd3a00fd993adbbe91695671a56'
+        ],
+        [
+          'd8ebece51adc5fb99dd6994bcb8fa1221d01576fd76af9134ab36f8d4698b55c',
+          '047503421850d3a6eecb7c9de33b367c4d3f96a34ff257ad0c34e234e29f3672' \
+          '525c6b4353ce6fdc9de3f885fdea798982e2252e610065dbdb62cd8cab1fe45822'
+        ],
+        [
+          'c95c79fb0cc1fe47b384751df0627be40bbe481ec94eeafeb6dc40e94c40de43',
+          '04b746ca07e718c7ca26d4eeec037492777f48bb5c750e972621698f699f5305' \
+          '35c0ffa96dad581102d0471add88e691af85955d1fd42f68506f8092fddfe0c47a'
+        ],
+        [
+          '5b61f807cc938b0fd3ec8f6006737d0002ceca09f296204138c4459de8a856f6',
+          '0487357bf30c13d47d955666f42f87690cfd18be96cc74cda711da74bf76b08e' \
+          'bc6055aba30680e6288df14bda68c781cbf71eaad096c3639e9724c5e26f3acf54'
+        ]
+      ].each do |key|
+        privkey, pubkey = [key.first].pack('H*')
+        expect(Bitcoin::OpenSSL_EC.regenerate_key(privkey)).to eq(key)
+      end
+
+      250.times.each do
+        keypair = Bitcoin.generate_key
+        expect(Bitcoin::OpenSSL_EC.regenerate_key(keypair.first)).to eq(keypair)
+      end
+    end
+
+    it 'recover public key from compact signature' do
+      args = [
+        "\x12&\x17\x9D\xDFc\x83\xFB\xCFQ\x02\xC9I%8\xB7 ls\x9A\xE7\x9E\xB0d@" \
+        "\x8C*\xBDg\xD3\x9B\xED",
+        "\x1C\xF0\xEC\xD57\xAC\x03\x8F\x1A\xF6\xEAx@\xE4H\xBA\xE6\xFA\xEDQ" \
+        "\xC13~\xD7\xEB\xAB$\x01\x8C\xF4\x12\xC86\xDE\a_2\xE0\x93`1NE\xCE" \
+        "\x97\x1A\x92\x99\xDB\xF7\xE5'h\x7F\rAy\xEB\xD1I\xC4j\x15g\x9D",
+        1,
+        false
+      ]
+      expected = '047840b97f46d4c32c62119f9e069172272592ec7741a3aec81e339b873' \
+                 '87350740dce89837c8332910f349818060b66070b94e8bb11442d49d3f6' \
+                 'c0d7f31ba6a6'
+
+      expect(Bitcoin::OpenSSL_EC.recover_public_key_from_signature(*args))
+        .to eq(expected)
+    end
+
+    it 'sign and verify text messages' do
+      [
+        ['5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj', false],
+        ['5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3', false],
+        ['Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw', true],
+        ['L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g', true]
+      ].each do |privkey_base58, expected_compression|
+        k = Bitcoin::Key.from_base58(privkey_base58)
+        expect(k.compressed).to eq(expected_compression)
+        k2 = Bitcoin::Key.new(nil, k.pub)
+        expect(k2.compressed).to eq(expected_compression)
+        16.times do |n|
+          msg = "Very secret message #{n}: 11"
+          signature = k.sign_message(msg)
+          expect(k2.verify_message(signature, msg)).to be true
+          expect(Bitcoin::Key.verify_message(k.addr, signature, msg)).to be true
+        end
+      end
+    end
+  end
+end