bitcoin-ruby 0.0.6 → 0.0.7

data/spec/bitcoin/fixtures/freicoin-block-000000005d231b285e63af83edae2d8f5e50e70d396468643092b9239fd3be3c.json

@@ -1,43 +0,0 @@
-{
-  "hash":"000000005d231b285e63af83edae2d8f5e50e70d396468643092b9239fd3be3c",
-  "ver":2,
-  "prev_block":"000000005b1e3d23ecfd2dd4a6e1a35238aa0392c0a8528c40df52376d7efe2c",
-  "mrkl_root":"a0b9ec1d860e0786b0be7380eac76fe6180ca98b20aa03c08097bda1fbbce895",
-  "time":1356123634,
-  "bits":486604799,
-  "nonce":2536343301,
-  "n_tx":1,
-  "size":220,
-  "tx":[
-    {
-      "hash":"898cf5a16a1a40342fb193d0ec5dd9de13951c6121b95be96d88042d1e7fcc66",
-      "ver":2,
-      "vin_sz":1,
-      "vout_sz":2,
-      "lock_time":0,
-      "size":139,
-      "in":[
-        {
-          "prev_out":{
-            "hash":"0000000000000000000000000000000000000000000000000000000000000000",
-            "n":4294967295
-          },
-          "coinbase":"51010f062f503253482f"
-        }
-      ],
-      "out":[
-        {
-          "value":"254.53572875",
-          "scriptPubKey":"036c370a402c3e50063d3abd46d49ad174aae679bdc25f2a4ce5a3a4ca15b8b86e OP_CHECKSIG"
-        },
-        {
-          "value":"496.03174604",
-          "scriptPubKey":"OP_DUP OP_HASH160 85e54144c4020a65fa0a8fdbac8bba75dbc2fd00 OP_EQUALVERIFY OP_CHECKSIG"
-        }
-      ]
-    }
-  ],
-  "mrkl_tree":[
-    "898cf5a16a1a40342fb193d0ec5dd9de13951c6121b95be96d88042d1e7fcc66"
-  ]
-}

data/spec/bitcoin/fixtures/freicoin-genesis-block-000000005b1e3d23ecfd2dd4a6e1a35238aa0392c0a8528c40df52376d7efe2c.json

@@ -1,67 +0,0 @@
-{
-  "hash":"000000005b1e3d23ecfd2dd4a6e1a35238aa0392c0a8528c40df52376d7efe2c",
-  "ver":1,
-  "prev_block":"0000000000000000000000000000000000000000000000000000000000000000",
-  "mrkl_root":"f53b1baa971ea40be88cf51288aabd700dfec96c486bf7155a53a4919af4c8bd",
-  "time":1356123600,
-  "bits":486604799,
-  "nonce":278229610,
-  "n_tx":1,
-  "size":1374,
-  "tx":[
-    {
-      "hash":"cfc428c86c94c63341d5466b214afd01f3fa4db9471831c233138a257601b102",
-      "ver":2,
-      "vin_sz":1,
-      "vout_sz":8,
-      "lock_time":0,
-      "size":1293,
-      "in":[
-        {
-          "prev_out":{
-            "hash":"0000000000000000000000000000000000000000000000000000000000000000",
-            "n":4294967295
-          },
-          "coinbase":"04ffff001d01044554656c6567726170682032372f4a756e2f3230313220426172636c61797320686974207769746820c2a33239306d2066696e65206f766572204c69626f7220666978696e67"
-        }
-      ],
-      "out":[
-        {
-          "value":"254.53671561",
-          "scriptPubKey":"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f OP_CHECKSIG"
-        },
-        {
-          "value":"0.00000001",
-          "scriptPubKey":"5029d180e0c5ed798d877b1ada99772986c1422ca932c41b2d04000000000000 OP_DROP 0"
-        },
-        {
-          "value":"0.00000001",
-          "scriptPubKey":"202020 OP_DROP 4d6574616c73207765726520616e20696d706c696369746c7920616275736976652061677265656d656e742e0a4d6f6465726e2022706170657222206973206120666c6177656420746f6f6c2c2069747320656e67696e656572696e672069732061206e657374206f66206c6565636865732e0a546865206f6c64206d6f6e6579206973206f62736f6c6574652e0a4c65742074686520696e646976696475616c206d6f6e6574697a65206974732063726564697420776974686f75742063617274656c20696e7465726d65646961726965732e0a4769766520757320612072656e742d6c657373206361736820736f2077652063616e206265206672656520666f72207468652066697273742074696d652e0a4c65742074686973206265207468652061776169746564206461776e2e OP_DROP OP_DUP OP_HASH160 0ef0f9d19a653023554146a866238b8822bc84df OP_EQUALVERIFY OP_CHECKSIG"
-        },
-        {
-          "value":"0.00000001",
-          "scriptPubKey":"2020202020202020 OP_DROP 224c65742075732063616c63756c6174652c20776974686f757420667572746865722061646f2c20696e206f7264657220746f207365652077686f2069732072696768742e22202d2d476f747466726965642057696c68656c6d204c6569626e697a0acebec2b4efbda5e28880efbda560efbc89e38080e38080e38080e3808020206e0aefbfa3e38080e38080e380802020efbcbce38080e380802020efbc882045efbc8920676f6f64206a6f622c206d61616b75210aefbe8ce38080e38080e3808020202fe383bd20e383bd5fefbc8fefbc8f OP_DROP OP_DUP OP_HASH160 c26be5ec809aa4bf6b30aa89823cff7cedc3679a OP_EQUALVERIFY OP_CHECKSIG"
-        },
-        {
-          "value":"0.00000001",
-          "scriptPubKey":"202020202020 OP_DROP 4963682077c3bc6e736368652046726569636f696e207669656c204572666f6c67207a756d204e75747a656e206465722039392050726f7a656e7421 OP_DROP OP_DUP OP_HASH160 2939acd60037281a708eb11e4e9eda452c029eca OP_EQUALVERIFY OP_CHECKSIG"
-        },
-        {
-          "value":"0.00000001",
-          "scriptPubKey":"20202020202020202020202020 OP_DROP 225468652076616c7565206f662061206d616e2073686f756c64206265207365656e20696e207768617420686520676976657320616e64206e6f7420696e20776861742068652069732061626c6520746f20726563656976652e22202d2d416c626572742045696e737465696e OP_DROP OP_DUP OP_HASH160 f9ca5caab4bda4dc28b5556aa79a2eec0447f0bf OP_EQUALVERIFY OP_CHECKSIG"
-        },
-        {
-          "value":"0.00000001",
-          "scriptPubKey":"202020202020202020202020 OP_DROP 22416e2061726d79206f66207072696e6369706c65732063616e2070656e65747261746520776865726520616e2061726d79206f6620736f6c64696572732063616e6e6f742e22202d2d54686f6d6173205061696e65 OP_DROP OP_DUP OP_HASH160 08f320cbb41a1ae25b794f6175f96080681989f3 OP_EQUALVERIFY OP_CHECKSIG"
-        },
-        {
-          "value":"496.03174604",
-          "scriptPubKey":"OP_DUP OP_HASH160 85e54144c4020a65fa0a8fdbac8bba75dbc2fd00 OP_EQUALVERIFY OP_CHECKSIG"
-        }
-      ]
-    }
-  ],
-  "mrkl_tree":[
-    "cfc428c86c94c63341d5466b214afd01f3fa4db9471831c233138a257601b102"
-  ]
-}

data/spec/bitcoin/namecoin_spec.rb

@@ -1,182 +0,0 @@
-# encoding: ascii-8bit
-
-require_relative 'spec_helper.rb'
-require 'bitcoin/script'
-
-include Bitcoin
-include Bitcoin::Builder
-
-describe 'Bitcoin::Namecoin' do
-
-  describe :script do
-
-    before do
-      Bitcoin.network = :namecoin
-      @name_new = Script.from_string("3045022023686b3584247c07f483de4048f3d5136c4faa2f961a6d1e487eb77437422b51022100b1ea62910f2dbb0533d32bd661e8a212d129057d3d71620572278895dbb5c7b501
-          04b656d7be83e73344e298feba41b38c52ea50d4583ead0c947fd8019f75c906e0d810c5d167ee616c46d28d7cb5ca1d7a20a180470c9dad79524118bafe6cf569 1 820fa9c6d252d6773e4ef26a2feffa93f0237641 OP_2DROP OP_DUP OP_HASH160 eb86f8f23909e248d199192d8407881c3435a5db OP_EQUALVERIFY OP_CHECKSIG")
-      @name_firstupdate = Script.from_string("3044022054e1557304c504498f8d40b961373d7401a4e4c1650518db8a9c3a49ee9add7e022061573b2837598c346b21c01969081a309c055d5da23b0ac7e139a6290f2f0a4b01
-          04d2628245cdfc6ccf5a762d303ba8a10bd54d597cfdcbf0ac3823bae666a36bb744ed44a2384f42525e37b5b1150c5321718806c0f941904336588dd624f4ce93 2 642f626974636f696e a8c22832fb0d40e900 7b22696e666f223a7b22726567697374726172223a22687474703a2f2f72656769737465722e646f742d6269742e6f7267227d2c22656d61696c223a2022726567697374657240646f742d6269742e6f7267222c226e73223a5b226e73302e7765622d73776565742d7765622e6e6574222c226e73312e7765622d73776565742d7765622e6e6574225d2c226d6170223a7b22223a7b226e73223a5b226e73302e7765622d73776565742d7765622e6e6574222c226e73312e7765622d73776565742d7765622e6e6574225d7d7d7d OP_2DROP OP_2DROP OP_DUP OP_HASH160 f3f4aee9d80da759a4a3547cf6aa95c09881decb OP_EQUALVERIFY OP_CHECKSIG")
-      @name_update = Script.from_string("304402206a8598a87aadd697732d0a187220023e2b54e542e144d0dee67660c8ca3d66f4022000de36f02afb9162f2d27e947d452d4e28baadfdb21637db2b1f252ad62d7fb201
-          04b61d1529dbe912c84d0de898e88ab8a9d9fa4a13e76e7b60419dd3bd2b72021842bbf0f5eba1001d55f0c6f2c255289bedbe843d0164b545bbc056f150b4c3f2 3 642f626974636f696e 7b22696e666f223a7b22726567697374726172223a22687474703a2f2f72656769737465722e646f742d6269742e6f7267227d2c22656d61696c223a2022726567697374657240646f742d6269742e6f7267222c226e73223a5b226e73302e7765622d73776565742d7765622e6e6574222c226e73312e7765622d73776565742d7765622e6e6574225d2c226d6170223a7b22223a7b226e73223a5b226e73302e7765622d73776565742d7765622e6e6574222c226e73312e7765622d73776565742d7765622e6e6574225d7d7d7d OP_2DROP OP_DROP OP_DUP OP_HASH160 8f29c40b89ceda0b9176819e2bb5a15f592c6548 OP_EQUALVERIFY OP_CHECKSIG")
-    end
-
-    it 'should parse name_new script' do
-      @name_new.is_name_new?.should == true
-      @name_firstupdate.is_name_new?.should == false
-      @name_update.is_name_new?.should == false
-    end
-
-    it 'should parse name_firstupdate script' do
-      @name_new.is_name_firstupdate?.should == false
-      @name_firstupdate.is_name_firstupdate?.should == true
-      @name_update.is_name_firstupdate?.should == false
-    end
-
-    it 'should parse name_update script' do
-      @name_new.is_name_update?.should == false
-      @name_firstupdate.is_name_update?.should == false
-      @name_update.is_name_update?.should == true
-    end
-
-    it 'should run scripts' do
-      @name_new.run { true }.should == true
-      @name_firstupdate.run { true }.should == true
-      @name_update.run { true }.should == true
-    end
-
-    it 'should get name_hash' do
-      @name_new.get_namecoin_hash.should == "820fa9c6d252d6773e4ef26a2feffa93f0237641"
-    end
-
-    it 'should get name' do
-      @name_firstupdate.get_namecoin_name.should == "d/bitcoin"
-      @name_update.get_namecoin_name.should == "d/bitcoin"
-    end
-
-    it 'should get value' do
-      @name_firstupdate.get_namecoin_value.should == '{"info":{"registrar":"http://register.dot-bit.org"},"email": "register@dot-bit.org","ns":["ns0.web-sweet-web.net","ns1.web-sweet-web.net"],"map":{"":{"ns":["ns0.web-sweet-web.net","ns1.web-sweet-web.net"]}}}'
-      @name_update.get_namecoin_value.should == @name_firstupdate.get_namecoin_value
-    end
-
-    def set_rand rand; @rand = rand; end
-
-    it 'should create scripts' do
-      key = Key.generate
-      script = Script.to_name_new_script(self, "test/foo", key.addr)
-      Script.new(script).to_string.should =~
-        /^1 (.*?) OP_2DROP OP_DUP OP_HASH160 #{key.hash160} OP_EQUALVERIFY OP_CHECKSIG$/
-      @rand.should != nil
-
-      script = Script.to_name_firstupdate_script("test/foo", "1234", "testing", key.addr)
-      Script.new(script).to_string.should ==
-        "2 746573742f666f6f 1234 74657374696e67 OP_2DROP OP_2DROP " +
-        "OP_DUP OP_HASH160 #{key.hash160} OP_EQUALVERIFY OP_CHECKSIG"
-
-      script = Script.to_name_update_script("test/foo", "more testing", key.addr)
-      Script.new(script).to_string.should ==
-        "3 746573742f666f6f 6d6f72652074657374696e67 OP_2DROP OP_DROP " +
-        "OP_DUP OP_HASH160 #{key.hash160} OP_EQUALVERIFY OP_CHECKSIG"
-    end
-
-  end
-
-  [
-   { :name => :utxo, :db => 'sqlite:/', utxo_cache: 0 },
-   { :name => :sequel, :db => 'sqlite:/' },
-  ].each do |configuration|
-
-    describe "Namecoin (#{configuration[:name]} store)" do
-
-      before do
-        Bitcoin.network = :namecoin
-        Bitcoin.network[:no_difficulty] = true
-        class Bitcoin::Validation::Block; def min_timestamp; true; end; end
-        Bitcoin.network[:proof_of_work_limit] = Bitcoin.encode_compact_bits("ff"*32)
-        [:name_new, :name_firstupdate, :name_update].each {|type|
-          Bitcoin::Storage::Backends::SequelStore::SCRIPT_TYPES << type }
-        @store = Bitcoin::Storage.send(configuration[:name], configuration)
-        @store.reset
-        @store.log.level = :error
-        @key = Bitcoin::Key.generate
-        @block = create_block "00"*32, false, [], @key
-        Bitcoin.network[:genesis_hash] = @block.hash
-        @store.store_block(@block)
-      end
-
-      def set_rand r; @rand = r; end
-
-      it "should store names" do
-        # create name_new
-        @block = create_block @block.hash, true, [->(t) {
-          t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @key }
-          t.output {|o| o.value 50e8; o.script {|s| s.type(:name_new)
-            s.recipient(self, "test", @key.addr) } } }], @key
-        @store.db[:names][hash: Bitcoin.hash160(@rand + "test".hth)].should != nil
-
-        # name_firstupdate should not be valid yet
-        @block = create_block @block.hash, true, [->(t) {
-          t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @key }
-          t.output {|o| o.value 50e8; o.script {|s| s.type(:name_firstupdate)
-            s.recipient("test", @rand, "testvalue", @key.addr) } } }], @key
-        @store.name_show("test").should == nil
-
-        # create enough blocks for name_new to become valid
-        Namecoin::FIRSTUPDATE_LIMIT.times {
-          @block = create_block @block.hash, true, [], @key }
-
-        # name_firstupdate should be valid now
-        @block = create_block @block.hash, true, [->(t) {
-          t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @key }
-          t.output {|o| o.value 50e8; o.script {|s|; s.type(:name_firstupdate)
-            s.recipient("test", @rand, "testvalue", @key.addr) } } }], @key
-
-        name = @store.name_show("test")
-        name.get_address.should == @key.addr
-        name.name.should == "test"
-        name.value.should == "testvalue"
-        name.hash.should == Bitcoin.hash160(@rand + "test".hth)
-
-        # create name_update
-        @new_key = Bitcoin::Key.generate
-        @block = create_block @block.hash, true, [->(t) {
-          t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @key}
-            t.output {|o|o.value 50e8; o.script {|s| s.type(:name_update)
-              s.recipient("test", "testupdate", @new_key.addr) } } }], @new_key
-
-        name = @store.name_show("test")
-        name.get_address.should == @new_key.addr
-        name.value.should == "testupdate"
-
-        h = @store.name_history("test")
-        h.size.should == 2
-        h[0].value.should == "testvalue"
-        h[0].get_address.should == @key.addr
-        h[1].value.should == "testupdate"
-        h[1].get_address.should == @new_key.addr
-      end
-
-      it "should expire names" do
-        @block = create_block @block.hash, true, [->(t) {
-          t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @key }
-          t.output {|o| o.value 50e8; o.script {|s| s.type(:name_new)
-            s.recipient(self, "test", @key.addr) } } }], @key
-        @store.db[:names][hash: Bitcoin.hash160(@rand + "test".hth)].should != nil
-
-        # create enough blocks for name_new to become valid
-        Namecoin::FIRSTUPDATE_LIMIT.times {
-          @block = create_block @block.hash, true, [], @key }
-
-        # name_firstupdate should be valid now
-        @block = create_block @block.hash, true, [->(t) {
-          t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @key }
-          t.output {|o| o.value 50e8; o.script {|s|; s.type(:name_firstupdate)
-            s.recipient("test", @rand, "testvalue", @key.addr) } } }], @key
-
-        @store.name_show("test").expires_in.should == Namecoin::EXPIRATION_DEPTH
-        @block = create_block @block.hash, true, [], @key
-        @store.name_show("test").expires_in.should == Namecoin::EXPIRATION_DEPTH - 1
-      end
-
-    end
-  end
-end

data/spec/bitcoin/node/command_api_spec.rb

@@ -1,663 +0,0 @@
-require_relative '../spec_helper.rb'
-
-include Bitcoin
-include Builder
-
-class Array
-  def stringify_keys
-    map do |e|
-      (e.is_a?(Array) || e.is_a?(Hash)) ? e.stringify_keys : e
-    end
-  end
-end
-
-class Hash
-  def stringify_keys
-    Hash[map do |k, v|
-      v = v.stringify_keys  if v.is_a?(Hash) || v.is_a?(Array)
-      [k.to_s, v]
-    end]
-  end
-end
-
-describe 'Node Command API' do
-
-  TSLB_TIMEOUT = 3
-
-  def test_command command, params = nil, response = nil, &block
-    $responses = {}
-    EM.run do
-      @client = Bitcoin::Network::CommandClient.connect(*@config[:command]) do
-        on_connected do
-          request(command, params)
-        end
-        on_response do |cmd, data|
-          $responses[cmd] = data
-          EM.stop
-        end
-      end
-    end
-
-    result = $responses[command]
-
-    return result  unless response || block
-
-    if block
-      block.call(result)
-    else
-      raise "ERROR: #{result} != #{response}"  unless result.should == response
-    end
-  end
-
-
-  before do
-    Bitcoin::Validation::Block::RULES.merge({
-      syntax: [:hash, :tx_list, :bits, :max_timestamp, :coinbase, :coinbase_scriptsig, :transactions_syntax],
-      context: [:prev_hash, :coinbase_value, :min_timestamp, :transactions_context]
-    })
-
-    Bitcoin.network = :spec
-    @config = {
-      listen: ["127.0.0.1", 38333],
-      command: ["127.0.0.1", 38332],
-      storage: "sequel::sqlite:/",
-      dns: false,
-      intervals: { queue: 0.01 },
-      log: { network: :warn, storage: :warn },
-    }
-
-    @node = Bitcoin::Network::Node.new(@config)
-    @pid = fork do
-#      $stdout = StringIO.new
-      SimpleCov.running = false if defined?(SimpleCov)
-      @node.run
-    end
-
-    @genesis = P::Block.new("0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d1aa4ae180101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".htb)
-
-    Bitcoin.network[:proof_of_work_limit] = Bitcoin.encode_compact_bits("ff"*32)
-    @key = Bitcoin::Key.generate
-    @block = create_block @genesis.hash, false, [], @key
-
-    test_command "store_block", hex: @genesis.to_payload.hth
-    sleep 0.1
-
-    @id = 0
-  end
-
-  after do
-    Process.kill("TERM", @pid)
-  end
-
-  it "should return error for unknown command" do
-    test_command("foo", nil, {"error" => "unknown command: foo. send 'help' for help."})
-  end
-
-  # it "should return error for wrong parameters" do
-  #   test_command("info", "foo", {"error" => "wrong number of arguments (1 for 0)"})
-  # end
-
-  it "should query tslb" do
-    test_command("tslb") {|r| (0..TSLB_TIMEOUT).include?(r['tslb']).should == true }
-  end
-
-  it "should query info" do
-    info = test_command "info"
-    info.is_a?(Hash).should == true
-    info["blocks"].should == { "depth" => 0, "peers" => "?", "sync" => false }
-    info["addrs"].should == { "alive" => 0, "total" => 0 }
-    info["connections"].should == {
-      "established" => 0, "outgoing" => 0, "incoming" => 0, "connecting" => 0 }
-    info["queue"].should == 0
-    info["inv_queue"].should == 0
-    info["inv_cache"].should == 0
-    info["network"].should == "bitcoin"
-    info["storage"].should == "sequel::sqlite:/"
-    info["version"].should == 70001
-    info["external_ip"].should == "127.0.0.1"
-    info["uptime"].between?(0, 1).should == true
-  end
-
-  it "should query config" do
-    test_command("config").should == JSON.load(@node.config.to_json)
-  end
-
-  # TODO
-  it "should query connections" do
-    test_command("connections").should == []
-  end
-
-  # TODO
-  it "should connect" do
-    test_command("connect", {host: "127.0.0.1", port: 1234})["state"].should == "connecting"
-  end
-
-  # TODO
-  it "should disconnect" do
-    test_command("disconnect", ["127.0.0.1:1234"])["state"].should == "disconnected"
-  end
-
-  it "should store block" do
-    test_command("info")["blocks"].should == {"depth" => 0, "peers" => "?", "sync" => false}
-    res = test_command("store_block", { hex: @block.to_payload.hth })
-    res.should == { "queued" => @block.hash }
-    sleep 0.1
-    test_command("info")["blocks"]["depth"].should == 1
-    test_command("info")["blocks"]["sync"].should == true
-  end
-
-  # TODO
-  # it "should store tx" do
-  #   @tx = @block.tx[1]
-  #   res = test_command("store_tx", { hex: @tx.to_payload.htb })
-  #   res.should == { "queued" => @tx.hash }
-  # end
-
-  describe :create_tx do
-
-    before do
-      @key2 = Key.generate
-      test_command("store_block", hex: @block.to_payload.hth)
-      sleep 0.1
-    end
-
-    it "should create transaction from given private keys" do
-      res = test_command("create_tx", {
-          keys: [ @key.to_base58 ], 
-          recipients: [[@key2.addr, 10e8], [@key.addr, 40e8]]
-        })
-      tx = P::Tx.new(res["hex"].htb)
-      tx.hash.should == res["hash"]
-      tx.verify_input_signature(0, @block.tx[0]).should == true
-    end
-
-    it "should create unsigned transaction from given addresses" do
-      res = test_command("create_tx", {
-          keys: [ @key.addr ], 
-          recipients: [[@key2.addr, 10e8], [@key.addr, 40e8]]
-        })
-      tx = P::Tx.new(res["hex"].htb)
-      tx.hash.should == res["hash"]
-      tx.in[0].script_sig.should == ""
-      #-> { tx.verify_input_signature(0, @block.tx[0]) }.should.raise(TypeError)
-      tx.verify_input_signature(0, @block.tx[0]).should == false
-
-      res["missing_sigs"].each.with_index do |sig_data, idx|
-        sig_hash, sig_addr = *sig_data
-        sig_addr.should == @key.addr
-        sig = @key.sign(sig_hash.htb)
-        script_sig = Script.to_signature_pubkey_script(sig, @key.pub.htb)
-        tx.in[idx].script_sig_length = script_sig.bytesize
-        tx.in[idx].script_sig = script_sig
-      end
-
-      tx.verify_input_signature(0, @block.tx[0]).should == true
-    end
-
-    it "should create transaction from given pubkeys" do
-      res = test_command("create_tx", {
-          keys: [@key.pub], 
-          recipients: [[@key2.addr, 10e8], [@key.addr, 40e8]]
-        })
-      tx = P::Tx.new(res["hex"].htb)
-      tx.hash.should == res["hash"]
-      #-> { tx.verify_input_signature(0, @block.tx[0]) }.should.raise(TypeError)
-      tx.verify_input_signature(0, @block.tx[0]).should == false
-
-      res["missing_sigs"].each.with_index do |sig_data, idx|
-        sig_hash, sig_addr = *sig_data
-        sig_addr.should == @key.addr
-        sig = @key.sign(sig_hash.htb)
-        script_sig = Script.to_signature_pubkey_script(sig, @key.pub.htb)
-        tx.in[idx].script_sig_length = script_sig.bytesize
-        tx.in[idx].script_sig = script_sig
-      end
-
-      tx.verify_input_signature(0, @block.tx[0]).should == true
-    end
-
-  end
-
-  describe :assemble_tx do
-
-    it "should assemble tx from unsigned tx structure, signatures and pubkeys" do
-      tx = build_tx do |t|
-        t.input do |i|
-          i.prev_out @block.tx[0]
-          i.prev_out_index 0
-        end
-        t.output {|o| o.value 50e8; o.script {|s| s.recipient @key.addr } }
-      end
-      sig = @key.sign(tx.in[0].sig_hash)
-      test_command("store_block", hex: @block.to_payload.hth)
-      sleep 0.1
-      res = test_command("assemble_tx", {tx: tx.to_payload.hth, sig_pubs: [[sig.hth, @key.pub]]})
-      tx = Bitcoin::P::Tx.new(res["hex"].htb)
-      tx.hash.should == res["hash"]
-      tx.verify_input_signature(0, @block.tx[0]).should == true
-    end
-
-  end
-
-  describe :relay_tx do
-
-    it "should handle decoding error" do
-      res = test_command("relay_tx", hex: "foobar")
-      res["error"].should == "Error decoding transaction."
-    end
-
-    it "should handle syntax error" do
-      # create transaction with invalid output size
-      block = create_block(@block.hash, false, [->(t) {
-        create_tx(t, @block.tx[0], 0, [[22e14, @key]]) }], @key)
-      tx = block.tx[1]
-
-      error = test_command("relay_tx", hex: tx.to_payload.hth)
-      error["error"].should == "Transaction syntax invalid."
-      error["details"].should == ["output_values", [22e14, 21e14]]
-    end
-
-    it "should handle context error" do
-      # create transaction with invalid input
-      block = create_block(@block.hash, false, [->(t) {
-        create_tx(t, @block.tx[0], 0, [[25e8, @key]]) }], @key)
-      tx = block.tx[1]
-
-      error = test_command("relay_tx", hex: tx.to_payload.hth)
-      error["error"].should == "Transaction context invalid."
-      error["details"].should == ["prev_out", [[@block.tx[0].hash, 0]]]
-    end
-
-    it "should relay transaction" do
-      block = create_block(@block.hash, false, [->(t) {
-        create_tx(t, @block.tx[0], 0, [[25e8, @key]]) }], @key)
-      tx = block.tx[1]
-
-      test_command("store_block", hex: @block.to_payload.hth)
-      sleep 0.1
-      res = test_command("relay_tx", hex: tx.to_payload.hth, send: 1, wait: 0)
-      res["success"].should == true
-      res["hash"].should == tx.hash
-      res["propagation"].should == { "sent" => 1, "received" => 0, "percent" => 0.0 }
-    end
-
-  end
-
-  describe :monitor do
-
-    before do
-      @client = TCPSocket.new(*@config[:command])
-
-      def send method, params = nil, client = @client
-        request = { id: @id += 1, method: method, params: params }
-        client.write(request.to_json + "\x00")
-        request.stringify_keys
-      end
-
-      def should_receive request, expected, client = @client
-        expected = expected.stringify_keys  if expected.is_a?(Hash)
-        begin
-          Timeout.timeout(100) do
-            buf = ""
-            while b = client.read(1)
-              break  if b == "\x00"
-              buf << b
-            end
-            resp = JSON.load(buf)
-            expected = request.merge(result: expected).stringify_keys
-            expected.delete("params")
-            raise "ERROR: #{resp} != #{expected}"  unless resp.should == expected
-          end
-        rescue Timeout::Error
-          print " [TIMEOUT]"
-          :timeout.should == nil
-        end
-      end
-
-      def should_receive_block request, block, depth, client = @client
-        expected = { hash: block.hash, hex: block.to_payload.hth, depth: depth }
-        should_receive(request, expected, client)
-      end
-
-      def should_receive_tx request, tx, conf, client = @client
-        expected = { hash: tx.hash, nhash: tx.nhash, hex: tx.to_payload.hth, conf: conf }
-        should_receive(request, expected, client)
-      end
-
-      def should_receive_output request, tx, idx, conf, client = @client
-        expected = { hash: tx.hash, nhash: tx.nhash, idx: idx,
-          address: tx.out[idx].parsed_script.get_address, value: tx.out[idx].value, conf: conf }
-        should_receive(request, expected, client)
-      end
-
-      def store_block block
-        request = send("store_block", hex: block.to_payload.hth)
-        should_receive(request, {"queued" => block.hash })
-      end
-
-    end
-
-    describe :channels do
-
-      it "should combine multiple channels" do
-        should_receive r1 = send("monitor", channel: "block"), id: 0
-        should_receive r2 = send("monitor", channel: "tx", conf: 1), id: 1
-        store_block @block
-        should_receive_block(r1, @block, 1)
-        should_receive_tx(r2, @block.tx[0], 1)
-      end
-
-      it "should handle multiple clients" do
-        @client2 = TCPSocket.new(*@config[:command])
-        should_receive r1_1 = send("monitor", channel: "tx", conf: 1), id: 0
-        r1_2 = send("monitor", { channel: "block" }, @client2)
-        should_receive r1_2, { id: 0 }, @client2
-
-        store_block @block
-
-        should_receive_block(r1_2, @block, 1, @client2)
-        should_receive_tx(r1_1, @block.tx[0], 1)
-
-        block = create_block @block.hash, false
-        store_block block
-
-        should_receive_block(r1_2, block, 2, @client2)
-        should_receive_tx(r1_1, block.tx[0], 1)
-
-        r2_2 = send "monitor", { channel: "tx", conf: 1 }, @client2
-        should_receive r2_2, { id: 1 }, @client2
-        should_receive r2_1 = send("monitor", channel: "block"), id: 1
-
-        block = create_block block.hash, false
-        store_block block
-
-        should_receive_block(r1_2, block, 3, @client2)
-        should_receive_tx(r2_2, block.tx[0], 1, @client2)
-
-        should_receive_tx(r1_1, block.tx[0], 1)
-
-        # if something was wrong, we would now receive the last tx again
-
-        should_receive_block(r2_1, block, 3)
-
-        block = create_block block.hash, false
-        store_block block
-
-        should_receive_tx(r1_1, block.tx[0], 1)
-
-        should_receive_block(r2_1, block, 4)
-        should_receive_block(r1_2, block, 4, @client2)
-        should_receive_tx(r2_2, block.tx[0], 1, @client2)
-      end
-
-    end
-
-    describe :block do
-
-      before do
-        @request = send "monitor", channel: "block"
-        
-        should_receive(@request, id: 0)
-        store_block @block
-        should_receive_block(@request, @block, 1)
-      end
-
-      it "should monitor block" do
-        @block = create_block @block.hash, false
-        store_block @block
-        should_receive_block(@request, @block, 2)
-      end
-
-      it "should unmonitor block" do
-        @request = send "unmonitor", id: 0
-        should_receive @request, id: 0
-        store_block create_block(@block.hash, false)
-
-        test_command("tslb") {|r| (0..TSLB_TIMEOUT).include?(r['tslb']).should == true }
-      end
-
-      it "should not monitor side or orphan blocks" do
-        @side = create_block @genesis.hash, false
-        store_block @side
-
-        @orphan = create_block "00" * 32, false
-        store_block @orphan
-
-        # should not send side or orphan block only the next main block
-        @block = create_block @block.hash, false
-        store_block @block
-
-        should_receive_block(@request, @block, 2)
-      end
-
-      it "should received missed blocks when last block hash is given" do
-        @client = TCPSocket.new(*@config[:command])
-        blocks = [@block]
-        3.times do
-          blocks << create_block(blocks.last.hash, false)
-          store_block blocks.last
-        end
-        sleep 0.1
-
-        r = send "monitor", channel: "block", last: blocks[1].hash
-
-        should_receive_block(r, blocks[1], 2)
-        should_receive_block(r, blocks[2], 3)
-        should_receive_block(r, blocks[3], 4)
-      end
-
-    end
-
-    describe :reorg do
-
-      before do
-        @request = send "monitor", channel: "reorg"
-        should_receive @request, id: 0
-        store_block @block
-      end
-
-      it "should monitor reorg" do
-        @block1 = create_block @genesis.hash, false
-        store_block @block1
-        @block2 = create_block @block1.hash, false
-        store_block @block2
-        should_receive @request, { new_main: [ @block1.hash ], new_side: [ @block.hash ] }
-      end
-
-      it "should unmonitor reorg" do
-        r = send "unmonitor", id: 0
-        should_receive r, id: 0
-        @block1 = create_block @genesis.hash, false
-        store_block @block1
-        @block2 = create_block @block1.hash, false
-        store_block @block2
-
-        test_command("tslb") {|r| (0..TSLB_TIMEOUT).include?(r['tslb']).should == true }
-      end
-
-    end
-
-    describe :tx do
-
-
-      it "should monitor unconfirmed tx" do
-        r1 = send "monitor", channel: "tx"
-        should_receive r1, id: 0
-        tx = @block.tx[0]
-        r2 = send "store_tx", hex: tx.to_payload.hth
-        should_receive r2, { "queued" => tx.hash }
-
-        should_receive_tx(r1, tx, 0)
-      end
-
-      it "should unmonitor tx" do
-        r1 = send "monitor", channel: "tx"
-        should_receive r1, id: 0
-
-        r2 = send "unmonitor", id: 0
-        should_receive r2, id: 0
-
-        tx = @block.tx[0]
-        r3 = send "store_tx", hex: tx.to_payload.hth
-        should_receive r3, { "queued" => tx.hash }
-
-        test_command("tslb") {|r| (0..TSLB_TIMEOUT).include?(r['tslb']).should == true }
-      end
-
-      it "should monitor confirmed tx" do
-        r = send "monitor", channel: "tx", conf: 1
-        should_receive r, id: 0
-        store_block @block
-
-        should_receive_tx(r, @block.tx[0], 1)
-      end
-
-      it "should monitor tx for given confirmation level" do
-        r = send "monitor", channel: "tx", conf: 3
-        should_receive r, id: 0
-
-        @tx = @block.tx[0]
-        store_block @block
-        @block = create_block @block.hash, false
-        store_block @block
-
-        should_receive_tx(r, @genesis.tx[0], 3)
-
-        @block = create_block @block.hash, false
-        store_block @block
-
-        should_receive_tx(r, @tx, 3)
-      end
-
-      it "should receive missed txs when last txhash is given" do
-        @client = TCPSocket.new(*@config[:command])
-        blocks = [@block]; store_block @block
-        3.times do
-          blocks << create_block(blocks.last.hash, false)
-          store_block blocks.last
-        end
-        sleep 0.1
-
-        r = send "monitor", channel: "tx", conf: 1, last: blocks[0].tx[0].hash
-
-        should_receive_tx(r, blocks[1].tx[0], 3)
-        should_receive_tx(r, blocks[2].tx[0], 2)
-        should_receive_tx(r, blocks[3].tx[0], 1)
-
-        should_receive r, id: 0
-      end
-
-
-      it "should filter txs for given addresses" do
-        @key2 = Bitcoin::Key.generate
-        block = create_block(@block.hash, false, [->(t) {
-              create_tx(t, @block.tx[0], 0, [[50e8, @key2]]) }], @key)
-        @addr = @block.tx[0].out[0].parsed_script.get_address
-        r = send "monitor", channel: "tx", conf: 1, addresses: [ @key2.addr ]
-        should_receive r, id: 0
-        store_block @block
-        store_block block
-        should_receive_tx(r, block.tx[1], 1)
-      end
-
-    end
-
-    describe :output do
-
-      before do
-        @tx = @block.tx[0]; @out = @tx.out[0]
-      end
-
-      it "should monitor unconfirmed outputs" do
-        r1 = send "monitor", channel: "output"
-        should_receive r1, id: 0
-        tx = @block.tx[0]
-        r2 = send "store_tx", hex: tx.to_payload.hth
-        should_receive r2, { "queued" => tx.hash }
-        should_receive_output(r1, tx, 0, 0)
-      end
-
-      it "should unmonitor outputs" do
-        should_receive send("monitor", channel: "output"), id: 0
-        should_receive send("unmonitor", id: 0), id: 0
-
-        tx = @block.tx[0]
-        r2 = send "store_tx", hex: tx.to_payload.hth
-        should_receive r2, { "queued" => tx.hash }
-
-        test_command("tslb") {|r| (0..TSLB_TIMEOUT).include?(r['tslb']).should == true }
-      end
-
-      it "should monitor confirmed output" do
-        r = send "monitor", channel: "output", conf: 1
-        should_receive r, id: 0
-        store_block @block
-        should_receive_output(r, @tx, 0, 1)
-      end
-
-      it "should monitor output for given confirmation level" do
-        r = send "monitor", channel: "output", conf: 3
-        should_receive r, id: 0
-        store_block @block
-        @block = create_block @block.hash, false
-        store_block @block
-        tx = @genesis.tx[0]; out = tx.out[0]
-        should_receive_output(r, tx, 0, 3)
-
-        @block = create_block @block.hash, false
-        store_block @block
-        should_receive_output(r, @tx, 0, 3)
-      end
-
-      it "should receive missed outputs when last txhash:idx is given" do
-        @key = Bitcoin::Key.generate
-        @client = TCPSocket.new(*@config[:command])
-        blocks = [@block]; store_block @block
-        3.times do
-          blocks << create_block(blocks.last.hash, false, [], @key)
-          store_block blocks.last
-        end
-        sleep 0.1
-
-        r = send "monitor", channel: "output", conf: 1, last: "#{blocks[0].tx[0].hash}:0"
-
-        should_receive_output(r, blocks[1].tx[0], 0, 3)
-        should_receive_output(r, blocks[2].tx[0], 0, 2)
-        should_receive_output(r, blocks[3].tx[0], 0, 1)
-
-        should_receive r, id: 0
-      end
-
-      it "should filter outputs for given addresses" do
-        @key2 = Bitcoin::Key.generate
-        block = create_block(@block.hash, false, [->(t) {
-              create_tx(t, @block.tx[0], 0, [[50e8, @key2]]) }], @key)
-
-        r = send "monitor", channel: "output", conf: 1, addresses: [ @key2.addr ]
-        should_receive r, id: 0
-        store_block @block
-        store_block block
-        should_receive_output(r, block.tx[1], 0, 1)
-      end
-
-      it "should add filter address to output monitor params" do
-        @key2 = Bitcoin::Key.generate
-        block = create_block(@block.hash, false, [->(t) {
-              create_tx(t, @block.tx[0], 0, [[50e8, @key2]]) }], @key)
-
-        r1 = send "monitor", channel: "output", conf: 1, addresses: [  ]
-        should_receive r1, id: 0
-
-        r2 = send "filter_monitor_output", id: 0, address: @key2.addr
-        should_receive r2, id: 0
-
-        store_block @block
-        store_block block
-        should_receive_output(r1, block.tx[1], 0, 1)
-      end
-
-    end
-
-  end
-
-end