bitcoin-ruby 0.0.1

data/lib/bitcoin/builder.rb

@@ -0,0 +1,266 @@
+module Bitcoin
+
+  # Optional DSL to help create blocks and transactions.
+  #
+  # see also BlockBuilder, TxBuilder, TxInBuilder, TxOutBuilder, ScriptBuilder
+  module Builder
+
+    # build a Bitcoin::Protocol::Block matching the given +target+.
+    # see BlockBuilder for details.
+    def blk(target = "00".ljust(32, 'f'))
+      c = BlockBuilder.new
+      yield c
+      c.block(target)
+    end
+
+    # build a Bitcoin::Protocol::Tx.
+    # see TxBuilder for details.
+    def tx
+      c = TxBuilder.new
+      yield c
+      c.tx
+    end
+
+    # build a Bitcoin::Script.
+    # see ScriptBuilder for details.
+    def script
+      c = ScriptBuilder.new
+      yield c
+      c.script
+    end
+
+    # DSL to create a Bitcoin::Protocol::Block used by Builder#blk.
+    #  block = blk("00".ljust(32, 'f')) do |b|
+    #    b.prev_block "\x00"*32
+    #    b.tx do |t|
+    #      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
+    #      end
+    #    end
+    #  end
+    class BlockBuilder
+
+      def initialize
+        @block = Bitcoin::P::Block.new(nil)
+      end
+
+      # specify block version. this is usually not necessary. defaults to 1.
+      def version v
+        @version = v
+      end
+
+      # set the hash of the previous block.
+      def prev_block hash
+        @prev_block = hash
+      end
+
+      # add transactions to the block (see TxBuilder).
+      def tx
+        c = TxBuilder.new
+        yield c
+        @block.tx << c.tx
+      end
+
+      # create the block according to values specified via DSL.
+      def block target
+        @block.ver = @version || 1
+        @block.prev_block = [@prev_block].pack("H*").reverse
+        @block.mrkl_root = @mrkl_root
+        @block.time = Time.now.to_i
+        @block.nonce = 0
+        @block.mrkl_root = [Bitcoin.hash_mrkl_tree(@block.tx.map {|t|
+              t.hash }).last].pack("H*")
+        find_hash(target)
+        Bitcoin::P::Block.new(@block.to_payload)
+      end
+
+      private
+
+      # increment nonce/time to find a block hash matching the +target+.
+      def find_hash target
+        @block.bits = Bitcoin.encode_compact_bits(target)
+        t = Time.now
+        @block.recalc_block_hash
+        until @block.hash < target
+          @block.nonce += 1
+          @block.recalc_block_hash
+          if @block.nonce == 100000
+            if t
+              tt = 1 / ((Time.now - t) / 100000) / 1000
+              print "\r%.2f khash/s" % tt
+            end
+            t = Time.now
+            @block.time = Time.now.to_i
+            @block.nonce = 0
+            $stdout.flush
+          end
+        end
+      end
+
+    end
+
+    # DSL to create Bitcoin::Protocol::Tx used by Builder#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
+    #   end
+    #   t.output do |o|
+    #     o.value 12345 # 0.00012345 BTC
+    #     o.script {|s| s.type :address; s.recipient key.addr }
+    #   end
+    # end
+    class TxBuilder
+
+      def initialize
+        @tx = Bitcoin::P::Tx.new(nil)
+        @tx.ver, @tx.lock_time = 1, 0
+        @ins, @outs = [], []
+      end
+
+      # specify tx version. this is usually not necessary. defaults to 1.
+      def version n
+        @tx.ver = n
+      end
+
+      # specify tx lock_time. this is usually not necessary. defaults to 0.
+      def lock_time n
+        @tx.lock_time = n
+      end
+
+      # add an input to the transaction (see TxInBuilder).
+      def input
+        c = TxInBuilder.new
+        yield c
+        @ins << c
+      end
+
+      # add an output to the transaction (see TxOutBuilder).
+      def output
+        c = TxOutBuilder.new
+        yield c
+        @outs << c
+      end
+
+      # create the transaction according to values specified via DSL and sign inputs.
+      def tx
+        @ins.each {|i| @tx.add_in(i.txin) }
+        @outs.each {|o| @tx.add_out(o.txout) }
+        @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
+          end
+          prev_tx = inc.instance_variable_get(:@prev_out)
+          sig_hash = @tx.signature_hash_for_input(i, prev_tx)
+          sig = inc.key.sign(sig_hash)
+          script_sig = Bitcoin::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)
+        end
+        Bitcoin::P::Tx.new(@tx.to_payload)
+      end
+    end
+
+    # create a Bitcoin::Protocol::TxIn used by TxBuilder#input.
+    #
+    # inputs can be either 'coinbase', in which case they only need to specify #coinbase,
+    # or they have to define a #prev_out, #prev_out_index and #signature key.
+    class TxInBuilder
+      attr_reader :key, :coinbase_data
+
+      def initialize
+        @txin = Bitcoin::P::TxIn.new
+      end
+
+      # previous transaction that contains the output we want to use.
+      def prev_out tx
+        @prev_out = tx
+      end
+
+      # index of the output in the #prev_out transaction.
+      def prev_out_index i
+        @prev_out_index = i
+      end
+
+      # specify sequence. this is usually not needed.
+      def sequence s
+        @sequence = s
+      end
+
+      # Bitcoin::Key used to sign the signature_hash for the input.
+      # see Bitcoin::Script.signature_hash_for_input and Bitcoin::Key.sign.
+      def signature_key key
+        @key = key
+      end
+
+      # specify that this is a coinbase input. optionally set +data+.
+      def coinbase data = nil
+        @coinbase_data = data || OpenSSL::Random.random_bytes(32)
+        @prev_out = nil
+        @prev_out_index = 4294967295
+      end
+
+      # create the txin according to values specified via DSL
+      def txin
+        @txin.prev_out = (@prev_out ? @prev_out.binary_hash : "\x00"*32)
+        @txin.prev_out_index = @prev_out_index
+        @txin.sequence = @sequence || "\xff\xff\xff\xff"
+        @txin
+      end
+    end
+
+    # create a Bitcoin::Script used by TxOutBuilder#script.
+    class ScriptBuilder
+      attr_reader :script
+
+      def initialize
+        @type = nil
+        @script = nil
+      end
+
+      # script type (:pubkey, :address/hash160, :multisig).
+      def type type
+        @type = type.to_sym
+      end
+
+      # recipient(s) of the script.
+      # depending on the #type, either an address, hash160 pubkey, etc.
+      def recipient *data
+        @script = Bitcoin::Script.send("to_#{@type}_script", *data)
+      end
+    end
+
+    # create a Bitcoin::Protocol::TxOut used by TxBuilder#output.
+    class TxOutBuilder
+      attr_reader :txout
+
+      def initialize
+        @txout = Bitcoin::P::TxOut.new
+      end
+
+      # set output value (in base units / "satoshis")
+      def value value
+        @txout.value = value
+      end
+
+      # add a script to the output (see ScriptBuilder).
+      def script &block
+        c = ScriptBuilder.new
+        yield c
+        @txout.pk_script = c.script
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/config.rb

@@ -0,0 +1,56 @@
+require 'yaml'
+module Bitcoin
+
+  # Load config files, merge options, etc.
+  #
+  # Multiple config files are loaded in order, and their settings merged into an
+  # existing +options+ hash.
+  #
+  # Each config file defines one or more +categories+ which hold the actual settings.
+  # Which categories are loaded, and in what order, is specified when you load
+  # the config (ie. the order in the file doesn't matter).
+  # The default category "all" is always used, and is always the first
+  # (gets overridden by all others)
+  module Config
+
+    CONFIG_PATHS = "./bitcoin-ruby.yml:~/.bitcoin-ruby.yml:/etc/bitcoin-ruby.yml"
+
+    # Load +categories+ from all files at +paths+ into given +options+ hash.
+    def self.load(options, categories = [], paths = CONFIG_PATHS)
+      paths.split(":").reverse.each do |path|
+        path.sub!("~", ENV["HOME"])
+        next  unless File.exist?(path)
+        options = load_file(options, path, categories)
+      end
+      options
+    end
+
+    # Load categories +c+ of a single config +file+ into given +options+ hash.
+    def self.load_file(options, file, c = [])
+      categories = YAML::load_file(file)
+      [:all, *(c.is_a?(Array) ? c : [c])].each do |category|
+        options = merge(options, categories[category.to_s])  if categories[category.to_s]
+      end
+      options
+    end
+
+    # Deep-merge hash +b+ into +a+.
+    def self.merge(a, b)
+      return a unless b
+      symbolize(a).merge(symbolize(b)) do |k, o, n|
+        if o.is_a?(Hash) && n.is_a?(Hash)
+          merge(symbolize(o), symbolize(n))
+        else
+          n
+        end
+      end
+    end
+
+    # Turn all keys in +hash+ into symbols.
+    def self.symbolize(hash)
+      Hash[hash.map{|k,v|[k.to_sym,v]}]
+    end
+
+  end
+
+end

data/lib/bitcoin/connection.rb

@@ -0,0 +1,126 @@
+require 'socket'
+require 'eventmachine'
+require 'bitcoin'
+
+module Bitcoin
+
+  module ConnectionHandler
+    def hth(h); h.unpack("H*")[0]; end
+    def htb(h); [h].pack("H*"); end
+
+    def on_inv_transaction(hash)
+      p ['inv transaction', hth(hash)]
+      pkt = Protocol.getdata_pkt(:tx, [hash])
+      send_data(pkt)
+    end
+
+    def on_inv_block(hash)
+      p ['inv block', hth(hash)]
+      pkt = Protocol.getdata_pkt(:block, [hash])
+      send_data(pkt)
+    end
+
+    def on_get_transaction(hash)
+      p ['get transaction', hth(hash)]
+    end
+
+    def on_get_block(hash)
+      p ['get block', hth(hash)]
+    end
+
+    def on_addr(addr)
+      p ['addr', addr, addr.alive?]
+    end
+
+    def on_tx(tx)
+      p ['tx', tx.hash]
+    end
+
+    def on_block(block)
+      p ['block', block.hash]
+      #p block.payload.each_byte.map{|i| "%02x" % [i] }.join(" ")
+      #puts block.to_json
+    end
+
+    def on_version(version)
+      p [@sockaddr, 'version', version, version.timestamp - Time.now.to_i]
+      send_data( Protocol.verack_pkt )
+    end
+
+    def on_handshake_complete
+      p [@sockaddr, 'handshake complete']
+      @connected = true
+
+      query_blocks
+    end
+
+    def query_blocks
+      start = ("\x00"*32)
+      stop  = ("\x00"*32)
+      pkt = Protocol.pkt("getblocks", "\x00" + start + stop )
+      send_data(pkt)
+    end
+
+    def on_handshake_begin
+      block   = 127953
+      from    = "127.0.0.1:8333"
+      from_id = Bitcoin::Protocol::Uniq
+      to      = @sockaddr.reverse.join(":")
+      # p "==", from_id, from, to, block
+      pkt = Protocol.version_pkt(from_id, from, to, block)
+      p ['sending version pkt', pkt]
+      send_data(pkt)
+    end
+  end
+
+
+  class Connection < EM::Connection
+    include ConnectionHandler
+
+    def initialize(host, port, connections)
+      @sockaddr = [port, host]
+      @connections = connections
+      @parser = Bitcoin::Protocol::Parser.new( self )
+    end
+
+    def post_init
+      p ['connected', @sockaddr]
+      EM.schedule{ on_handshake_begin }
+    end
+
+    def receive_data(data)
+      @parser.parse(data)
+    end
+
+    def unbind
+      p ['disconnected', @sockaddr]
+      self.class.connect_random_from_dns(@connections)
+    end
+
+    def self.connect(host, port, connections)
+      EM.connect(host, port, self, host, port, connections)
+    end
+
+    def self.connect_random_from_dns(connections)
+      seeds = Bitcoin.network[:dns_seeds]
+      if seeds.any?
+        host = `nslookup #{seeds.sample}`.scan(/Address\: (.+)$/).flatten.sample
+        connect(host, Bitcoin::network[:default_port], connections)
+      else
+        raise "No DNS seeds available. Provide IP, configure seeds, or use different network."
+      end
+    end
+  end
+end
+
+
+if $0 == __FILE__
+  EM.run do
+
+    connections = []
+    #Bitcoin::Connection.connect('127.0.0.1', 8333, connections)
+    #Bitcoin::Connection.connect('217.157.1.202', 8333, connections)
+    Bitcoin::Connection.connect_random_from_dns(connections)
+
+  end
+end