bitcoin-ruby 0.0.1

data/spec/bitcoin/protocol/version_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../spec_helper.rb'
+
+describe 'Bitcoin::Protocol::Parser (version)' do
+
+  class Version_Handler < Bitcoin::Protocol::Handler
+    attr_reader :pkt
+    def on_version(pkt)
+      @pkt = pkt
+    end
+  end
+
+  it 'parses version packets' do
+    pkt = Bitcoin::Protocol.pkt("version",
+      ["60ea00000100000000000000b3c1424f00000000010000000000000000000000000000000000ffff7f000001e1ca010000000000000000000000000000000000ffff7f000001479d9525d0c7b30688ae122f626974636f696e2d71743a302e362e302f82b60000"].pack("H*"))
+
+    parser = Bitcoin::Protocol::Parser.new( handler = Version_Handler.new )
+    parser.parse(pkt + "AAAA").should == "AAAA"
+
+    pkt = handler.pkt
+    pkt.fields.should == {
+      :version     => 60000,
+      :services    => "\x01\x00\x00\x00\x00\x00\x00\x00",
+      :time        => 1329775027,
+      :from        => "127.0.0.1:18333",
+      :to          => "127.0.0.1:57802",
+      :nonce       => 12576309328653329813,
+      :user_agent  => "/bitcoin-qt:0.6.0/",
+      :last_block  => 46722
+    }
+
+    pkt = [
+      "f9 be b4 d9 76 65 72 73 69 6f 6e 00 00 00 00 00 55 00 00 00 a4 c2 08 cb 40 9c 00 00 01 00 00 00 00 00 00 00 10 42 c9 4e 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ff 7f 00 00 01 04 d2 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ff 7f 00 00 01 47 9d 4b b8 bb 21 ae d7 f0 71 00 fa 00 00 00"
+        .split(" ").join].pack("H*")
+
+
+    parser = Bitcoin::Protocol::Parser.new( handler = Version_Handler.new )
+    parser.parse(pkt + "AAAA").should == "AAAA"
+
+    pkt = handler.pkt
+    pkt.fields.should == {
+      :version     => 40000,
+      :services    => "\x01\x00\x00\x00\x00\x00\x00\x00",
+      :time        => 1321812496,
+      :from        => "127.0.0.1:18333",
+      :to          => "127.0.0.1:1234",
+      :nonce       => 8210299263586646091,
+      :user_agent  => nil,
+      :last_block  => 250
+    }
+  end
+
+  it 'creates version packets' do
+    version = Bitcoin::Protocol::Version.new({
+      :time       => 1337,
+      :from       => "127.0.0.1:8333",
+      :to         => "127.0.0.1:1234",
+      :nonce      => 123,
+      :last_block => 188617,
+    })
+
+    parser = Bitcoin::Protocol::Parser.new( handler = Version_Handler.new )
+    parser.parse( version.to_pkt )
+
+    pkt = handler.pkt
+    pkt.fields.should == {
+      :version    => Bitcoin::Protocol::VERSION,
+      :services    => "\x01\x00\x00\x00\x00\x00\x00\x00",
+      :time       => 1337,
+      :to         => "127.0.0.1:8333",
+      :from       => "127.0.0.1:1234",
+      :nonce      => 123,
+      :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
+      :last_block => 188617
+    }
+  end
+
+end

data/spec/bitcoin/reorg_spec.rb

@@ -0,0 +1,129 @@
+require_relative 'spec_helper'
+
+include Bitcoin::Builder
+
+describe "reorg" do
+
+  def create_block prev, store = true
+    block = blk do |b|
+      b.prev_block prev
+      b.tx do |t|
+        t.input {|i| i.coinbase }
+        t.output do |o|
+          o.value 5000000000
+          o.script {|s| s.type :address; s.recipient Bitcoin::Key.generate.addr }
+        end
+      end
+    end
+    @store.store_block(block)  if store
+    block
+  end
+
+  def balance addr
+    @store.get_balance(Bitcoin.hash160_from_address(addr))
+  end
+
+  before do
+    Bitcoin.network = :testnet
+    @store = Bitcoin::Storage.sequel(:db => "sqlite:/")
+    @store.log.level = :warn
+    @block0 = Bitcoin::Protocol::Block.new(fixtures_file('testnet/block_0.bin'))
+    @store.store_block(@block0)
+  end
+
+  it "should reorg a single side block" do
+    @store.get_head.should == @block0
+
+    block1 = create_block @block0.hash
+    @store.get_head.should == block1
+
+    block2_0 = create_block block1.hash
+    @store.get_head.should == block2_0
+
+    block2_1 = create_block block1.hash
+    @store.get_head.should == block2_0
+
+    block3 = create_block block2_1.hash
+    @store.get_head.should == block3
+    @store.get_block_by_depth(2).hash.should == block2_1.hash
+  end
+
+  it "should reorg two side blocks" do
+    block1 = create_block @block0.hash
+    @store.get_head.should == block1
+
+    block2_0 = create_block block1.hash
+    @store.get_head.should == block2_0
+
+    block2_1 = create_block block1.hash
+    @store.get_head.should == block2_0
+
+    block3_1 = create_block block2_1.hash
+    @store.get_head.should == block3_1
+
+    block3_0 = create_block block2_0.hash
+    @store.get_head.should == block3_1
+
+    block4 = create_block block3_0.hash
+    @store.get_head.should == block4
+  end
+
+  it "should reconnect orphans" do
+    blocks = [@block0]
+    3.times { blocks << create_block(blocks.last.hash, false) }
+
+    {
+      [0, 1, 2, 3] => [0, 1, 2, 3],
+      [0, 1, 3, 2] => [0, 1, 1, 3],
+      [0, 3, 2, 1] => [0, 0, 0, 3],
+      [0, 3, 1, 2] => [0, 0, 1, 3],
+      [0, 2, 3, 1] => [0, 0, 0, 3],
+    }.each do |order, result|
+      @store.reset
+      order.each_with_index do |n, i|
+        @store.store_block(blocks[n])
+        @store.get_head.should == blocks[result[i]]
+      end
+    end
+
+    i = 3; (0..i).to_a.permutation.each do |order|
+      @store.reset
+      order.each {|n| @store.store_block(blocks[n]) }
+      @store.get_head.should == blocks[i]
+    end
+  end
+
+  it "should handle existing blocks" do
+    Bitcoin.network = :testnet
+    blocks = [@block0]
+    3.times { blocks << create_block(blocks.last.hash, false) }
+    3.times do
+      @store.store_block(blocks[1]).should == [1, 0]
+      @store.store_block(blocks[2]).should == [2, 0]
+      @store.get_head.should == blocks[2]
+    end
+  end
+
+  # see https://bitcointalk.org/index.php?topic=46370.0
+  it "should pass reorg unit tests" do
+    Bitcoin.network = :bitcoin
+    @store.import "./spec/bitcoin/fixtures/reorg/blk_0_to_4.dat"
+    @store.get_depth.should == 4
+    @store.get_head.hash.should =~ /000000002f264d65040/
+    balance("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa").should == 10000000000
+    balance("1NiEGXeURREqqMjCvjCeZn6SwEBZ9AdVet").should == 0
+    balance("1KXFNhNtrRMfgbdiQeuJqnfD7dR4PhniyJ").should == 5000000000
+    balance("1JyMKvPHkrCQd8jQrqTR1rBsAd1VpRhTiE").should == 10000000000
+    @store.import "./spec/bitcoin/fixtures/reorg/blk_3A.dat"
+    @store.import "./spec/bitcoin/fixtures/reorg/blk_4A.dat"
+    @store.get_head.hash.should =~ /000000002f264d65040/
+    @store.import "./spec/bitcoin/fixtures/reorg/blk_5A.dat"
+    @store.get_depth.should == 5
+    @store.get_head.hash.should =~ /00000000195f85184e7/
+    balance("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa").should == 15000000000
+    balance("1NiEGXeURREqqMjCvjCeZn6SwEBZ9AdVet").should == 1000000000
+    balance("1KXFNhNtrRMfgbdiQeuJqnfD7dR4PhniyJ").should == 0
+    balance("1JyMKvPHkrCQd8jQrqTR1rBsAd1VpRhTiE").should == 14000000000
+  end
+
+end

data/spec/bitcoin/script/opcodes_spec.rb

@@ -0,0 +1,417 @@
+require_relative '../spec_helper.rb'
+require 'bitcoin/script'
+
+describe "Bitcoin::Script OPCODES" do
+
+  before do
+    @script = Bitcoin::Script.new("")
+    @script.class.instance_eval { attr_accessor :stack, :stack_alt }
+    @script.stack << "foobar"
+  end
+
+  def op(op, stack)
+    @script.stack = stack
+    @script.send("op_#{op}")
+    @script.stack
+  end
+
+  it "should do OP_NOP" do
+    @script.op_nop
+    @script.stack.should == ["foobar"]
+  end
+
+  it "should do OP_DUP" do
+    @script.op_dup
+    @script.stack.should == ["foobar", "foobar"]
+  end
+
+  it "should do OP_SHA256" do
+    @script.op_sha256
+    @script.stack.should ==
+      [["c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2"].pack("H*")]
+  end
+
+  it "should do OP_SHA1" do
+    @script.op_sha1
+    @script.stack.should ==
+      [["8843d7f92416211de9ebb963ff4ce28125932878"].pack("H*")]
+  end
+
+  it "should do OP_HASH160" do
+    @script.op_hash160
+    @script.stack.should ==
+      [["f6c97547d73156abb300ae059905c4acaadd09dd"].pack("H*")]
+  end
+
+  it "should do OP_RIPEMD160" do
+    @script.op_ripemd160
+    @script.stack.should ==
+      [["a06e327ea7388c18e4740e350ed4e60f2e04fc41"].pack("H*")]
+  end
+
+  it "should do OP_HASH256" do
+    @script.op_hash256
+    @script.stack.should ==
+      [["3f2c7ccae98af81e44c0ec419659f50d8b7d48c681e5d57fc747d0461e42dda1"].pack("H*")]
+  end
+
+  it "should do OP_TOALTSTACK" do
+    @script.op_toaltstack
+    @script.stack.should == []
+    @script.stack_alt.should == ["foobar"]
+  end
+
+  it "should do OP_FROMALTSTACK" do
+    @script.instance_eval { @stack_alt << "barfoo" }
+    @script.op_fromaltstack
+    @script.stack.should == ["foobar", "barfoo"]
+    @script.stack_alt.should == []
+  end
+
+  it "should do OP_TUCK" do
+    @script.instance_eval { @stack += ["foo", "bar"] }
+    @script.op_tuck
+    @script.stack.should == ["foobar", "bar", "foo", "bar"]
+  end
+
+  it "should do OP_SWAP" do
+    @script.instance_eval { @stack << "barfoo" }
+    @script.op_swap
+    @script.stack.should == ["barfoo", "foobar"]
+  end
+
+  it "should do OP_BOOLAND" do
+    op(:booland, [0, 0]).should == [0]
+    op(:booland, [0, 1]).should == [0]
+    op(:booland, [1, 0]).should == [0]
+    op(:booland, [1, 1]).should == [1]
+  end
+
+  it "should do OP_ADD" do
+    op(:add, [0, 1]).should == [1]
+    op(:add, [3, 4]).should == [7]
+    op(:add, [5,-4]).should == [1]
+  end
+
+  it "should do OP_SUB" do
+    op(:sub, [2, 3]).should == [1]
+    op(:sub, [1, 9]).should == [8]
+    op(:sub, [3, 1]).should == [-2]
+  end
+
+  it "should do OP_GREATERTHANOREQUAL" do
+    op(:greaterthanorequal, [1, 2]).should == [1]
+    op(:greaterthanorequal, [2, 2]).should == [1]
+    op(:greaterthanorequal, [2, 1]).should == [0]
+  end
+
+  it "should do OP_DROP" do
+    @script.op_drop
+    @script.stack.should == []
+  end
+
+  it "should do OP_EQUAL" do
+    op(:equal, [1,2]).should == [0]
+    op(:equal, [1,1]).should == [1]
+  end
+
+  it "should do OP_VERIFY" do
+    op(:verify, [1]).should == []
+    op(:verify, [0]).should == [0]
+  end
+
+  it "should do OP_EQUALVERIFY" do
+    op(:equalverify, [1,2]).should == [0]
+    @script.invalid?.should == true
+    op(:equalverify, [1,1]).should == []
+    @script.invalid?.should == false
+  end
+
+  it "should do OP_0" do
+    @script.op_0
+    @script.stack.should == ["foobar", ""]
+  end
+
+  it "should do OP_1" do
+    @script.op_1
+    @script.stack.should == ["foobar", 1]
+  end
+
+  it "should do OP_MIN" do
+    [
+      [4, 5], [5, 4], [4, 4]
+    ].each{|s|
+      @script.instance_eval { @stack = s }
+      @script.op_min
+      @script.stack.should == [4]
+    }
+  end
+
+  it "should do OP_MAX" do
+    [
+      [4, 5], [5, 4], [5, 5]
+    ].each{|s|
+      @script.instance_eval { @stack = s }
+      @script.op_max
+      @script.stack.should == [5]
+    }
+  end
+  
+  it "should do op_2over" do
+    @script.instance_eval { @stack = [1,2,3,4] }
+    @script.op_2over
+    @script.stack.should == [1,2,3,4,1,2]
+  end
+  
+  it "should do op_2swap" do
+    @script.instance_eval { @stack = [1,2,3,4] }
+    @script.op_2swap
+    @script.stack.should == [3,4,1,2]
+  end
+  
+  it "should do op_ifdup" do
+    @script.instance_eval { @stack = [1] }
+    @script.op_ifdup
+    @script.stack.should == [1,1]
+    
+    @script.instance_eval { @stack = ['a'] }
+    @script.op_ifdup
+    @script.stack.should == ['a','a']
+    
+    @script.instance_eval { @stack = [0] }
+    @script.op_ifdup
+    @script.stack.should == [0]
+  end
+
+  it "should do op_1negate" do
+    @script.instance_eval { @stack = [] }
+    @script.op_1negate
+    @script.stack.should == [ -1 ]
+  end
+  
+  it "should do op_depth" do
+    @script.instance_eval { @stack = [] }
+    @script.op_depth
+    @script.stack.should == [0]
+    
+    @script.instance_eval { @stack = [1,2,3] }
+    @script.op_depth
+    @script.stack.should == [1,2,3,3]
+  end
+
+  it "should do OP_CHECKSIG" do
+    @script.stack = ["bar", "foo"]
+    verify_callback = proc{|pubkey,signature,type|
+      pubkey   .should == "foo"
+      signature.should == "ba"
+      type     .should == "r".ord
+      true
+    }
+    @script.op_checksig(verify_callback).should == [1]
+
+    @script.stack = ["bar", "foo"]
+    verify_callback = proc{ true }
+    @script.op_checksig(verify_callback).should == [1]
+
+    @script.stack = ["bar", "foo"]
+    verify_callback = proc{ false }
+    @script.op_checksig(verify_callback).should == [0]
+
+    @script.stack = ["foo"]
+    verify_callback = proc{ false }
+    @script.op_checksig(verify_callback).should == nil
+
+
+    pubkey    = ["04324c6ebdcf079db6c9209a6b715b955622561262cde13a8a1df8ae0ef030eaa1552e31f8be90c385e27883a9d82780283d19507d7fa2e1e71a1d11bc3a52caf3"].pack("H*")
+    signature = ["304402202c2fb840b527326f9bbc7ce68c6c196a368a38864b5a47681352c4b2f416f7ed02205c4801cfa8aed205f26c7122ab5a5934fcf7a2f038fd130cdd8bcc56bdde0a00"].pack("H*")
+    hash_type = [1].pack("C")
+    signature_data = ["20245059adb84acaf1aa942b5d8a586da7ba76f17ecb5de4e7543e1ce1b94bc3"].pack("H*")
+
+    @script.stack = [signature + hash_type, pubkey]
+    verify_callback = proc{|pub,sig,hash_type|
+      pub     .should == pubkey
+      sig     .should == signature
+      hash_type.should == 1
+
+      hash = signature_data
+      Bitcoin.verify_signature( hash, sig, pub.unpack("H*")[0] )
+    }
+    @script.op_checksig(verify_callback).should == [1]
+
+
+    @script.stack = [signature + hash_type, pubkey]
+    verify_callback = proc{|pub,sig,hash_type|
+      hash = "foo" + signature_data
+      Bitcoin.verify_signature( hash, sig, pub.unpack("H*")[0] )
+    }
+    @script.op_checksig(verify_callback).should == [0]
+
+    @script.stack = [signature + hash_type, pubkey]
+    verify_callback = proc{|pub,sig,hash_type|
+      hash = signature_data
+      Bitcoin.verify_signature( hash, "foo", pub.unpack("H*")[0] )
+    }
+    @script.op_checksig(verify_callback).should == [0]
+
+    @script.stack = [signature + hash_type, pubkey]
+    verify_callback = proc{|pub,sig,hash_type|
+      hash = signature_data
+      Bitcoin.verify_signature( hash, sig, "foo" )
+    }
+    @script.op_checksig(verify_callback).should == [0]
+
+    # Bitcoin::Key API
+    key = Bitcoin::Key.new; key.generate
+    sig = (key.sign("foobar") + "\x01").unpack("H*")[0]
+    script = Bitcoin::Script.from_string("#{sig} #{key.pub} OP_CHECKSIG")
+    script.run{|pk, sig, hash_type|
+      k = Bitcoin::Key.new nil, pk.unpack("H*")[0]
+      k.verify("foobar", sig)
+    }.should == true
+    script.stack.should == []
+  end
+
+  def run_script(string, hash)
+    script = Bitcoin::Script.from_string(string)
+    script.run do |pk, sig, hash_type|
+      k = Bitcoin::Key.new nil, pk.unpack("H*")[0]
+      k.verify(hash, sig) rescue false
+    end == true
+  end
+
+  it "should do OP_CHECKMULTISIG" do
+    k1 = Bitcoin::Key.new; k1.generate
+    k2 = Bitcoin::Key.new; k2.generate
+    k3 = Bitcoin::Key.new; k3.generate
+    sig1 = (k1.sign("foobar") + "\x01").unpack("H*")[0]
+    sig2 = (k2.sign("foobar") + "\x01").unpack("H*")[0]
+    sig3 = (k3.sign("foobar") + "\x01").unpack("H*")[0]
+
+    script = "0 #{sig1} #{sig2} 2 #{k1.pub} #{k2.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == true
+
+    script = "0 #{sig1} #{sig2} 2 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == true
+
+    script = "0 #{sig2} #{sig3} 2 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == true
+
+    script = "0 #{sig1} #{sig2} #{sig3} 3 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == true
+
+    script = "#{sig1} #{sig2} #{sig3} 3 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG" # without OP_NOP
+    run_script(script, "foobar").should == true
+
+    script = "0 #{sig2} 1 #{k1.pub} #{k2.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == true
+
+    script = "0 #{sig2} OP_TRUE #{k1.pub} #{k2.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == true
+
+    script = "0 #{sig1} #{sig2} #{sig3} 3 #{k1.pub} #{k2.pub} #{k3.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 #{sig1} #{sig2} #{sig3} 3 #{k2.pub} #{k3.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 #{sig1} #{sig2} #{sig3} 3 2 #{k3.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 #{sig1} #{sig2} #{sig3} 3 0 #{k3.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 #{sig1} #{sig2} 2 3 #{k2.pub} #{k3.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 #{sig1} #{sig2} 0 3 #{k2.pub} #{k3.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 #{sig2} f0f0f0f0 2 #{k1.pub} #{k2.pub} 2 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 afafafaf #{sig2} 2 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    script = "0 #{sig1} f0f0f0f0 #{sig3} 3 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    run_script(script, "foobar").should == false
+
+    # # TODO: check signature order; these assertions should fail:
+    # script = "0 #{sig2} #{sig1} 2 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    # run_script(script, "foobar").should == false
+    # script = "0 #{sig3} #{sig2} 2 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    # run_script(script, "foobar").should == false
+    # script = "0 #{sig1} #{sig3} #{sig2} 3 #{k1.pub} #{k2.pub} #{k3.pub} 3 OP_CHECKMULTISIG"
+    # run_script(script, "foobar").should == false
+  end
+
+
+  it "should do OP_CHECKHASHVERIFY" do # https://en.bitcoin.it/wiki/BIP_0017
+    k1 = Bitcoin::Key.new; k1.generate
+    k2 = Bitcoin::Key.new; k2.generate
+    k3 = Bitcoin::Key.new; k2.generate
+    sig1 = (k1.sign("foobar") + "\x01").unpack("H*")[0]
+    sig2 = (k2.sign("foobar") + "\x01").unpack("H*")[0]
+    sig3 = (k2.sign("foobar") + "\x01").unpack("H*")[0]
+
+
+    # scriptSig: [signatures...] OP_CODESEPARATOR 1 [pubkey1] [pubkey2] 2 OP_CHECKMULTISIG
+    # scriptPubKey: [20-byte-hash of {1 [pubkey1] [pubkey2] 2 OP_CHECKMULTISIG} ] OP_CHECKHASHVERIFY OP_DROP
+    script = "1 #{k1.pub} #{k2.pub} 2 OP_CHECKMULTISIG"
+    checkhash = Bitcoin.hash160(Bitcoin::Script.binary_from_string(script).unpack("H*")[0])
+    script = "0 #{sig1} OP_CODESEPARATOR #{script} #{checkhash} OP_CHECKHASHVERIFY OP_DROP"
+    run_script(script, "foobar").should == true
+
+    script = "1 #{k1.pub} #{k2.pub} 2 OP_CHECKMULTISIG"
+    checkhash = Bitcoin.hash160(Bitcoin::Script.binary_from_string(script).unpack("H*")[0])
+    script = "0 #{sig1} OP_CODESEPARATOR #{script} #{checkhash} OP_NOP2 OP_DROP" # tests OP_NOP2 as OP_CHECKHASHVERIFY
+    run_script(script, "foobar").should == true
+
+    # invalid checkhashverify
+    script = "1 #{k1.pub} #{k2.pub} 2 OP_CHECKMULTISIG"
+    checkhash = Bitcoin.hash160(Bitcoin::Script.binary_from_string(script).unpack("H*")[0])
+    script = "1 #{k1.pub} #{k3.pub} 2 OP_CHECKMULTISIG"
+    script = "0 #{sig1} OP_CODESEPARATOR #{script} #{checkhash} OP_NOP2 OP_DROP" # tests OP_NOP2 as OP_CHECKHASHVERIFY
+    run_script(script, "foobar").should == false
+
+
+    # scriptSig: [signature] OP_CODESEPARATOR [pubkey] OP_CHECKSIG
+    # scriptPubKey: [20-byte-hash of {[pubkey] OP_CHECKSIG} ] OP_CHECKHASHVERIFY OP_DROP
+    script = "#{k1.pub} OP_CHECKSIG"
+    checkhash = Bitcoin.hash160(Bitcoin::Script.binary_from_string(script).unpack("H*")[0])
+    script = "#{sig1} OP_CODESEPARATOR #{script} #{checkhash} OP_CHECKHASHVERIFY OP_DROP"
+    run_script(script, "foobar").should == true
+
+    # invalid checkhashverify
+    script = "#{k2.pub} OP_CHECKSIG"
+    checkhash = Bitcoin.hash160(Bitcoin::Script.binary_from_string(script).unpack("H*")[0])
+    script = "#{k1.pub} OP_CHECKSIG"
+    script = "#{sig1} OP_CODESEPARATOR #{script} #{checkhash} OP_CHECKHASHVERIFY OP_DROP"
+    run_script(script, "foobar").should == false
+
+    # invalid signature in checksig
+    script = "#{k1.pub} OP_CHECKSIG"
+    checkhash = Bitcoin.hash160(Bitcoin::Script.binary_from_string(script).unpack("H*")[0])
+    script = "#{sig2} OP_CODESEPARATOR #{script} #{checkhash} OP_CHECKHASHVERIFY OP_DROP"
+    run_script(script, "foobar").should == false
+  end
+
+  it "should do P2SH" do
+    k1 = Bitcoin::Key.new; k1.generate
+    sig = (k1.sign("foobar") + "\x01").unpack("H*")[0]
+    inner_script = Bitcoin::Script.from_string("#{k1.pub} OP_CHECKSIG").raw.unpack("H*")[0]
+    script_hash = Bitcoin.hash160(inner_script)
+    script = Bitcoin::Script.from_string("#{sig} #{inner_script} OP_HASH160 #{script_hash} OP_EQUAL")
+    script.is_p2sh?.should == true
+    run_script(script.to_string, "foobar").should == true
+    run_script(script.to_string, "barbaz").should == false
+
+    script = Bitcoin::Script.from_string("OP_HASH160 #{script_hash} OP_EQUAL")
+    script.is_p2sh?.should == true
+    run_script(script.to_string, "foobar").should == false
+
+    address = "3CkxTG25waxsmd13FFgRChPuGYba3ar36B"
+    script = Bitcoin::Script.new(Bitcoin::Script.to_address_script(address))
+    script.type.should == :p2sh
+  end
+
+end