bitcoin-ruby 0.0.1

data/lib/bitcoin/protocol/tx.rb

@@ -0,0 +1,205 @@
+require 'bitcoin/script'
+
+module Bitcoin
+  module Protocol
+
+    class Tx
+
+      # transaction hash
+      attr_reader :hash
+
+      # inputs (Array of TxIn)
+      attr_reader :in
+
+      # outputs (Array of TxOut)
+      attr_reader :out
+
+      # raw protocol payload
+      attr_reader :payload
+
+      # version (usually 1)
+      attr_accessor :ver
+
+      # lock time
+      attr_accessor :lock_time
+
+      alias :inputs  :in
+      alias :outputs :out
+
+      # compare to another tx
+      def ==(other)
+        @hash == other.hash
+      end
+
+      # return the tx hash in binary format
+      def binary_hash
+        [@hash].pack("H*").reverse
+      end
+
+      # create tx from raw binary +data+
+      def initialize(data=nil)
+        @ver, @lock_time, @in, @out = 1, 0, [], []
+        parse_data(data) if data
+      end
+
+      # generate the tx hash for given +payload+ in hex format
+      def hash_from_payload(payload)
+        Digest::SHA256.digest(Digest::SHA256.digest( payload )).reverse.unpack("H*")[0]
+      end
+      alias generate_hash hash_from_payload
+
+      # add an input
+      def add_in(input); (@in ||= []) << input; end
+
+      # add an output
+      def add_out(output); (@out ||= []) << output; end
+
+      # parse raw binary data
+      def parse_data(data)
+        @ver = data.unpack("I")[0]
+        idx = 4
+        in_size, tmp = Protocol.unpack_var_int(data[idx..-1])
+        idx += data[idx..-1].bytesize-tmp.bytesize
+        # raise "unkown transaction version: #{@ver}" unless @ver == 1
+
+        @in = (0...in_size).map{
+          txin = TxIn.new
+          idx += txin.parse_data(data[idx..-1])
+          txin
+        }
+
+        out_size, tmp = Protocol.unpack_var_int(data[idx..-1])
+        idx += data[idx..-1].bytesize-tmp.bytesize
+
+        @out = (0...out_size).map{
+          txout = TxOut.new
+          idx += txout.parse_data(data[idx..-1])
+          txout
+        }
+
+        @lock_time = data[idx...idx+=4].unpack("I")[0]
+
+        @payload = data[0...idx]
+        @hash = hash_from_payload(@payload)
+
+        if data[idx] == nil
+          true          # reached the end.
+        else
+          data[idx..-1] # rest of buffer.
+        end
+      end
+
+      # output transaction in raw binary format
+      def to_payload
+        pin  =  @in.map(&:to_payload).join
+        pout = @out.map(&:to_payload).join
+
+        in_size, out_size = Protocol.pack_var_int(@in.size), Protocol.pack_var_int(@out.size)
+        [[@ver].pack("I"), in_size, pin, out_size, pout, [@lock_time].pack("I")].join
+      end
+
+      # generate a signature hash for input +input_idx+.
+      # either pass the +outpoint_tx+ or the +script_pubkey+ directly.
+      def signature_hash_for_input(input_idx, outpoint_tx, script_pubkey=nil, hash_type=nil, drop_sigs=nil, script=nil)
+        # https://github.com/bitcoin/bitcoin/blob/e071a3f6c06f41068ad17134189a4ac3073ef76b/script.cpp#L834
+        # http://code.google.com/p/bitcoinj/source/browse/trunk/src/com/google/bitcoin/core/Script.java#318
+        # https://en.bitcoin.it/wiki/OP_CHECKSIG#How_it_works
+        # https://github.com/bitcoin/bitcoin/blob/c2e8c8acd8ae0c94c70b59f55169841ad195bb99/src/script.cpp#L1058
+
+        hash_type ||= 1 # 1: ALL, 2: NONE, 3: SINGLE
+
+        pin  = @in.map.with_index{|input,idx|
+          if idx == input_idx
+            script_pubkey ||= outpoint_tx.out[ input.prev_out_index ].pk_script
+            script_pubkey = Bitcoin::Script.binary_from_string(script)                if script    # force this string a script
+            script_pubkey = Bitcoin::Script.drop_signatures(script_pubkey, drop_sigs) if drop_sigs # array of signature to drop
+            input.to_payload(script_pubkey)
+          else
+            case hash_type
+            when 2; input.to_payload("", "\x00\x00\x00\x00")
+            else;   input.to_payload("")
+            end
+          end
+        }.join
+
+        pout = @out.map(&:to_payload).join
+
+        case hash_type
+        when 2
+          pout = ""
+          in_size, out_size = Protocol.pack_var_int(@in.size), Protocol.pack_var_int(0)
+        else
+          in_size, out_size = Protocol.pack_var_int(@in.size), Protocol.pack_var_int(@out.size)
+        end
+
+        buf = [ [@ver].pack("I"), in_size, pin, out_size, pout, [@lock_time, hash_type].pack("II") ].join
+        Digest::SHA256.digest( Digest::SHA256.digest( buf ) )
+      end
+
+      # verify input signature +in_idx+ against the corresponding
+      # output in +outpoint_tx+
+      def verify_input_signature(in_idx, outpoint_tx)
+        outpoint_idx  = @in[in_idx].prev_out_index
+        script_sig    = @in[in_idx].script_sig
+        script_pubkey = outpoint_tx.out[outpoint_idx].pk_script
+        script        = script_sig + script_pubkey
+
+        Bitcoin::Script.new(script).run do |pubkey,sig,hash_type,drop_sigs,script|
+          # this IS the checksig callback, must return true/false
+          hash = signature_hash_for_input(in_idx, outpoint_tx, nil, hash_type, drop_sigs, script)
+          #hash = signature_hash_for_input(in_idx, nil, script_pubkey, hash_type, drop_sigs, script)
+          Bitcoin.verify_signature( hash, sig, pubkey.unpack("H*")[0] )
+        end
+      end
+
+      # convert to ruby hash (see also #from_hash)
+      def to_hash
+        @hash ||= hash_from_payload(to_payload)
+        {
+          'hash' => @hash, 'ver' => @ver,
+          'vin_sz' => @in.size, 'vout_sz' => @out.size,
+          'lock_time' => @lock_time, 'size' => (@payload ||= to_payload).bytesize,
+          'in'  =>  @in.map(&:to_hash),
+          'out' => @out.map(&:to_hash)
+        }
+      end
+
+      # generates rawblock json as seen in the block explorer.
+      def to_json(options = {:space => ''}, *a)
+        JSON.pretty_generate( to_hash, options )
+      end
+
+      # write json representation to a file
+      # (see also #to_json)
+      def to_json_file(path)
+        File.open(path, 'wb'){|f| f.print to_json; }
+      end
+
+      # parse ruby hash (see also #to_hash)
+      def self.from_hash(h)
+        tx = new(nil)
+        tx.ver, tx.lock_time = *h.values_at('ver', 'lock_time')
+        h['in'] .each{|input|   tx.add_in  TxIn.from_hash(input)   }
+        h['out'].each{|output|  tx.add_out TxOut.from_hash(output) }
+        tx.instance_eval{ @hash = hash_from_payload(@payload = to_payload) }
+        tx
+      end
+
+      # convert ruby hash to raw binary
+      def self.binary_from_hash(h); from_hash(h).to_payload; end
+
+      # parse json representation
+      def self.from_json(json_string); from_hash( JSON.load(json_string) ); end
+
+      # convert json representation to raw binary
+      def self.binary_from_json(json_string); from_json(json_string).to_payload; end
+
+      # read binary block from a file
+      def self.from_file(path); new( Bitcoin::Protocol.read_binary_file(path) ); end
+
+      # read json block from a file
+      def self.from_json_file(path); from_json( Bitcoin::Protocol.read_binary_file(path) ); end
+    end
+
+  end
+end

data/lib/bitcoin/protocol/txin.rb

@@ -0,0 +1,97 @@
+module Bitcoin
+  module Protocol
+
+    class TxIn
+
+      # previous output hash
+      attr_accessor :prev_out
+
+      # previous output index
+      attr_accessor :prev_out_index
+
+      # script_sig input Script (signature)
+      attr_accessor :script_sig, :script_sig_length
+
+      # sequence
+      attr_accessor :sequence
+
+      DEFAULT_SEQUENCE = "\xff\xff\xff\xff"
+
+      def initialize *args
+        @prev_out, @prev_out_index, @script_sig_length,
+        @script_sig, @sequence = *args
+        @sequence ||= DEFAULT_SEQUENCE
+      end
+
+      # compare to another txout
+      def ==(other)
+        @prev_out == other.prev_out &&
+          @prev_out_index == other.prev_out_index &&
+          @script_sig == other.script_sig &&
+          @sequence == other.sequence
+      end
+
+      # parse raw binary data for transaction input
+      def parse_data(data)
+        idx = 0
+        @prev_out, @prev_out_index = data[idx...idx+=36].unpack("a32I")
+        @script_sig_length, tmp = Protocol.unpack_var_int(data[idx..-1])
+        idx += data[idx..-1].bytesize - tmp.bytesize
+        @script_sig = data[idx...idx+=@script_sig_length]
+        @sequence = data[idx...idx+=4]
+        idx
+      end
+
+      alias :parse_payload :parse_data
+
+      def to_payload(script=@script_sig, sequence=@sequence)
+        buf =  [ @prev_out, @prev_out_index ].pack("a32I")
+        buf << Protocol.pack_var_int(script.bytesize)
+        buf << script if script.bytesize > 0
+        buf << (sequence || DEFAULT_SEQUENCE)
+      end
+
+      def to_hash
+        t = { 'prev_out'  => { 'hash' => @prev_out.reverse.unpack("H*")[0], 'n' => @prev_out_index } }
+        if coinbase?
+          t['coinbase']  = @script_sig.unpack("H*")[0]
+        else # coinbase tx
+          t['scriptSig'] = Bitcoin::Script.new(@script_sig).to_string
+          t['sequence']  = @sequence.unpack("I")[0] unless @sequence == "\xff\xff\xff\xff"
+        end
+        t
+      end
+
+      def self.from_hash(input)
+        txin = TxIn.new([ input['prev_out']['hash'] ].pack('H*').reverse, input['prev_out']['n'])
+        if input['coinbase']
+          txin.script_sig = [ input['coinbase'] ].pack("H*")
+          txin.sequence = "\xff\xff\xff\xff"
+        else
+          txin.script_sig = Script.binary_from_string(input['scriptSig'])
+          txin.sequence = [ input['sequence'] || 0xffffffff ].pack("I")
+        end
+        txin
+      end
+
+      # previous output in hex
+      def previous_output
+        @prev_out.reverse.unpack("H*")[0]
+      end
+
+      # check if input is coinbase
+      def coinbase?
+        (@prev_out_index == 4294967295) && (@prev_out == "\x00"*32)
+      end
+
+      # set script_sig and script_sig_length
+      def script_sig=(script_sig)
+        @script_sig_length = script_sig.bytesize
+        @script_sig = script_sig
+      end
+      alias :script= :script_sig=
+
+    end
+
+  end
+end

data/lib/bitcoin/protocol/txout.rb

@@ -0,0 +1,73 @@
+module Bitcoin
+  module Protocol
+
+    class TxOut
+
+      # output value (in base units; "satoshi")
+      attr_accessor :value
+
+      # pk_script output Script
+      attr_accessor :pk_script, :pk_script_length
+
+      def initialize *args
+        if args.size == 2
+          @value, @pk_script_length, @pk_script = args[0], args[1].bytesize, args[1]
+        else
+          @value, @pk_script_length, @pk_script = *args
+        end
+      end
+
+      def ==(other)
+        @value == other.value && @pk_script == other.pk_script
+      end
+
+      # parse raw binary data for transaction output
+      def parse_data(data)
+        idx = 0
+        @value = data[idx...idx+=8].unpack("Q")[0]
+        @pk_script_length, tmp = Protocol.unpack_var_int(data[idx..-1])
+        idx += data[idx..-1].bytesize - tmp.bytesize
+        @pk_script = data[idx...idx+=@pk_script_length]
+        idx
+      end
+
+      alias :parse_payload :parse_data
+
+      def to_payload
+        buf =  [ @value ].pack("Q")
+        buf << Protocol.pack_var_int(@pk_script_length)
+        buf << @pk_script if @pk_script_length > 0
+        buf
+      end
+
+      def to_hash
+        { 'value' => "%.8f" % (@value / 100000000.0),
+          'scriptPubKey' => Bitcoin::Script.new(@pk_script).to_string }
+      end
+
+      def self.from_hash(output)
+        amount = output['value'].gsub('.','').to_i
+        script = Script.binary_from_string(output['scriptPubKey'])
+        new(amount, script)
+      end
+      # set pk_script and pk_script_length
+      def pk_script=(script)
+        @pk_script_length, @pk_script = script.bytesize, script
+      end
+
+      alias :amount   :value
+      alias :amount=  :value=
+      alias :script   :pk_script
+      alias :script=  :pk_script=
+
+
+      # create output spending +value+ btc (base units) to +address+
+      def self.value_to_address(value, address)
+        pk_script = Bitcoin::Script.to_address_script(address)
+        new(value, pk_script)
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/protocol/version.rb

@@ -0,0 +1,70 @@
+module Bitcoin
+  module Protocol
+
+    class Version
+      attr_reader :fields
+      def initialize(opts={})
+        @fields = {
+          :version    => Bitcoin::Protocol::VERSION,
+          :services   => 1,
+          :time       => Time.now.tv_sec,
+          :from       => "127.0.0.1:8333",
+          :to         => "127.0.0.1:8333",
+          :nonce      => Bitcoin::Protocol::Uniq,
+          :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
+          :last_block => 0 # 188617
+        }.merge( opts.reject{|k,v| v == nil } )
+      end
+
+      def to_payload
+        payload = [
+          @fields.values_at(:version, :services, :time).pack("IQQ"),
+          pack_address_field(@fields[:from]),
+          pack_address_field(@fields[:to]),
+          @fields.values_at(:nonce).pack("Q"),
+          Protocol.pack_var_string(@fields[:user_agent]),
+          @fields.values_at(:last_block).pack("I")
+        ].join
+      end
+
+      def to_pkt
+        Bitcoin::Protocol.pkt("version", to_payload)
+      end
+
+      def parse(payload)
+        version, services, timestamp, to, from, nonce, payload = payload.unpack("Ia8Qa26a26Qa*")
+        to, from = unpack_address_field(to), unpack_address_field(from)
+        user_agent, payload = Protocol.unpack_var_string(payload)
+        last_block = payload.unpack("I")[0]
+
+        @fields = {
+         :version => version, :services => services, :time => timestamp,
+         :from => from, :to => to, :nonce => nonce,
+         :user_agent => user_agent, :last_block => last_block
+        }
+        self
+      end
+
+      def unpack_address_field(payload)
+        ip, port = payload.unpack("x8x12a4n")
+        "#{ip.unpack("C*").join(".")}:#{port}"
+      end
+
+      def pack_address_field(addr_str)
+        host, port = addr_str.split(":")
+        port = port ? port.to_i : 8333
+        sockaddr = Socket.pack_sockaddr_in(port, host)
+        #raise "invalid IPv4 Address: #{addr}" unless sockaddr[0...2] == "\x02\x00"
+        port, host = sockaddr[2...4], sockaddr[4...8]
+        [[1].pack("Q"), "\x00"*10, "\xFF\xFF",  host, port].join
+      end
+
+      def uptime
+        @fields[:time] - Time.now.tv_sec
+      end
+
+      def self.parse(payload); new.parse(payload); end
+    end
+
+  end
+end