bitcoin-ruby 0.0.18 → 0.0.19

data/lib/bitcoin/logger.rb

@@ -1,86 +0,0 @@
-# encoding: ascii-8bit
-
-begin
-  require 'log4r'
-  # monkey-patch Log4r to accept level names as symbols
-  class Log4r::Logger
-    def level= l = 0
-      _level = l.is_a?(Fixnum) ? l : Log4r::LNAMES.index(l.to_s.upcase)
-      Log4r::Log4rTools.validate_level(_level)
-      @level = _level
-      LoggerFactory.define_methods(self)
-      Log4r::Logger.log_internal {"Logger '#{@fullname}' set to #{LNAMES[@level]}"}
-      @level
-    end
-  end
-rescue LoadError
-end
-
-module Bitcoin
-  # this is a very simple logger that is used if log4r is not available
-  module Logger
-
-    module TimeLogger
-
-      def time message
-        time = Time.now
-        res = yield
-        debug { message % (Time.now - time) }
-        res
-      end
-
-    end
-
-    class Logger
-      LEVELS = [:debug, :info, :warn, :error, :fatal]
-
-      include TimeLogger
-
-      attr_accessor :level
-
-      def initialize(name)
-        @name, @level = name, :info
-      end
-
-      def level= level
-        @level = level.is_a?(Fixnum) ? LEVELS[level] : level.to_sym
-      end
-
-      LEVELS.each do |level|
-        define_method(level) do |*msg, &block|
-          return  if LEVELS.index(level.to_sym) < LEVELS.index(@level.to_sym)
-          msg = block ? block.call : msg.join
-          puts "#{level.to_s.upcase.ljust(5)} #{@name}: #{msg}"
-        end
-      end
-
-    end
-
-    # wrap a logger and prepend a special name in front of the messages
-    class LogWrapper
-      def initialize(name, log); @name, @log = name, log; end
-      def method_missing(m, *a, &blk)
-        @log.send(m, *a, &proc{ "#{@name} #{blk.call}" })
-      end
-    end
-
-    # create a logger with given +name+. if log4r is installed, the logger
-    # will have a stdout and a fileout outputter to `log/<name>.log`.
-    # otherwise, the internal dummy logger is used which only logs to stdout.
-    def self.create name, level = :info
-      if defined?(Log4r)
-        dir = "log"
-        FileUtils.mkdir_p(dir) rescue dir = nil
-        @log = Log4r::Logger.new(name.to_s)
-        @log.extend(TimeLogger)
-        @log.level = level
-        @log.outputters << Log4r::Outputter.stdout
-        @log.outputters << Log4r::FileOutputter.new("fout", :filename => "#{dir}/#{name}.log")  if dir
-      else
-        @log = Bitcoin::Logger::Logger.new(name)
-      end
-      @log
-    end
-
-  end
-end

data/lib/bitcoin/protocol/alert.rb

@@ -1,46 +0,0 @@
-# encoding: ascii-8bit
-
-module Bitcoin
-module Protocol
-
-  class Alert < Struct.new(:version, :relay_until, :expiration, :id, :cancel, :set_cancel,
-                           :min_ver, :max_ver, :set_sub_ver, :priority, :comment, :status_bar, :reserved)
-
-    attr_accessor :payload, :signature
-
-    def initialize(values, alert_payload=nil, alert_signature=nil)
-      @payload, @signature = alert_payload, alert_signature
-      super(*values)
-    end
-
-    def valid_signature?
-      return false unless @payload && @signature
-      hash = Digest::SHA256.digest(Digest::SHA256.digest(@payload))
-      Bitcoin.network[:alert_pubkeys].any?{|public_key| Bitcoin.verify_signature(hash, @signature, public_key) }
-    end
-
-
-    def self.parse(payload)
-      count,             payload = Bitcoin::Protocol.unpack_var_int(payload)
-      alert_payload,     payload = payload.unpack("a#{count}a*")
-      count,             payload = Bitcoin::Protocol.unpack_var_int(payload)
-      alert_signature,   payload = payload.unpack("a#{count}a*")
-
-      version, relay_until, expiration, id, cancel, payload = alert_payload.unpack("VQQVVa*")
-
-      set_cancel,        payload = Bitcoin::Protocol.unpack_var_int_array(payload)
-      min_ver, max_ver,  payload = payload.unpack("VVa*")
-      set_sub_ver,       payload = Bitcoin::Protocol.unpack_var_string_array(payload)
-      priority,          payload = payload.unpack("Va*")
-      comment,           payload = Bitcoin::Protocol.unpack_var_string(payload)
-      status_bar,        payload = Bitcoin::Protocol.unpack_var_string(payload)
-      reserved,          payload = Bitcoin::Protocol.unpack_var_string(payload)
-
-      values = [ version, relay_until, expiration, id, cancel, set_cancel, min_ver, max_ver, set_sub_ver, priority, comment, status_bar, reserved ]
-
-      new(values, alert_payload, alert_signature)
-    end
-  end
-
-end
-end

data/spec/bitcoin/bech32_spec.rb

@@ -1,160 +0,0 @@
-# encoding: ascii-8bit
-
-require_relative 'spec_helper'
-
-describe Bitcoin::Bech32 do
-  before do
-    Bitcoin.network = :bitcoin
-
-    @invalid_address_enc = [
-      ["BC", 0, 20],
-      ["bc", 0, 21],
-      ["bc", 17, 32],
-      ["bc", 1, 1],
-      ["bc", 16, 41],
-    ]
-
-    @valid_address = [
-        [
-            "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4",
-            22, [
-                0x00, 0x14, 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54,
-                0x94, 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
-            ]
-        ],
-        [
-            "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
-            34, [
-                0x00, 0x20, 0x18, 0x63, 0x14, 0x3c, 0x14, 0xc5, 0x16, 0x68, 0x04,
-                0xbd, 0x19, 0x20, 0x33, 0x56, 0xda, 0x13, 0x6c, 0x98, 0x56, 0x78,
-                0xcd, 0x4d, 0x27, 0xa1, 0xb8, 0xc6, 0x32, 0x96, 0x04, 0x90, 0x32,
-                0x62
-            ]
-        ],
-        [
-            "bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx",
-            42, [
-                0x51, 0x28, 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54,
-                0x94, 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6,
-                0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94, 0x1c,
-                0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
-            ]
-        ],
-        [
-            "BC1SW50QA3JX3S",
-            4, [
-               0x60, 0x02, 0x75, 0x1e
-            ]
-        ],
-        [
-            "bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj",
-            18, [
-                0x52, 0x10, 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54,
-                0x94, 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23
-            ]
-        ],
-        [
-            "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy",
-            34, [
-                0x00, 0x20, 0x00, 0x00, 0x00, 0xc4, 0xa5, 0xca, 0xd4, 0x62, 0x21,
-                0xb2, 0xa1, 0x87, 0x90, 0x5e, 0x52, 0x66, 0x36, 0x2b, 0x99, 0xd5,
-                0xe9, 0x1c, 0x6c, 0xe2, 0x4d, 0x16, 0x5d, 0xab, 0x93, 0xe8, 0x64,
-                0x33
-            ]
-        ]
-    ]
-
-		@valid_checksum = [
-				"A12UEL5L",
-				"an83characterlonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1tt5tgs",
-				"abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw",
-				"11qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqc8247j",
-				"split1checkupstagehandshakeupstreamerranterredcaperred2y9e3w",
-		]
-
-		@invalid_checksum = [
-				" 1nwldj5",
-				"\x7f""1axkwrx",
-				"an84characterslonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1569pvx",
-				"pzry9x0s0muk",
-				"1pzry9x0s0muk",
-				"x1b4n0q5v",
-				"li1dgmt3",
-				"de1lg7wt\xff",
-		]
-
-		@invalid_address = [
-				"tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty",
-				"bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5",
-				"BC13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2",
-				"bc1rw5uspcuh",
-				"bc10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90",
-				"BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P",
-				"tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7",
-				"bc1zw508d6qejxtdg4y5r3zarvaryvqyzf3du",
-				"tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv",
-				"bc1gmk9yu",
-		]
-  end
-
-  describe '#decode and #encode' do
-    it "test vectors" do
-      @valid_checksum.each do |testdata|
-        hrp, data = Bitcoin::Bech32.decode(testdata)
-        newdata = Bitcoin::Bech32.encode(hrp, data)
-        newdata.should == testdata.downcase
-      end
-
-      @invalid_checksum.each do |testdata|
-        hrp, data = Bitcoin::Bech32.decode(testdata)
-        hrp.should == nil
-      end
-
-      @valid_address.each do |testdata, _, _|
-        hrp, data = Bitcoin::Bech32.decode(testdata)
-        newdata = Bitcoin::Bech32.encode(hrp, data)
-        newdata.should == testdata.downcase
-      end
-    end
-  end
-
-  describe '#decode_segwit_address and #encode_segwit_address' do
-    it "test vectors" do
-			@valid_address.each do |testaddress, _, testscript|
-				Bitcoin.network = :bitcoin
-				version, program = Bitcoin.decode_segwit_address(testaddress)
-				if version.nil?
-					Bitcoin.network = :testnet3
-					version, program = Bitcoin.decode_segwit_address(testaddress)
-				end
-				version.should != nil
-
-        script = Bitcoin::Script.to_witness_script(version, program)
-        script.should == testscript.pack("C*")
-
-        newaddress = Bitcoin.encode_segwit_address(version, program)
-        newaddress.should != nil
-        newaddress.should == testaddress.downcase
-			end
-
-			@invalid_address.each do |testaddress|
-				Bitcoin.network = :bitcoin
-				version, program = Bitcoin.decode_segwit_address(testaddress)
-				if version.nil?
-					Bitcoin.network = :testnet3
-					version, program = Bitcoin.decode_segwit_address(testaddress)
-				end
-				version.should == nil
-      end
-
-			Bitcoin.network = :bitcoin
-      @invalid_address_enc.each do |testhrp, testversion, testlength|
-			  Bitcoin.network[:bech32_hrp] = testhrp
-        program_hex = Array.new(testlength){ 0 }.pack("C*").unpack("H*").first
-        newaddress = Bitcoin.encode_segwit_address(testversion, program_hex)
-        newaddress.should == nil
-      end
-    end
-  end
-
-end

data/spec/bitcoin/bitcoin_spec.rb

@@ -1,666 +0,0 @@
-# encoding: ascii-8bit
-
-require_relative 'spec_helper.rb'
-require 'bitcoin'
-
-
-describe 'Bitcoin Address/Hash160/PubKey' do
-
-  it 'bitcoin-hash160 from public key' do
-    # 65 bytes (8 bit version + 512 bits) pubkey in hex (130 bytes)
-    pubkey = "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"
-    Bitcoin.hash160(pubkey).should == "62e907b15cbf27d5425399ebf6f0fb50ebb88f18"
-  end
-
-  it 'bitcoin-address from bitcoin-hash160' do
-    # 20 bytes (160 bit) hash160 in hex (40 bytes)
-
-    Bitcoin::network = :testnet
-    Bitcoin.hash160_to_address("62e907b15cbf27d5425399ebf6f0fb50ebb88f18")
-      .should == "mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt"
-
-    Bitcoin::network = :bitcoin
-    Bitcoin.hash160_to_address("62e907b15cbf27d5425399ebf6f0fb50ebb88f18")
-      .should == "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
-  end
-
-  it 'bitcoin-address from pubkey' do
-    Bitcoin::network = :testnet
-    Bitcoin.pubkey_to_address("029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4")
-      .should == "mu6vSuyvpVxvDAJyZczjxaU56pXLNBSf9C"
-    Bitcoin.pubkey_to_address("049e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4b82314814017e4e9b06a0fd8e01772bb410cb1c36cfc2d03079c315bc7494b86")
-    .should == "n4bZ82i9SdLj6YauPn3PPKFRhQHMZrdaPq"
-
-    Bitcoin::network = :bitcoin
-    Bitcoin.pubkey_to_address("029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4")
-    .should == "1Eay9rtx1UXfS3qMr42N8fFkEpvdR2euvg"
-    Bitcoin.pubkey_to_address("049e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4b82314814017e4e9b06a0fd8e01772bb410cb1c36cfc2d03079c315bc7494b86")
-    .should == "1Q5bpydAdbuUKS7HgD51ZQ36qQgeiN8cBE"
-  end
-
-  it 'bitcoin p2sh multisig address from pubkeys' do
-    Bitcoin::network = :testnet
-    address, redeem_script = Bitcoin.pubkeys_to_p2sh_multisig_address(2, "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4",
-                                                                      "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec")
-    address.should == "2NGaiH7MNYWhsWPQKudZEvy8KnoWPfuGPg1"
-    redeem_script.hth.should == "52" + # OP_2
-                                "21" + "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4" + # pubkey.bytesize + pubkey
-                                "21" + "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec" + # pubkey.bytesize + pubkey
-                                "52" +  # OP_2
-                                "ae"    # OP_CHECKMULTISIG
-
-    Bitcoin::network = :bitcoin
-    address, redeem_script = Bitcoin.pubkeys_to_p2sh_multisig_address(2, "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4",
-                                                                      "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec",
-                                                                      "020b16a7227f873ac68cf3140f1101d2eda5acb28bf3e7d546409139caf25142e4")
-    address.should == "38eiL6Jac27TVAu83wj81Miso9rXiVqgcP"
-    redeem_script.hth.should == "52" + # OP_2
-                                "21" + "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4" + # pubkey.bytesize + pubkey
-                                "21" + "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec" + # pubkey.bytesize + pubkey
-                                "21" + "020b16a7227f873ac68cf3140f1101d2eda5acb28bf3e7d546409139caf25142e4" + # pubkey.bytesize + pubkey
-                                "53" +  # OP_3
-                                "ae"    # OP_CHECKMULTISIG
-  end
-
-  it 'bitcoin p2sh address from bitcoin-hash160' do
-    Bitcoin::network = :testnet
-    Bitcoin.hash160_to_p2sh_address("d11e2f2f385efeecd30f867f1d55c0bc8a27f29e")
-      .should == "2NCJwNct2SVE5VwdrPXmnek59kCfdgCpxeF"
-
-    Bitcoin::network = :bitcoin
-    Bitcoin.hash160_to_p2sh_address("d11e2f2f385efeecd30f867f1d55c0bc8a27f29e")
-      .should == "3LkjJswzq2ijJA1JiQ9v2o5tXrTTvPtAMe"
-  end
-
-  it 'bitcoin-hash160 from bitcoin-address' do
-    Bitcoin::network = :testnet
-    Bitcoin.hash160_from_address("mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt")
-      .should == "62e907b15cbf27d5425399ebf6f0fb50ebb88f18"
-    Bitcoin.hash160_from_address("totally-invalid").should == nil
-
-    Bitcoin::network = :bitcoin
-    Bitcoin.hash160_from_address("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa")
-      .should == "62e907b15cbf27d5425399ebf6f0fb50ebb88f18"
-
-    Bitcoin.hash160_from_address("11ofrrzv87Ls97jN4TUetfQp4gEsUSL7A")
-      .should == "0026f5494b39ea04b7bcb05e583acf3b0102d61f"
-    Bitcoin.hash160_from_address("11122RGUQSszAsTpptd2h8sdyYGR6nKs6f")
-      .should == "0000daec8d6f05e949710f202c4f73258aa7791e"
-    Bitcoin.hash160_from_address("11119uLoMQCBHmKevdsFKHMaUoyrwLa9Y")
-      .should == "00000090c66372823859c935149e2e32d276a1e6"
-    Bitcoin.hash160_from_address("1111136sgL8UNSTVL9ize2uGFPxFDGwFp")
-      .should == "0000000096d3ad65d030a36e2c23f7fdd5dfcadb"
-    Bitcoin.hash160_from_address("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4")
-      .should == "751e76e8199196d454941c45d1b3a323f1433bd6"
-  end
-
-  it 'should survive rounds of hash160 <-> address' do
-    hex = "62e907b15cbf27d5425399ebf6f0fb50ebb88f18"
-
-    Bitcoin::network = :testnet
-    addr = "mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt"
-    Bitcoin.hash160_from_address(Bitcoin.hash160_to_address(hex)).should == hex
-    Bitcoin.hash160_to_address(Bitcoin.hash160_from_address(addr)).should == addr
-
-    Bitcoin::network = :bitcoin
-    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
-    Bitcoin.hash160_from_address(Bitcoin.hash160_to_address(hex)).should == hex
-    Bitcoin.hash160_to_address(Bitcoin.hash160_from_address(addr)).should == addr
-  end
-
-  it '#address_checksum?' do
-    Bitcoin::network = :testnet
-    Bitcoin.address_checksum?("mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt").should == true
-    Bitcoin.address_checksum?("1D3KpY5kXnYhTbdCbZ9kXb2ZY7ZapD85cW").should == true
-    Bitcoin.address_checksum?("f0f0f0").should == false
-
-    Bitcoin::network = :bitcoin
-    Bitcoin.address_checksum?("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa").should == true
-    Bitcoin.address_checksum?("mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt").should == true
-    Bitcoin.address_checksum?("f0f0f0").should == false
-  end
-
-  it 'validate bitcoin-address' do
-
-    Bitcoin::network = :testnet
-
-    Bitcoin.valid_address?("mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt").should == true
-    Bitcoin.valid_address?("1D3KpY5kXnYhTbdCbZ9kXb2ZY7ZapD85cW").should == false
-    Bitcoin.valid_address?("1moYFpRM4LkTV4Ho5eCxiEPB2bSm3AsJNGj").should == false
-    Bitcoin.valid_address?("f0f0f0").should == false
-
-    Bitcoin::network = :bitcoin
-
-    Bitcoin.valid_address?("1D3KpY5kXnYhTbdCbZ9kXb2ZY7ZapD85cW").should == true
-    Bitcoin.valid_address?("mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt").should == false
-    Bitcoin.valid_address?("2D3KpY5kXnYhTbdCbZ9kXb2ZY7ZapD85cW").should == false
-    Bitcoin.valid_address?("1D3KpY5kXnYhTbdCbZ9kXb2ZY7ZapD85cX").should == false
-    Bitcoin.valid_address?("1moYFpRM4LkTV4Ho5eCxiEPB2bSm3AsJNGj").should == false
-
-    Bitcoin.valid_address?("1ZQxJYBRmbb2rDNYPhd96x3eMbNnPD98q").should == true
-    Bitcoin.valid_address?("12KhCL8nGK3Luy7ehU3AxPs1mTocdessLM").should == true
-    Bitcoin.valid_address?("1AnNQgfaGgSKejzR6km74tyQPDGwZBBVT").should == true
-    Bitcoin.valid_address?("f0f0f0").should == false
-
-
-    Bitcoin.base58_to_int("114EpVhtPpJQKti8HiH2fvXZFPiPkgDZrE").should \
-      == 15016857106811133404017207799481956647721349092596212439
-
-    Bitcoin.network, success = :testnet, true
-    400.times{
-      addr = Bitcoin.generate_address
-      success = false if Bitcoin.hash160_from_address(addr[0])  != addr[-1]
-      success = false if Bitcoin.hash160_to_address(addr[-1])   != addr[0]
-      success = false if Bitcoin.valid_address?(addr[0]) != true
-    }
-    success.should == true
-
-    Bitcoin.network, success = :bitcoin, true
-    400.times{
-      addr = Bitcoin.generate_address
-      success = false if Bitcoin.hash160_from_address(addr[0]) != addr[-1]
-      success = false if Bitcoin.hash160_to_address(addr[-1])  != addr[0]
-      success = false if Bitcoin.valid_address?(addr[0]) != true
-    }
-    success.should == true
-  end
-
-  it 'validate bitcoin public key' do
-    key = Bitcoin::Key.generate
-    Bitcoin.valid_pubkey?(key.pub_compressed).should == true
-    Bitcoin.valid_pubkey?(key.pub_uncompressed).should == true
-    Bitcoin.valid_pubkey?(key.addr).should == false
-    Bitcoin.valid_pubkey?(key.priv).should == false
-  end
-
-  it 'validate p2sh address' do
-    Bitcoin.network = :testnet
-    Bitcoin.valid_address?("2MyLngQnhzjzatKsB7XfHYoP9e2XUXSiBMM").should == true
-    Bitcoin.network = :bitcoin
-    Bitcoin.valid_address?("3CkxTG25waxsmd13FFgRChPuGYba3ar36B").should == true
-  end
-
-  it '#address_type' do
-    Bitcoin.network = :testnet
-    Bitcoin.address_type("2MyLngQnhzjzatKsB7XfHYoP9e2XUXSiBMM").should == :p2sh
-    Bitcoin.address_type("mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt").should == :hash160
-    Bitcoin.address_type("1D3KpY5kXnYhTbdCbZ9kXb2ZY7ZapD85cW").should == nil
-    Bitcoin.network = :bitcoin
-    Bitcoin.address_type("3CkxTG25waxsmd13FFgRChPuGYba3ar36B").should == :p2sh
-    Bitcoin.address_type("1D3KpY5kXnYhTbdCbZ9kXb2ZY7ZapD85cW").should == :hash160
-    Bitcoin.address_type("mpXwg4jMtRhuSpVq4xS3HFHmCmWp9NyGKt").should == nil
-    Bitcoin.address_type("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4").should == :witness_v0_keyhash
-    Bitcoin.address_type("bc1qw508d6qejxtdg4y5r3zarvayr0c5xw7kv8f3t4").should == nil
-    Bitcoin.address_type("bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3").should == :witness_v0_scripthash
-
-    # address_type recognizes Litecoin addresses encoded with the legacy P2SH version byte
-    Bitcoin.network = :litecoin
-    Bitcoin.address_type("3CkxTG25waxsmd13FFgRChPuGYba3ar36B").should == :p2sh
-    Bitcoin.address_type("MJy6m9S3thpJa8GwM8fm2LeJbFC22w18Vx").should == :p2sh
-    Bitcoin.address_type("2MyLngQnhzjzatKsB7XfHYoP9e2XUXSiBMM").should == nil
-
-    Bitcoin.network = :bitcoin
-  end
-
-  it 'Bitcoin#checksum' do
-    Bitcoin.checksum("0062e907b15cbf27d5425399ebf6f0fb50ebb88f18").should == "c29b7d93"
-  end
-
-  it '#bitcoin_mrkl' do
-    # block 170 is the first block that has a transaction.
-    # hash 00000000d1145790a8694403d4063f323d499e655c83426834d4ce2f8dd4a2ee
-    a = "b1fea52486ce0c62bb442b530a3f0132b826c74e473d1f2c220bfa78111c5082"
-    b = "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16"
-    c = "7dac2c5666815c17a3b36427de37bb9d2e2c5ccec3f8633eb91a4205cb4c10ff"
-
-    Bitcoin.bitcoin_hash(b + a)    .should == c
-    Bitcoin.bitcoin_mrkl(a , b)    .should == c
-  end
-
-  it 'mrkl_tree from transaction-hashes' do
-
-    # mrkl tree for block 170
-    mrkl_tree = [
-      "b1fea52486ce0c62bb442b530a3f0132b826c74e473d1f2c220bfa78111c5082",# tx 1
-      "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",# tx 2
-      "7dac2c5666815c17a3b36427de37bb9d2e2c5ccec3f8633eb91a4205cb4c10ff"
-    ]
-    Bitcoin.hash_mrkl_tree(mrkl_tree[0...2]).should == mrkl_tree
-
-
-    mrkl_tree = [
-      "4fa598026d9be1ca0c2bff1b531e566b7ea7f90b72e75fda0c1795bc2dfa375c",
-      "186640daf908156e2616790d7c816235b0c43f668c3c38351b348c08ca44d457",
-      "ef3928700309b4deceac9a992a19a7481b4e520cbc0b1ab74e2645eee39c8da0",
-
-      "688c53517f62f7a65c0e87519c18a4de98f2ccafbf389b269d0bb867f88d166a",
-      "01889506f7fe9210045f588361881e2d16a034a62bc48ebd7b6b0a3edeaf5a6d",
-
-      "74f3a7df861d6a58957b84a3e425a8cf57e1e2e3a3def046dd200baeb8714f00"
-    ]
-
-    Bitcoin.hash_mrkl_tree( mrkl_tree[0...3] ).should == mrkl_tree
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[0], mrkl_tree[1] ).should == mrkl_tree[3]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[2], mrkl_tree[2] ).should == mrkl_tree[4]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[3], mrkl_tree[4] ).should == mrkl_tree[5]
-
-    mrkl_tree[0...3].each.with_index do |target, idx|
-      branch = Bitcoin.hash_mrkl_branch( mrkl_tree[0...3], target )
-      Bitcoin.mrkl_branch_root( branch, target, idx ).should == mrkl_tree[-1]
-    end
-
-    mrkl_tree = [
-      "349f717b6630e1f305f95964a2d94117dacca76e0b715d4d7a5657698ec96c6c", # 0
-      "7f44a84349200473455bcfc05ee68036e23993a6f58dce3f6a7faab46a754440", # 1
-      "6b3ba3fdfb7eeb6c2e5fd0e36e5bb4634da294521f7b1b808286c214981f9b17", # 2
-      "0467b41043d654ba3dc3940cbefec0eb38feed6e7085a8e825e4f782eccb48e3", # 3
-      "83d0231624f7a7d5c37557461ac0d09a8ad7a1f4ab673dd697acb275d4b114de", # 4
-      "074970aaa98db7d00e6f97a719fe85e9c7f51b75fa5a9a92218d568ccc2b21fe", # 5
-
-      "c1b6d2a416de6b63e42c1b50f229911bfb07f816e0795bb86ff7dcf0463ab0df", # 6
-      "751bcfd8acc10792f42050dca5b852f7a2fcd5300897d05907a98473f59a5650", # 7
-      "7abf551000d942efb93afc2d6174dc1bb7d41e8ea5fd76724685000734f1d77b", # 8
-
-      "e268927aa50d44de5365c11a2e402478767b7b98856a21a0715f9db65709aabb", # 9
-      "ed5ecc6b0e2fdd81be806599d6509d166e26849049e60e8d8b398641282b1e5a", # 10
-
-      "72e0e61880cc5fc9c7b5990c2d40b22eba783391b72807d2d5349fb55875c015"  # 11
-    ]
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[0], mrkl_tree[1] ).should == mrkl_tree[6]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[2], mrkl_tree[3] ).should == mrkl_tree[7]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[4], mrkl_tree[5] ).should == mrkl_tree[8]
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[6], mrkl_tree[7] ).should == mrkl_tree[9]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[8], mrkl_tree[8] ).should == mrkl_tree[10]
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[9], mrkl_tree[10] ).should == mrkl_tree[11]
-
-    Bitcoin.hash_mrkl_tree(mrkl_tree[0...6]).should == mrkl_tree
-
-    mrkl_tree[0...5].each.with_index do |target, idx|
-      branch = Bitcoin.hash_mrkl_branch( mrkl_tree[0..5], target )
-      Bitcoin.mrkl_branch_root( branch, target, idx ).should == mrkl_tree[-1]
-    end
-
-    mrkl_tree = [
-      "627c859b5af6d537930fd16148eb0597542bea543f65fc2b0e5f188b5a458529", # 0
-      "d00b90525820a74f30ce26488db7f77c6ee9577e650568a051edd8560bbf83a1", # 1
-      "706b8ac1a433bc28385450626e12c1c7806032dc8b7e12221f417c5f22059d70", # 2
-      "10107ad569400a5f9621498e410845e6db0551671a2cafcf4358bd7867c6bc14", # 3
-      "ac6b08a363aedd5e58177c7f68bb213403ef78d24be0012c06b3483a9e2461fe", # 4
-      "d3074f5b33a44d9961f40eadf250cdc1425f7975012fccb6b06abc5202c53f4b", # 5
-      "3270c13599266d3a8da90a85a07fc003c58a8ff2938988356783b6261be335a6", # 6
-      "e097c3e2e3a07385628ac5a5a775e8a5e22dda3732bee32ae65b1430d080fc32", # 7
-      "c335a3963e8d89a9f46b94158d33f9b0dee25e776cba91be5eda44898bd31a78", # 8
-
-      "eb52315c6b26f72fa58ed95cd4886f1aa047ecd8f34ed8a367f59854f20733d8", # 9
-      "f97bf49e42e1732c0b515ecbac7cffc29c8c75c20c6783ad48b09d348fe0b6cf", # 10
-      "fc655dfc41eed4e2ea4cfe33ebb6bf593eb256bf86c17802fd03567668d0bf71", # 11
-      "06c4abf5dae15d5fa3632e7e5f82f05e7afbbfd495ea8015c6094764d868654c", # 12
-      "31bbd6e4523aeaaaf75b6ea4ef63d0fe3dba66fb719f4a4232891a3b58ad5cec", # 13
-
-      "0c728622b795e14ac40c4aa13cb732a0407b2b85c9108c6f06c083220bb6d65d", # 14
-      "f83f6ea46edcbeaa738ce4701bf48412a10c4b1a9f109efe44bc8fe5cb6b0017", # 15
-      "5e6168778c8407ace3ae9901a2f5197d6f21a6634ae0af639e52d14c39b13e02", # 16
-
-      "b92a7980b8a8a64f896027c0de732298d04ca56bea66c18cf97983037486e456", # 17
-      "2a2fd5e450b6ec31ccbe9d827f2e903714eb69c351300b1e76c587aef60e000c", # 18
-
-      "9ed561bb49c47648e0250cb074721d94cba84ed1e083f1e57c29eca78e36d73d"  # 19
-    ]
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[0], mrkl_tree[1] ).should == mrkl_tree[9]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[2], mrkl_tree[3] ).should == mrkl_tree[10]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[4], mrkl_tree[5] ).should == mrkl_tree[11]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[6], mrkl_tree[7] ).should == mrkl_tree[12]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[8], mrkl_tree[8] ).should == mrkl_tree[13]
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[9], mrkl_tree[10] ).should == mrkl_tree[14]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[11], mrkl_tree[12] ).should == mrkl_tree[15]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[13], mrkl_tree[13] ).should == mrkl_tree[16]
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[14], mrkl_tree[15] ).should == mrkl_tree[17]
-    Bitcoin.bitcoin_mrkl( mrkl_tree[16], mrkl_tree[16] ).should == mrkl_tree[18]
-
-    Bitcoin.bitcoin_mrkl( mrkl_tree[17], mrkl_tree[18] ).should == mrkl_tree[19]
-
-    Bitcoin.hash_mrkl_tree(mrkl_tree[0...9]).should == mrkl_tree
-
-    mrkl_tree[0..8].each.with_index do |target, idx|
-      branch = Bitcoin.hash_mrkl_branch( mrkl_tree[0..8], target )
-      Bitcoin.mrkl_branch_root( branch, target, idx ).should == mrkl_tree[-1]
-    end
-
-  end
-
-  it 'should not allow duplicate hash in merkle trees' do
-    Bitcoin.hash_mrkl_tree(["aa", "bb", "cc"]).last.should !=
-      Bitcoin.hash_mrkl_tree(["aa", "bb", "cc", "cc"]).last
-  end
-  
-  it 'return a value even if a merkle branch is empty' do
-    branch = []
-    mrkl_index = 0
-    target = "089b911f5e471c0e1800f3384281ebec5b372fbb6f358790a92747ade271ccdf"
-    Bitcoin.mrkl_branch_root(branch.map(&:hth), target, mrkl_index).should == target
-  end
-
-  it 'nonce compact bits to bignum hex' do
-    Bitcoin.decode_compact_bits( "1b00b5ac".to_i(16) ).index(/[^0]/).should == 12
-    Bitcoin.decode_compact_bits( "1b00b5ac".to_i(16) ).to_i(16).should ==
-      "000000000000b5ac000000000000000000000000000000000000000000000000".to_i(16)
-
-
-    target = 453031340
-    Bitcoin.decode_compact_bits( target ).should ==
-      "000000000000b5ac000000000000000000000000000000000000000000000000"
-    Bitcoin.encode_compact_bits( Bitcoin.decode_compact_bits( target ) ).should == target
-
-    target = 486604799
-    Bitcoin.decode_compact_bits( target ).should ==
-      "00000000ffff0000000000000000000000000000000000000000000000000000"
-    Bitcoin.encode_compact_bits( Bitcoin.decode_compact_bits( target ) ).should == target
-
-    target = 476399191 # from block 40,320
-    Bitcoin.decode_compact_bits(target).should ==
-      "0000000065465700000000000000000000000000000000000000000000000000"
-    Bitcoin.encode_compact_bits( Bitcoin.decode_compact_bits( target ) ).should == target
-
-    #Bitcoin.network = :dogecoin
-    #Bitcoin.decode_compact_bits( "01fedcba".to_i(16) ).to_i(16).should == -0x7e
-  end
-
-  it '#block_hash' do
-    # block 0  n_tx: 1
-    prev_block="0000000000000000000000000000000000000000000000000000000000000000"
-    mrkl_root ="4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
-    time, bits, nonce, ver = 1231006505, 486604799, 2083236893, 1
-
-    Bitcoin.block_hash(prev_block, mrkl_root, time, bits, nonce, ver).should ==
-      "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
-
-
-    # block 1  n_tx: 1
-    prev_block="000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
-    mrkl_root ="0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098"
-    time, bits, nonce, ver = 1231469665, 486604799, 2573394689, 1
-
-    Bitcoin.block_hash(prev_block, mrkl_root, time, bits, nonce, ver).should ==
-      "00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048"
-
-    #  .. only n_tx: 1
-
-    # block 169  n_tx: 1
-    prev_block="00000000567e95797f93675ac23683ae3787b183bb36859c18d9220f3fa66a69"
-    mrkl_root ="d7b9a9da6becbf47494c27e913241e5a2b85c5cceba4b2f0d8305e0a87b92d98"
-    time, bits, nonce, ver = 1231730523, 486604799, 3718213931, 1
-
-    Bitcoin.block_hash(prev_block, mrkl_root, time, bits, nonce, ver).should ==
-      "000000002a22cfee1f2c846adbd12b3e183d4f97683f85dad08a79780a84bd55"
-
-
-    # block 170  n_tx: 2
-    prev_block="000000002a22cfee1f2c846adbd12b3e183d4f97683f85dad08a79780a84bd55"
-    mrkl_root ="7dac2c5666815c17a3b36427de37bb9d2e2c5ccec3f8633eb91a4205cb4c10ff"
-    time, bits, nonce, ver = 1231731025, 486604799, 1889418792, 1
-
-    Bitcoin.block_hash(prev_block, mrkl_root, time, bits, nonce, ver).should ==
-      "00000000d1145790a8694403d4063f323d499e655c83426834d4ce2f8dd4a2ee"
-
-
-    # block 171  n_tx: 1
-    prev_block="00000000d1145790a8694403d4063f323d499e655c83426834d4ce2f8dd4a2ee"
-    mrkl_root ="d5f2d21453a6f0e67b5c42959c9700853e4c4d46fa7519d1cc58e77369c893f2"
-    time, bits, nonce, ver = 1231731401, 486604799, 653436935, 1
-    Bitcoin.block_hash(prev_block, mrkl_root, time, bits, nonce, ver).should ==
-      "00000000c9ec538cab7f38ef9c67a95742f56ab07b0a37c5be6b02808dbfb4e0"
-  end
-
-  it 'generates openssl-secp256k1 private/public keypair' do
-    private_key, public_key = Bitcoin.generate_key
-
-    private_key.size  .should == 64   # bytes in hex
-    public_key.size   .should == 130  # bytes in hex
-
-    key = Bitcoin.open_key(private_key, public_key)
-    Bitcoin.inspect_key( key ).should == [ private_key, public_key ]
-  end
-
-  begin
-    Bitcoin::OpenSSL_EC
-    it 'opens key from private key and resolves public key' do
-      50.times.all?{
-        private_key, public_key = Bitcoin.generate_key
-        key = Bitcoin.open_key(private_key)
-        [ key.private_key_hex, key.public_key_hex ] == [ private_key, public_key ]
-      }.should == true
-    end
-
-    it 'extract private key from uncompressed DER format' do
-      der = "308201130201010420a29fe0f28b2936dbc89f889f74cd1f0662d18a873ac15d6cd417b808db1ccd0aa081a53081a2020101302c06072a8648ce3d0101022100fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f300604010004010704410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8022100fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141020101a14403420004768cfc6c44b927b0e69e9dd343e96132f7cd1d360d8cb8d65c83d89d7beaceadfd19918e076606a099344156acdb026b1065a958e39f098cfd0a34dd976291d6"
-
-      Bitcoin::OpenSSL_EC.der_to_private_key(der).should == "a29fe0f28b2936dbc89f889f74cd1f0662d18a873ac15d6cd417b808db1ccd0a"
-    end
-
-    it 'sign and verify text messages (signmessage/verifymessage)' do
-      [
-        ["1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ", "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747",
-         "040b4c866585dd868a9d62348a9cd008d6a312937048fff31670e7e920cfc7a7447b5f0bba9e01e6fe4735c8383e6e7a3347a0fd72381b8f797a19f694054e5a69"],
-        ["1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs", "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747",
-         "030b4c866585dd868a9d62348a9cd008d6a312937048fff31670e7e920cfc7a744"]
-      ].each{|address, privkey, pubkey|
-        key = Bitcoin.open_key(privkey)
-        16.times.each { |n|
-        #10_000.times.all?{|n|
-        #  puts 'RAM USAGE: ' + `pmap #{Process.pid} | tail -1`[10,40].strip if (n % 1_000) == 0
-          s = Bitcoin.sign_message(key.private_key_hex, key.public_key_hex, "Very secret message %d: 11" % n)
-          Bitcoin.verify_message(s['address'], 'invalid-signature', s['message']).should == false
-          Bitcoin.verify_message(s['address'], s['signature'], s['message']).should == true
-        }
-      }
-
-      Bitcoin.network = :testnet3
-      Bitcoin.verify_message("mwPVMbZQgkpwJJt2YP3sLSgbEBQw3FWZSc", "H5GER0Nz+L7TPZMQzXtv0hnLSsyfPok9lkdHIv01vksREpEpOhTPTonU1xvyPAOIIKhU3++Ol+LaWKWmsfyxDXk=", "A"*500).should == true
-      Bitcoin.network = :bitcoin
-    end
-  rescue LoadError
-  end
-
-  it 'generates new bitcoin-address' do
-    address, private_key, public_key, hash160 = Bitcoin.generate_address
-
-    private_key.size  .should == 64   # bytes in hex
-    public_key.size   .should == 130  # bytes in hex
-    #Bitcoin.valid_address?(address).should == true # fix/extend
-    Bitcoin.hash160_to_address(Bitcoin.hash160(public_key)).should == address
-  end
-
-  it 'encodes and decodes base58' do
-    # fixtures from: https://github.com/bitcoin/bitcoin/blob/master/src/test/base58_tests.cpp
-    bin = [
-            "",
-            "\x61",
-            "\x62\x62\x62",
-            "\x63\x63\x63",
-            "\x73\x69\x6d\x70\x6c\x79\x20\x61\x20\x6c\x6f\x6e\x67\x20\x73\x74\x72\x69\x6e\x67",
-            "\x00\xeb\x15\x23\x1d\xfc\xeb\x60\x92\x58\x86\xb6\x7d\x06\x52\x99\x92\x59\x15\xae\xb1\x72\xc0\x66\x47",
-            "\x51\x6b\x6f\xcd\x0f",
-            "\xbf\x4f\x89\x00\x1e\x67\x02\x74\xdd",
-            "\x57\x2e\x47\x94",
-            "\xec\xac\x89\xca\xd9\x39\x23\xc0\x23\x21",
-            "\x10\xc8\x51\x1e",
-            "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-          ]
-    out = [
-            "",
-            "2g",
-            "a3gV",
-            "aPEr",
-            "2cFupjhnEsSn59qHXstmK2ffpLv2",
-            "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L",
-            "ABnLTmg",
-            "3SEo3LWLoPntC",
-            "3EFU7m",
-            "EJDM8drfXA6uyA",
-            "Rt5zm",
-            "1111111111"
-          ]
-
-    fixtures = bin.zip(out).map{|b,out| [ b.unpack("H*")[0], out ] }
-    #fixtures.each{|hex,out| p [hex, out, Bitcoin.encode_base58(hex), Bitcoin.decode_base58(out)] }
-    fixtures.all?{|hex,out| Bitcoin.encode_base58(hex) == out }.should == true
-    fixtures.all?{|hex,out| Bitcoin.decode_base58(out) == hex }.should == true
-  end
-
-  it '#block_next_retarget' do
-    Bitcoin.block_next_retarget(189408).should == 189503
-    Bitcoin.block_next_retarget(189503).should == 189503
-    Bitcoin.block_next_retarget(189504).should == 191519
-  end
-
-  it '#block_difficulty' do
-    Bitcoin.block_difficulty(436835377).should == "1751454.5353407"
-  end
-
-  it 'should calculate retarget difficulty' do
-    prev_height = 201599
-    prev_block_time = 1349227021
-    prev_block_bits = 0x1a05db8b
-    last_retarget_time = 1348092851
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    
-    Bitcoin.decode_compact_bits(new_difficulty.should) == Bitcoin.decode_compact_bits(0x1a057e08)
-  end
-
-  it '#block_hashes_to_win' do
-    Bitcoin.block_hashes_to_win(436835377).should == 7522554734795001
-  end
-
-  it '#block_probability' do
-    Bitcoin.block_probability(436835377).should ==
-      "0.0000000000000001329335625003267087884673003372881794348"
-  end
-
-  it '#block_average_hashing_time' do
-    Bitcoin.block_average_hashing_time(436835377, 630_000_000).should == 11940563
-  end
-
-  it '#block_average_mining_time' do
-    Bitcoin.block_average_mining_time(0x1a022fbe, 231337, 270.0, 1.0).should == 56.50855038530773 # days
-  end
-
-  it '#blockchain_total_btc' do
-    # 0.step(6930000, 210000){|height|
-    #   p total_btc(height-1) unless height == 0
-    #   p total_btc(height)
-    # }
-    [0, 209999, 210000, 419999, 420000, 1680000].map{|height|
-      Bitcoin.blockchain_total_btc(height)
-    }.should == [
-      [5000000000,       1, 5000000000,       0],
-      [1050000000000000, 1, 5000000000,  209999],
-      [1050005000000000, 2, 2500000000,  210000],
-      [1575002500000000, 2, 2500000000,  419999],
-      [1575005000000000, 3, 1250000000,  420000],
-      [2091801875000000, 9,   19531250, 1680000]
-    ]
-  end
-
-  it '#block_creation_reward' do
-    [0, 209999, 210000, 419999, 420000, 1680000].map{|height|
-      Bitcoin.block_creation_reward(height)
-    }.should == [ 5000000000, 5000000000, 2500000000, 2500000000, 1250000000, 19531250 ]
-  end
-
-  # Port of Bitcoin Core test vectors.
-  # https://github.com/bitcoin/bitcoin/blob/595a7bab23bc21049526229054ea1fff1a29c0bf/src/test/base58_tests.cpp#L139
-  it "valid address JSON tests" do
-    restore_network = Bitcoin.network_name
-
-    test_cases = JSON.parse(fixtures_file('base58_keys_valid.json'))
-    test_cases.each do |test_case|
-      # Single element arrays in tests are comments.
-      next if test_case.length == 1
-
-      address = test_case[0]
-      script = test_case[1].htb
-      is_privkey = test_case[2].fetch('isPrivkey')
-      is_swapcase_valid = test_case[2].fetch('tryCaseFlip', false)
-
-      Bitcoin.network =
-        case test_case[2].fetch('chain').to_sym
-        when :main then :bitcoin
-        when :test then :testnet3
-        when :regtest then :regtest
-        end
-
-      # This spec only tests address generation, not base58 private key encoding
-      next if is_privkey
-
-      computed_script = Bitcoin::Script.to_address_script(address)
-      computed_script.should == script
-
-      Bitcoin.valid_address?(address.swapcase).should == is_swapcase_valid
-
-      computed_address = Bitcoin::Script.new(script).get_address
-      computed_address.should == address
-    end
-
-    Bitcoin.network = restore_network
-  end
-
-  # Port of Bitcoin Core test vectors.
-  # https://github.com/bitcoin/bitcoin/blob/595a7bab23bc21049526229054ea1fff1a29c0bf/src/test/base58_tests.cpp#L179
-  it "invalid address JSON tests" do
-    restore_network = Bitcoin.network_name
-
-    test_cases = JSON.parse(fixtures_file('base58_keys_invalid.json'))
-    test_cases.each do |test_case|
-      address = test_case[0]
-
-      %i(bitcoin testnet3 regtest).each do |network_name|
-        Bitcoin.network = network_name
-
-        Bitcoin.valid_address?(address).should == false
-      end
-    end
-
-    Bitcoin.network = restore_network
-  end
-end
-
-
-__END__
-describe 'Bitcoin-Wiki - Common Standards - Hashes' do
-  # https://en.bitcoin.it/wiki/Protocol_specification
-  # Hashes
-  #  Usually, when a hash is computed within bitcoin, it is computed twice.
-  #  Most of the time SHA-256 hashes are used, however RIPEMD-160 is also
-  #  used when a shorter hash is desirable.
-
-  require 'digest/sha2'
-  require 'digest/rmd160'
-
-
-  it 'double-SHA-256 encoding of string "hello"' do
-     # first round sha256
-     Digest::SHA256.hexdigest("hello").should ==
-       "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
-
-     # second round sha256
-     Digest::SHA256.hexdigest( Digest::SHA256.digest("hello") ).should ==
-       "9595c9df90075148eb06860365df33584b75bff782a510c6cd4883a419833d50"
-  end
-
-  it 'RIPEMD-160 encoding of string "hello"' do
-     # first round sha256
-     Digest::SHA256.hexdigest("hello").should ==
-       "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
-
-     # second round rmd160
-     Digest::RMD160.hexdigest( Digest::SHA256.digest("hello") ).should ==
-       "b6a9c8c230722b7c748331a8b450f05566dc7d0f"
-  end
-end