bitcoin-ruby 0.0.5 → 0.0.6

data/examples/bbe_verify_tx.rb

@@ -23,7 +23,7 @@ def get_tx(hash)
   end
   json = open(url).read
   Bitcoin::Protocol::Tx.from_json(json)
-rescue Exception
+rescue
   nil
 end
 

data/examples/index_nhash.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'bitcoin'
+
+Bitcoin.network = :testnet3
+@store = Bitcoin::Storage.sequel(:db => "postgres://mhanne:password@localhost:5434/testnet3_full")
+
+#@store.db.execute "DROP INDEX tx_nhash_index"
+
+def process_block blk
+  print "\r#{blk.hash} - #{blk.depth}"
+  blk.tx.each do |tx|
+    @store.db[:tx].where(hash: tx.hash.htb.blob).update(nhash: tx.nhash.htb.blob)
+  end
+end
+
+blk = @store.get_block_by_depth(0)
+process_block(blk)
+while blk = blk.get_next_block
+  process_block(blk)
+end
+
+@store.db.execute "CREATE INDEX tx_nhash_index ON tx (nhash)"

data/examples/reindex_p2sh_addrs.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'bitcoin'
+
+Bitcoin.network = :testnet3
+@store = Bitcoin::Storage.sequel(:db => "postgres://mhanne:password@localhost:5434/testnet3_full")
+# @store = Bitcoin::Storage.sequel(:db => "postgres:/testnet3")
+
+puts "move namecoin types up by one to make room for op_return"
+if Bitcoin.network_name == :namecoin
+  @store.db.run "UPDATE txout SET type = 8 WHERE type = 7"
+  @store.db.run "UPDATE txout SET type = 7 WHERE type = 6"
+  @store.db.run "UPDATE txout SET type = 6 WHERE type = 5"
+end
+
+puts "create missing p2sh output <-> address mappings"
+@store.db[:txout].where(type: 4).each do |txout|
+  script = Bitcoin::Script.new(txout[:pk_script])
+  if addr = @store.db[:addr][hash160: script.get_hash160]
+    addr_id = addr[:id]
+  else
+    addr_id = @store.db[:addr].insert(hash160: script.get_hash160)
+  end
+
+  if addr_txout = @store.db[:addr_txout][addr_id: addr_id, txout_id: txout[:id]]
+    # mapping already exists
+    print "e"
+  else
+    print "C"
+    @store.db[:addr_txout].insert(addr_id: addr_id, txout_id: txout[:id])
+  end
+end
+
+puts
+puts "scan all txouts of unknown type and check if they are op_returns"
+@store.db[:txout].where(type: 0).each do |txout|
+  if Bitcoin::Script.new(txout[:pk_script]).is_op_return?
+    print "C"
+    @store.db[:txout].where(id: txout[:id]).update(type: 5)
+  else
+    print "s"
+  end
+end

data/lib/bitcoin.rb

@@ -4,7 +4,7 @@
 require 'digest/sha2'
 require 'digest/rmd160'
 require 'openssl'
-
+require 'securerandom'
 
 module Bitcoin
 
@@ -21,6 +21,7 @@ module Bitcoin
   autoload :Validation, 'bitcoin/validation'
 
   autoload :Namecoin,   'bitcoin/namecoin'
+  autoload :Litecoin,   'bitcoin/litecoin'
 
   module Network
     autoload :ConnectionHandler,  'bitcoin/network/connection_handler'
@@ -128,6 +129,11 @@ module Bitcoin
       hash160_to_address( hash160(pubkey) )
     end
 
+    def pubkeys_to_p2sh_multisig_address(m, *pubkeys)
+      redeem_script = Bitcoin::Script.to_p2sh_multisig_script(m, *pubkeys).last
+      return Bitcoin.hash160_to_p2sh_address(Bitcoin.hash160(redeem_script.hth)), redeem_script
+    end
+
     def int_to_base58(int_val, leading_zero_bytes=0)
       alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
       base58_val, base = '', alpha.size
@@ -228,6 +234,23 @@ module Bitcoin
       bitcoin_hash(h)
     end
 
+    def litecoin_hash(hex)
+      bytes = [hex].pack("H*").reverse
+      begin
+        require "scrypt" unless defined?(::SCrypt)
+        hash = SCrypt::Engine.__sc_crypt(bytes, bytes, 1024, 1, 1, 32)
+      rescue LoadError
+        hash = Litecoin::Scrypt.scrypt_1024_1_1_256_sp(bytes)
+      end
+      hash.reverse.unpack("H*")[0]
+    end
+
+    def block_scrypt_hash(prev_block, mrkl_root, time, bits, nonce, ver)
+      h = "%08x%08x%08x%064s%064s%08x" %
+            [nonce, bits, time, mrkl_root, prev_block, ver]
+      litecoin_hash(h)
+    end
+
     # get merkle tree for given +tx+ list.
     def hash_mrkl_tree(tx)
       return [nil]  if tx != tx.uniq
@@ -306,13 +329,11 @@ module Bitcoin
       raise "malformed signature"       unless signature.bytesize == 65
       pubkey = Bitcoin::OpenSSL_EC.recover_compact(hash, signature)
       pubkey_to_address(pubkey) == address if pubkey
-    rescue Exception => ex
+    rescue => ex
       p [ex.message, ex.backtrace]; false
     end
 
 
-    RETARGET_INTERVAL = 2016
-
     # block count when the next retarget will take place.
     def block_next_retarget(block_height)
       (block_height + (RETARGET_INTERVAL-block_height.divmod(RETARGET_INTERVAL).last)) - 1
@@ -409,7 +430,8 @@ module Bitcoin
   @network = :bitcoin
 
   def self.network
-    NETWORKS[@network]
+    # Store the copy of network options so we can modify them in tests without breaking the defaults
+    @network_options ||= NETWORKS[@network].dup
   end
 
   def self.network_name
@@ -420,8 +442,9 @@ module Bitcoin
     @network_project
   end
 
-  def self.network= name
+  def self.network=(name)
     raise "Network descriptor '#{name}' not found."  unless NETWORKS[name.to_sym]
+    @network_options = nil # clear cached parameters
     @network = name.to_sym
     @network_project = network[:project] rescue nil
     Bitcoin::Namecoin.load  if namecoin?
@@ -433,13 +456,39 @@ module Bitcoin
   end
 
 
-  CENT =   1_000_000
-  COIN = 100_000_000
+  # maximum size of a block (in bytes)
   MAX_BLOCK_SIZE = 1_000_000
+
+  # soft limit for new blocks
   MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2
-  MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50
+
+  # maximum number of signature operations in a block
+  MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE / 50
+
+  # maximum number of orphan transactions to be kept in memory
   MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100
 
+  # Threshold for lock_time: below this value it is interpreted as block number, otherwise as UNIX timestamp.
+  LOCKTIME_THRESHOLD = 500000000 # Tue Nov  5 00:53:20 1985 UTC
+
+  # maximum integer value
+  UINT32_MAX = 0xffffffff
+  INT_MAX = 0xffffffff # deprecated name, left here for compatibility with existing users.
+
+  # number of confirmations required before coinbase tx can be spent
+  COINBASE_MATURITY = 100
+
+  # interval (in blocks) for difficulty retarget
+  RETARGET_INTERVAL = 2016
+  RETARGET = 2016 # deprecated constant
+
+
+  # interval (in blocks) for mining reward reduction
+  REWARD_DROP = 210_000
+
+  CENT =   1_000_000
+  COIN = 100_000_000
+
   MIN_FEE_MODE     = [ :block, :relay, :send ]
 
   NETWORKS = {
@@ -454,10 +503,14 @@ module Bitcoin
       :protocol_version => 70001,
       :coinbase_maturity => 100,
       :retarget_interval => 2016,
-      :retarget_time => 1209600, # 2 weeks
+      :retarget_time     => 1209600, # 2 weeks
+      :target_spacing    => 600, # block interval
       :max_money => 21_000_000 * COIN,
       :min_tx_fee => 10_000,
       :min_relay_tx_fee => 10_000,
+      :free_tx_bytes => 1_000,
+      :dust => CENT,
+      :per_dust_fee => false,
       :dns_seeds => [
         "seed.bitcoin.sipa.be",
         "dnsseed.bluematt.me",
@@ -484,9 +537,38 @@ module Bitcoin
         210000 => "000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e",
         216116 => "00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e",
         225430 => "00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932",
+        290000 => "0000000000000000fa0b2badd05db0178623ebf8dd081fe7eb874c26e27d0b3b",
+        300000 => "000000000000000082ccf8f1557c5d40b21edabb18d2d691cfbf87118bac7254",
+        305000 => "0000000000000000142bb90561e1a907d500bf534a6727a63a92af5b6abc6160",
       }
     },
 
+    :regtest => {
+      :project => :bitcoin,
+      :magic_head => "\xFA\xBF\xB5\xDA",
+      :address_version => "6f",
+      :p2sh_version => "c4",
+      :privkey_version => "ef",
+      :default_port => 18444,
+      :max_money => 21_000_000 * COIN,
+      :dns_seeds => [ ],
+      :genesis_hash => "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
+      :proof_of_work_limit => (1<<255) - 1,
+      :alert_pubkeys => ["04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a"],
+      :known_nodes => [],
+      :checkpoints => {},
+      :coinbase_maturity => 100,
+      :retarget_interval => 2016,
+      :retarget_time => 1209600, # 2 weeks
+      :target_spacing    => 600, # block interval
+      :max_money => 21_000_000 * COIN,
+      :min_tx_fee => 10_000,
+      :min_relay_tx_fee => 10_000,
+      :free_tx_bytes => 1_000,
+      :dust => CENT,
+      :per_dust_fee => false,
+    },
+
     :testnet => {
       :project => :bitcoin,
       :magic_head => "\xFA\xBF\xB5\xDA",
@@ -504,9 +586,13 @@ module Bitcoin
       :coinbase_maturity => 100,
       :retarget_interval => 2016,
       :retarget_time => 1209600, # 2 weeks
+      :target_spacing    => 600, # block interval
       :max_money => 21_000_000 * COIN,
       :min_tx_fee => 10_000,
       :min_relay_tx_fee => 10_000,
+      :free_tx_bytes => 1_000,
+      :dust => CENT,
+      :per_dust_fee => false,
     },
 
     :testnet3 => {
@@ -520,21 +606,28 @@ module Bitcoin
       :coinbase_maturity => 100,
       :retarget_interval => 2016,
       :retarget_time => 1209600, # 2 weeks
+      :target_spacing    => 600, # block interval
       :max_money => 21_000_000 * COIN,
       :min_tx_fee => 10_000,
+      :no_difficulty => true, # no good. add right testnet3 difficulty calculation instead
       :min_relay_tx_fee => 10_000,
+      :free_tx_bytes => 1_000,
+      :dust => CENT,
+      :per_dust_fee => false,
       :dns_seeds => [
         "testnet-seed.bitcoin.petertodd.org",
         "testnet-seed.bluematt.me",
       ],
       :genesis_hash => "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
-      :proof_of_work_limit => 0x1d07fff8,
+      :proof_of_work_limit => 0x1d00ffff,
       :alert_pubkeys => ["04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a"],
       :known_nodes => [],
       :checkpoints => {
         # 542 contains invalid transaction
         542 => "0000000083c1f82cf72c6724f7a317325806384b06408bce7a4327f418dfd5ad",
         71018 => "000000000010dd93dc55541116b2744eb8f4c3b706df6e8512d231a03fb9e435",
+        200000 => "0000000000287bffd321963ef05feab753ebe274e1d78b2fd4e2bfe9ad3aa6f2",
+        250000 => "0000000005910c146e4e8d71e8aa6617393738a9794b43cf113076dbaf08460b",
       }
     },
 
@@ -545,13 +638,16 @@ module Bitcoin
       :p2sh_version => "05",
       :privkey_version => "b0",
       :default_port => 9333,
-      :protocol_version => 60002,
+      :protocol_version => 70002,
       :max_money => 84_000_000 * COIN,
-      :min_tx_fee => 2_000_000,
+      :min_tx_fee => 100_000, # 0.001 LTC
+      :min_relay_tx_fee => 100_000, # 0.001 LTC
+      :free_tx_bytes => 5_000,
+      :dust => CENT / 10,
+      :per_dust_fee => true,
       :coinbase_maturity => 100,
       :retarget_interval => 2016,
       :retarget_time => 302400, # 3.5 days
-      :min_relay_tx_fee => 1_000_000,
       :dns_seeds => [
         "dnsseed.litecointools.com",
         "dnsseed.litecoinpool.org",
@@ -561,7 +657,7 @@ module Bitcoin
       ],
       :genesis_hash => "12a765e31ffd4059bada1e25190f6e98c99d9714d334efa41a195a7e7e04bfe2",
       :proof_of_work_limit => 0,
-      :alert_pubkeys => [],
+      :alert_pubkeys => ["040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9"],
       :known_nodes => [],
       :checkpoints => {
              1 => "80ca095ed10b02e53d769eb6eaf92cd04e9e0759e5be4a8477b42911ba49c78f",
@@ -578,6 +674,9 @@ module Bitcoin
         179620 => "2ad9c65c990ac00426d18e446e0fd7be2ffa69e9a7dcb28358a50b2b78b9f709",
         240000 => "7140d1c4b4c2157ca217ee7636f24c9c73db39c4590c4e6eab2e3ea1555088aa",
         383640 => "2b6809f094a9215bafc65eb3f110a35127a34be94b7d0590a096c3f126c6f364",
+        409004 => "487518d663d9f1fa08611d9395ad74d982b667fbdc0e77e9cf39b4f1355908a3",
+        456000 => "bf34f71cc6366cd487930d06be22f897e34ca6a40501ac7d401be32456372004",
+        541794 => "1cbccbe6920e7c258bbce1f26211084efb19764aa3224bec3f4320d77d6a2fd2",
       }
     },
 
@@ -588,22 +687,28 @@ module Bitcoin
       :p2sh_version => "c4",
       :privkey_version => "ef",
       :default_port => 19333,
-      :protocol_version => 60002,
-      :min_tx_fee => 2_000_000,
-      :min_relay_tx_fee => 1_000_000,
+      :protocol_version => 70002,
+      :min_tx_fee => 100_000, # 0.001 LTC
+      :min_relay_tx_fee => 100_000, # 0.001 LTC
+      :dust => CENT / 10,
+      :per_dust_fee => true,
+      :free_tx_bytes => 5_000,
       :coinbase_maturity => 100,
       :retarget_interval => 2016,
       :retarget_time => 302400, # 3.5 days
       :max_money => 84_000_000 * COIN,
       :dns_seeds => [
         "testnet-seed.litecointools.com",
+        "testnet-seed.ltc.xurious.com",
         "testnet-seed.weminemnc.com",
       ],
       :genesis_hash => "f5ae71e26c74beacc88382716aced69cddf3dffff24f384e1808905e0188f68f",
       :proof_of_work_limit => 0,
-      :alert_pubkeys => [],
+      :alert_pubkeys => ["04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a"],
       :known_nodes => [],
-      :checkpoints => {}
+      :checkpoints => {
+        546 => "a0fea99a6897f531600c8ae53367b126824fd6a847b2b2b73817a95b8e27e602",
+      }
     },
 
 
@@ -618,6 +723,9 @@ module Bitcoin
       :max_money => 21_000_000 * COIN,
       :min_tx_fee => 50_000,
       :min_relay_tx_fee => 10_000,
+      :free_tx_bytes => 1_000,
+      :dust => CENT,
+      :per_dust_fee => false,
       :dns_seeds => [ "seed.freico.in", "fledge.freico.in" ],
       :genesis_hash => "000000005b1e3d23ecfd2dd4a6e1a35238aa0392c0a8528c40df52376d7efe2c",
       :proof_of_work_limit => 0,
@@ -638,6 +746,9 @@ module Bitcoin
       :max_money => 21_000_000 * COIN,
       :min_tx_fee => 50_000,
       :min_relay_tx_fee => 10_000,
+      :free_tx_bytes => 1_000,
+      :dust => CENT,
+      :per_dust_fee => true,
       :dns_seeds => [],
       :genesis_hash => "000000000062b72c5e2ceb45fbc8587e807c155b0da735e6483dfba2f0a9c770",
       :proof_of_work_limit => 0x1d00ffff,
@@ -648,6 +759,7 @@ module Bitcoin
         19200 => "d8a7c3e01e1e95bcee015e6fcc7583a2ca60b79e5a3aa0a171eddd344ada903d",
         24000 => "425ab0983cf04f43f346a4ca53049d0dc2db952c0a68eb0b55c3bb64108d5371",
         97778 => "7553b1e43da01cfcda4335de1caf623e941d43894bd81c2af27b6582f9d83c6f",
+        165000 => "823d7a54ebab04d14c4ba3508f6b5f25977406f4d389539eac0174d52c6b4b62",
       }
     },
 
@@ -659,6 +771,9 @@ module Bitcoin
       :protocol_version => 35000,
       :min_tx_fee => 50_000,
       :min_relay_tx_fee => 10_000,
+      :free_tx_bytes => 1_000,
+      :dust => CENT,
+      :per_dust_fee => true,
       :max_money => 21_000_000 * COIN,
       :dns_seeds => [],
       :genesis_hash => "00000001f8ab0d14bceaeb50d163b0bef15aecf62b87bd5f5c864d37f201db97",

data/lib/bitcoin/builder.rb

@@ -18,10 +18,10 @@ module Bitcoin
 
     # build a Bitcoin::Protocol::Tx.
     # see TxBuilder for details.
-    def build_tx
+    def build_tx opts = {}
       c = TxBuilder.new
       yield c
-      c.tx
+      c.tx opts
     end
     alias :tx :build_tx
 
@@ -40,13 +40,12 @@ module Bitcoin
     #      t.input {|i| i.coinbase }
     #      t.output do |o|
     #        o.value 5000000000;
-    #        o.script do |s|
-    #          s.type :address
-    #          s.recipient Bitcoin::Key.generate.addr
-    #        end
+    #        o.to Bitcoin::Key.generate.addr
     #      end
     #    end
     #  end
+    #
+    # See Bitcoin::Builder::TxBuilder for details on building transactions.
     class BlockBuilder
 
       def initialize
@@ -69,10 +68,10 @@ module Bitcoin
       end
 
       # add transactions to the block (see TxBuilder).
-      def tx
-        c = TxBuilder.new
-        yield c
-        @block.tx << c.tx
+      def tx tx = nil
+        tx ||= ( c = TxBuilder.new; yield c; c.tx )
+        @block.tx << tx
+        tx
       end
 
       # create the block according to values specified via DSL.
@@ -117,18 +116,20 @@ module Bitcoin
     # DSL to create Bitcoin::Protocol::Tx used by Builder#build_tx.
     #  tx = tx do |t|
     #    t.input do |i|
-    #      i.prev_out prev_tx  # previous transaction
-    #      i.prev_out_index 0  # index of previous output
-    #      i.signature_key key # Bitcoin::Key used to sign the input
+    #      i.prev_out prev_tx, 0
+    #      i.signature_key key
     #    end
     #    t.output do |o|
     #      o.value 12345 # 0.00012345 BTC
-    #      o.script {|s| s.type :address; s.recipient key.addr }
+    #      o.to key.addr
     #    end
     #  end
     #
-    # signs every input that has a signature key. if the signature key is
-    # not specified, the input will include the #sig_hash that needs to be signed.
+    # Signs every input that has a signature key and where the previous outputs
+    # pk_script is known. If unable to sign, the resulting txin will include
+    # the #sig_hash that needs to be signed.
+    #
+    # See TxInBuilder and TxOutBuilder for details on how to build in/outputs.
     class TxBuilder
 
       def initialize
@@ -161,64 +162,202 @@ module Bitcoin
         @outs << c
       end
 
-      # create the transaction according to values specified via DSL.
-      # sign each input that has a signature key specified. if there is
+      # Create the transaction according to values specified via DSL.
+      # Sign each input that has a signature key specified. If there is
       # no key, store the sig_hash in the input, so it can easily be
       # signed later.
-      def tx
+      #
+      # When :change_address and :input_value options are given, it will
+      # automatically create a change output sending the remaining funds
+      # to the given address. The :leave_fee option can be used in this
+      # case to specify a tx fee that should be left unclaimed by the
+      # change output.
+      def tx opts = {}
+        if opts[:change_address] && !opts[:input_value]
+          raise "Must give 'input_value' when auto-generating change output!"
+        end
         @ins.each {|i| @tx.add_in(i.txin) }
         @outs.each {|o| @tx.add_out(o.txout) }
+
+        if opts[:change_address]
+          output_value = @tx.out.map(&:value).inject(:+)
+          change_value = opts[:input_value] - output_value
+          if opts[:leave_fee]
+            if change_value >= @tx.minimum_block_fee
+              change_value -= @tx.minimum_block_fee
+            else
+              change_value = 0
+            end
+          end
+          if change_value > 0
+            script = Script.to_address_script(opts[:change_address])
+            @tx.add_out(P::TxOut.new(change_value, script))
+          end
+        end
+
         @ins.each_with_index do |inc, i|
-          if @tx.in[i].coinbase?
-            script_sig = [inc.coinbase_data].pack("H*")
-            @tx.in[i].script_sig_length = script_sig.bytesize
-            @tx.in[i].script_sig = script_sig
-            next
+          sign_input(i, inc)
+        end
+
+        # run our tx through an encode/decode cycle to make sure that the binary format is sane
+        raise "Payload Error"  unless P::Tx.new(@tx.to_payload).to_payload == @tx.to_payload
+        @tx.instance_eval do
+          @payload = to_payload
+          @hash = hash_from_payload(@payload)
+        end
+
+        @tx
+      end
+
+      # coinbase inputs don't need to be signed, they only include the given +coinbase_data+
+      def include_coinbase_data i, inc
+        script_sig = [inc.coinbase_data].pack("H*")
+        @tx.in[i].script_sig_length = script_sig.bytesize
+        @tx.in[i].script_sig = script_sig
+      end
+
+      def sig_hash_and_all_keys_exist?(inc, sig_script)
+        return false unless @sig_hash && inc.has_keys?
+        script = Bitcoin::Script.new(sig_script)
+        return true if script.is_hash160? || script.is_pubkey?
+        if script.is_multisig?
+          return inc.has_multiple_keys? && inc.key.size >= script.get_signatures_required
+        end
+        raise "Script type must be hash160, pubkey or multisig"
+      end
+
+      def add_empty_script_sig_to_input(i)
+        @tx.in[i].script_sig_length = 0
+        @tx.in[i].script_sig = ""
+        # add the sig_hash that needs to be signed, so it can be passed on to a signing device
+        @tx.in[i].sig_hash = @sig_hash
+        # add the address the sig_hash needs to be signed with as a convenience for the signing device
+        @tx.in[i].sig_address = Script.new(@prev_script).get_address  if @prev_script
+      end
+
+      def get_script_sig(inc)
+        if inc.has_multiple_keys?
+          # multiple keys given, generate signature for each one
+          sigs = inc.sign(@sig_hash)
+          if redeem_script = inc.instance_eval { @redeem_script }
+            # when a redeem_script was specified, assume we spend a p2sh multisig script
+            script_sig = Script.to_p2sh_multisig_script_sig(redeem_script, sigs)
+          else
+            # when no redeem_script is given, do a regular multisig spend
+            script_sig = Script.to_multisig_script_sig(*sigs)
           end
-          prev_tx = inc.instance_variable_get(:@prev_out)
-          @sig_hash = @tx.signature_hash_for_input(i, prev_tx)
-          if inc.key && inc.key.priv
-            sig = inc.key.sign(@sig_hash)
-            script_sig = Script.to_signature_pubkey_script(sig, [inc.key.pub].pack("H*"))
-            @tx.in[i].script_sig_length = script_sig.bytesize
-            @tx.in[i].script_sig = script_sig
-            raise "Signature error"  unless @tx.verify_input_signature(i, prev_tx)
+        else
+          # only one key given, generate signature and script_sig
+          sig = inc.sign(@sig_hash)
+          script_sig = Script.to_signature_pubkey_script(sig, [inc.key.pub].pack("H*"))
+        end
+        return script_sig
+      end
+
+      # Sign input number +i+ with data from given +inc+ object (a TxInBuilder).
+      def sign_input i, inc
+        if @tx.in[i].coinbase?
+          include_coinbase_data(i, inc)
+        else
+          @prev_script = inc.instance_variable_get(:@prev_out_script)
+
+          # get the signature script; use +redeem_script+ if given
+          # (indicates spending a p2sh output), otherwise use the prev_script
+          sig_script = inc.instance_eval { @redeem_script }
+          sig_script ||= @prev_script
+
+          # when a sig_script was found, generate the sig_hash to be signed
+          @sig_hash = @tx.signature_hash_for_input(i, sig_script)  if sig_script
+
+          # when there is a sig_hash and one or more signature_keys were specified
+          if sig_hash_and_all_keys_exist?(inc, sig_script)
+            # add the script_sig to the txin
+            @tx.in[i].script_sig = get_script_sig(inc)
+
+            # double-check that the script_sig is valid to spend the given prev_script
+            raise "Signature error"  if @prev_script && !@tx.verify_input_signature(i, @prev_script)
+          elsif inc.has_multiple_keys?
+            raise "Keys missing for multisig signing"
           else
-            @tx.in[i].script_sig_length = 0
-            @tx.in[i].script_sig = ""
-            @tx.in[i].sig_hash = @sig_hash
-            @tx.in[i].sig_address = Script.new(prev_tx.out[@tx.in[i].prev_out_index].pk_script).get_address
+            # no sig_hash, add an empty script_sig.
+            add_empty_script_sig_to_input(i)
           end
         end
-        data = @tx.in.map {|i| [i.sig_hash, i.sig_address] }
-        tx = P::Tx.new(@tx.to_payload)
-        data.each.with_index {|d, i| i = tx.in[i]; i.sig_hash = d[0]; i.sig_address = d[1] }
-        raise "Payload Error"  unless tx.to_payload == @tx.to_payload
-        tx
+      end
+
+      # Randomize the outputs using SecureRandom
+      def randomize_outputs
+        @outs.sort_by!{ SecureRandom.random_bytes(4).unpack("I")[0] }
       end
     end
 
-    # create a Bitcoin::Protocol::TxIn used by TxBuilder#input.
+    # Create a Bitcoin::Protocol::TxIn used by TxBuilder#input.
+    #
+    # Inputs need the transaction hash and the index of the output they spend.
+    # You can pass either the transaction, or just its hash (in hex form).
+    # To sign the input, builder also needs the pk_script of the previous output.
+    # If you specify a tx hash instead of the whole tx, you need to specify the
+    # output script separately.
+    #
+    #  t.input do |i|
+    #    i.prev_out prev_tx  # previous transaction
+    #    i.prev_out_index 0  # index of previous output
+    #    i.signature_key key # Bitcoin::Key used to sign the input
+    #  end
+    #
+    #  t.input {|i| i.prev_out prev_tx, 0 }
     #
-    # inputs need a #prev_out tx and #prev_out_index of the output they spend.
+    # If you want to spend a p2sh output, you also need to specify the +redeem_script+.
+    #
+    #  t.input do |i|
+    #    i.prev_out prev_tx, 0
+    #    i.redeem_script prev_out.redeem_script
+    #  end
+    #
+    # If you want to spend a multisig output, just provide an array of keys to #signature_key.
     class TxInBuilder
-      attr_reader :key, :coinbase_data
+      attr_reader :prev_tx, :prev_script, :redeem_script, :key, :coinbase_data
 
       def initialize
         @txin = P::TxIn.new
+        @prev_out_hash = "\x00" * 32
+        @prev_out_index = 0
       end
 
-      # previous transaction that contains the output we want to use.
-      def prev_out tx, idx = nil
-        @prev_out, @prev_out_index = tx, idx
+      # Previous transaction that contains the output we want to use.
+      # You can either pass the transaction, or just the tx hash.
+      # If you pass only the hash, you need to pass the previous outputs
+      # +script+ separately if you want the txin to be signed.
+      def prev_out tx, idx = nil, script = nil
+        if tx.is_a?(Bitcoin::P::Tx)
+          @prev_tx = tx
+          @prev_out_hash = tx.binary_hash
+          @prev_out_script = tx.out[idx].pk_script  if idx
+        else
+          @prev_out_hash = tx.htb.reverse
+        end
+        @prev_out_script = script  if script
+        @prev_out_index = idx  if idx
       end
 
-      # index of the output in the #prev_out transaction.
+      # Index of the output in the #prev_out transaction.
       def prev_out_index i
         @prev_out_index = i
+        @prev_out_script = @prev_tx.out[i].pk_script  if @prev_tx
       end
 
-      # specify sequence. this is usually not needed.
+      # Previous output's +pk_script+. Needed when only the tx hash is specified as #prev_out.
+      def prev_out_script script
+        @prev_out_script = script
+      end
+
+      # Redeem script for P2SH output. To spend from a P2SH output, you need to provide
+      # the script with a hash matching the P2SH address.
+      def redeem_script script
+        @redeem_script = script
+      end
+
+      # Specify sequence. This is usually not needed.
       def sequence s
         @sequence = s
       end
@@ -229,44 +368,70 @@ module Bitcoin
         @key = key
       end
 
-      # specify that this is a coinbase input. optionally set +data+.
+      # Specify that this is a coinbase input. Optionally set +data+.
+      # If this is set, no other options need to be given.
       def coinbase data = nil
         @coinbase_data = data || OpenSSL::Random.random_bytes(32)
-        @prev_out = nil
+        @prev_out_hash = "\x00" * 32
         @prev_out_index = 4294967295
       end
 
-      # create the txin according to values specified via DSL
+      # Create the txin according to specified values
       def txin
-        @txin.prev_out = (@prev_out ? @prev_out.binary_hash : "\x00"*32)
+        @txin.prev_out = @prev_out_hash
         @txin.prev_out_index = @prev_out_index
         @txin.sequence = @sequence || "\xff\xff\xff\xff"
         @txin
       end
+
+      def has_multiple_keys?
+        @key.is_a?(Array)
+      end
+
+      def has_keys?
+        @key && (has_multiple_keys? ? @key.all?(&:priv) : @key.priv)
+      end
+
+      def sign(sig_hash)
+        if has_multiple_keys?
+          @key.map {|k| k.sign(sig_hash) }
+        else
+          @key.sign(sig_hash)
+        end
+      end
     end
 
-    # create a Bitcoin::Script used by TxOutBuilder#script.
+    # Create a Bitcoin::Script used by TxOutBuilder#script.
     class ScriptBuilder
-      attr_reader :script
+      attr_reader :script, :redeem_script
 
       def initialize
         @type = :address
         @script = nil
       end
 
-      # script type (:pubkey, :address/hash160, :multisig).
+      # Script type (:pubkey, :address/hash160, :multisig).
+      # Defaults to :address.
       def type type
         @type = type.to_sym
       end
 
-      # recipient(s) of the script.
-      # depending on the #type, either an address, hash160 pubkey, etc.
+      # Recipient(s) of the script.
+      # Depending on the #type, this should be an address, a hash160 pubkey,
+      # or an array of multisig pubkeys.
       def recipient *data
-        @script = Script.send("to_#{@type}_script", *data)
+        @script, @redeem_script = *Script.send("to_#{@type}_script", *data)
       end
     end
 
-    # create a Bitcoin::Protocol::TxOut used by TxBuilder#output.
+    # Create a Bitcoin::Protocol::TxOut used by TxBuilder#output.
+    #
+    #  t.output {|o| o.value 12345; o.to address }
+    #
+    #  t.output do |o|
+    #    o.value 12345
+    #    o.script {|s| s.recipient address }
+    #  end
     class TxOutBuilder
       attr_reader :txout
 
@@ -274,16 +439,21 @@ module Bitcoin
         @txout = P::TxOut.new
       end
 
-      # set output value (in base units / "satoshis")
+      # Set output value (in base units / "satoshis")
       def value value
         @txout.value = value
       end
 
-      # add a script to the output (see ScriptBuilder).
+      # Set recipient address and script type (defaults to :address).
+      def to recipient, type = :address
+        @txout.pk_script, @txout.redeem_script = *Bitcoin::Script.send("to_#{type}_script", *recipient)
+      end
+
+      # Add a script to the output (see ScriptBuilder).
       def script &block
         c = ScriptBuilder.new
         yield c
-        @txout.pk_script = c.script
+        @txout.pk_script, @txout.redeem_script = c.script, c.redeem_script
       end
 
     end