monacoin-ruby 0.1.2

data/examples/bbe_verify_tx.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+#
+# Fetch a transaction from blockexplorer.com and verify all signatures.
+#
+#  examples/bbe_verify_tx.rb <tx hash> [testnet]
+#  examples/bbe_verify_tx.rb f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16
+# see Bitcoin::P::Tx and Bitcoin::Script.
+
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+require 'bitcoin'
+require 'open-uri'
+
+tx_hash = ARGV[0]
+$testnet = ARGV.select{|i| i.downcase == 'testnet' }[0] ? true : false
+$use_coinbase_bbe = ARGV.select{|i| i.downcase == 'coinbase' }[0] ? true : false
+
+# fetch transaction from bbe as json and deserialize into Bitcoin::Protocol::Tx object
+def get_tx(hash)
+  if $use_coinbase_bbe && !$testnet
+    url = "https://coinbase.com/network/tx/%s.json" % [hash]
+  else
+    url = "http://blockexplorer.com/%srawtx/%s" % [$testnet ? 'testnet/' : '',  hash]
+  end
+  json = open(url).read
+  Bitcoin::Protocol::Tx.from_json(json)
+rescue
+  nil
+end
+
+tx1 = get_tx(tx_hash)
+
+unless tx1
+  puts "Tx #{tx_hash} not found."
+  exit
+end
+
+if tx1.in.all?{|txin| txin.coinbase? }
+  puts "Tx #{tx_hash} is a coinbase transaction. Check the block instead."
+  exit
+end
+
+tx1.in.each_with_index do |txin, idx|
+  if txin.coinbase?
+    puts "skipping coinbase transaction input.."; next
+  end
+
+  prev_tx = get_tx(txin.previous_output)
+  unless prev_tx
+    puts "Missing prev_out tx for input #{idx} of tx #{tx_hash}!"
+    exit
+  end
+
+  result = tx1.verify_input_signature(idx, prev_tx)
+  unless result
+    puts "Input #{idx} of tx #{tx_hash} is invalid!"
+    exit
+  end
+end
+
+puts "Tx #{tx_hash} is valid."

data/examples/concept-blockchain-pow.rb

@@ -0,0 +1,151 @@
+#
+# Ruby Example of the 'proof of work' explanation
+# from https://en.bitcoin.it/wiki/Proof_of_work
+#
+# note: block data passed to do_work is simplified.
+#       bitcoin blockchain is more complex too.
+#
+
+require 'digest/sha2'
+
+
+def do_work(data, target, nonce=0)
+  found = nil
+  until found
+      d = data + [nonce].pack("I")
+      h = Digest::SHA256.hexdigest( Digest::SHA256.digest( d ) ).to_i(16)
+
+      if h <= target
+        found = [h.to_s(16).rjust(64, '0'), nonce]
+        break
+      end
+
+      nonce+=1
+  end
+  found
+end
+
+
+def next_block(blocks, target, data)
+  block_id    = blocks.size
+  last_block  = last_hash(blocks)
+  data        = last_block + " " + data
+
+  hash, nonce = nil, nil
+
+  work_time   = t{   hash, nonce = do_work(data, target.to_i(16))         }
+  verify_time = t{   hash, nonce = do_work(data, target.to_i(16), nonce)  }
+
+  print_block( block_id, target, data, nonce, hash, work_time, verify_time )
+
+  [ hash, nonce, target, data, work_time, verify_time ]
+end
+
+
+
+def print_block(*args)
+  puts <<-TEXT % args
+-------------------- block %s
+  target: %s
+   data: '%s' + %s (nonce)
+   found: %s
+
+  time:
+    took: %f
+  verify: %f
+
+  TEXT
+end
+
+def last_hash(blocks)
+  if blocks.empty?
+    "0000000000000000000000000000000000000000000000000000000000000000"
+  else
+    blocks.last[0]
+  end
+end
+
+def t; x = Time.now; yield; Time.now - x; end
+
+
+
+if $0 == __FILE__
+
+  target = "00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+  blocks = []
+
+
+  blocks << next_block( blocks, target, "hello ruby" )
+  blocks << next_block( blocks, target, "this is" )
+  blocks << next_block( blocks, target, "a blockchain" )
+  blocks << next_block( blocks, target, "and proof-of-work" )
+  blocks << next_block( blocks, target, "example!" )
+
+
+  puts <<-TEXT % [ blocks.size, target, blocks.inject(0){|e,i| e+=i[-2] }, blocks.inject(0){|e,i| e+=i[-1] } ]
+-------------------- blockchain time summary
+       chain length: %d
+         difficulty: %s
+    total work time: %f
+  total verify time: %f
+
+  TEXT
+
+end
+
+
+__END__
+% ruby concept-examples/blockchain-pow.rb
+
+-------------------- block 0
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '0000000000000000000000000000000000000000000000000000000000000000 hello ruby' + 1373297 (nonce)
+   found: 00000b1522d81f532d5e33c4fd22537b66f1ff052315b47000e61496510ceaa2
+
+  time:
+    took: 41.073509
+  verify: 0.000060
+
+-------------------- block 1
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '00000b1522d81f532d5e33c4fd22537b66f1ff052315b47000e61496510ceaa2 this is' + 2877742 (nonce)
+   found: 0000006f3ac527d921b57a88d3d6e5793f0813d4fafb17e0b31456ad1d652e05
+
+  time:
+    took: 86.098830
+  verify: 0.000058
+
+-------------------- block 2
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '0000006f3ac527d921b57a88d3d6e5793f0813d4fafb17e0b31456ad1d652e05 a blockchain' + 255946 (nonce)
+   found: 000000196f5e67ca66f281cf6b884b312984173651ddf12e151db6b1428a882b
+
+  time:
+    took: 7.648288
+  verify: 0.000057
+
+-------------------- block 3
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '000000196f5e67ca66f281cf6b884b312984173651ddf12e151db6b1428a882b and proof-of-work' + 2930300 (nonce)
+   found: 00000a197372b28e93479598afa504c92bcb50af2c5c6893686e91ce47ad0747
+
+  time:
+    took: 87.530473
+  verify: 0.000058
+
+-------------------- block 4
+  target: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+   data: '00000a197372b28e93479598afa504c92bcb50af2c5c6893686e91ce47ad0747 example!' + 85074 (nonce)
+   found: 00000a406be803d6a02c5aded00c159b664fe11ed768dbcb3ecb7b2ec6257706
+
+  time:
+    took: 2.555810
+  verify: 0.000058
+
+-------------------- blockchain time summary
+       chain length: 5
+         difficulty: 00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+    total work time: 224.906909
+  total verify time: 0.000292
+
+

data/examples/connect.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+#
+# Connect to a random peer and download the first 500 blocks.
+#
+#  examples/connect.rb [testnet]
+#
+# see Bitcoin::Connection and Bitcoin::Protocol.
+
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'bitcoin/connection'
+
+Bitcoin::network = ARGV[0] || :bitcoin
+
+class RawJSON_Connection < Bitcoin::Connection
+  def on_tx(tx)
+    p ['tx', tx.hash, Time.now]
+    # puts tx.to_json
+  end
+
+  def on_block(block)
+    p ['block', block.hash, Time.now]
+    # puts block.to_json
+  end
+end
+
+EM.run do
+
+  host = '127.0.0.1'
+  #host = '217.157.1.202'
+
+  connections = []
+  #RawJSON_Connection.connect(host, 8333, connections)
+
+  RawJSON_Connection.connect_random_from_dns(connections)
+
+end

data/examples/generate_tx.rb

@@ -0,0 +1,34 @@
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'bitcoin'
+
+# p Bitcoin.generate_address # returns address, privkey, pubkey, hash160
+
+prev_tx = Bitcoin::Protocol::Tx.from_json_file('baedb362adba39753a7d2c58fd3dc4897a1b479859f707a819f096696f3facad.json') # <- redeeming transaction input fetchted by for example simple_network_monitor_and_util.rb
+prev_tx_output_index = 0
+value = prev_tx.outputs[prev_tx_output_index].value
+#value = 1337 # maybe change the value (eg subtract for fees)
+
+
+tx = Bitcoin::Protocol::Tx.new
+tx.add_in Bitcoin::Protocol::TxIn.new(prev_tx.binary_hash, prev_tx_output_index, 0)
+
+tx.add_out Bitcoin::Protocol::TxOut.value_to_address(value, "1MiQ3zD3hzZBZ4cUDfPd8Eqnjcedkwt5jy") # <- dest address (our donation address)
+
+# if all in and outputs are defined, start signing inputs.
+key = Bitcoin.open_key("9b2f08ebc186d435ffc1d10f3627f05ce4b983b72c76b0aee4fcce99e57b0342") # <- privkey
+sig = Bitcoin.sign_data(key, tx.signature_hash_for_input(0, prev_tx))
+tx.in[0].script_sig = Bitcoin::Script.to_signature_pubkey_script(sig, [key.public_key_hex].pack("H*"))
+#tx.in[0].add_signature_pubkey_script(sig, key.public_key_hex)
+
+# finish check
+tx = Bitcoin::Protocol::Tx.new( tx.to_payload )
+p tx.hash
+p tx.verify_input_signature(0, prev_tx) == true
+
+puts "json:\n"
+puts tx.to_json # json
+puts "\nhex:\n"
+puts tx.to_payload.unpack("H*")[0] # hex binary
+
+# use this json file for example with `ruby simple_network_monitor_and_util.rb send_tx=<filename>` to push/send it to the network
+File.open(tx.hash + ".json", 'wb'){|f| f.print tx.to_json }

data/examples/simple_network_monitor_and_util.rb

@@ -0,0 +1,195 @@
+$:.unshift( File.expand_path("../../lib", __FILE__) )
+require 'eventmachine'
+require 'bitcoin'
+require 'socket'
+
+class Bitcoin::Protocol::Parser; def log; stub=Object.new; def stub.method_missing(*a); end; stub; end; end
+
+
+module SimpleNode
+  class Connection < EM::Connection
+
+    def on_ping(nonce)
+      send_data(Bitcoin::Protocol.pong_pkt(nonce)) if nonce
+    end
+
+    def on_reject(reject)
+      log.info { "reject #{reject}" }
+    end
+
+    def on_tx(tx)
+      log.info { "received transaction: #{tx.hash}" }
+
+      puts tx.to_json
+
+      if tx.hash == @ask_tx
+        @args[:result] = tx
+        @args[:callback] ? (close_connection; @args[:callback].call(tx)) : EM.stop
+      end
+    end
+
+    def on_block(block)
+      log.info { "received block: #{block.hash}" }
+
+      puts block.to_json
+
+      if block.hash == @ask_block
+        if @ask_tx
+          if tx = block.tx.find{|tx| tx.hash == @ask_tx }
+            on_tx(tx)
+          else
+            log.info { "@ask_tx #{@ask_tx} not in @ask_block #{@ask_block}" }
+            @args[:result] = nil
+            @args[:callback] ? (close_connection; @args[:callback].call(nil)) : EM.stop
+          end
+        else
+          @args[:result] = block
+          @args[:callback] ? (close_connection; @args[:callback].call(block)) : EM.stop
+        end
+      end
+    end
+
+    def on_handshake_complete
+      return if @connected
+      @connected = true
+      log.info { "handshake complete" }
+      
+      EM.add_timer(0.5){
+        if @ask_block
+          log.info { "ask for @ask_block: #{@ask_block}" }
+          send_data Bitcoin::Protocol.getdata_pkt(:block, [htb(@ask_block)])
+        else
+          if @ask_tx
+            log.info { "ask for @ask_tx: #{@ask_tx}" }
+            send_data Bitcoin::Protocol.getdata_pkt(:tx, [htb(@ask_tx)])
+          end
+        end
+        if @send_tx
+          tx = Bitcoin::P::Tx.from_json(File.read(@send_tx))
+          send_data(Bitcoin::Protocol.pkt('tx', tx.to_payload))
+          p [:sent, tx.hash]
+        end
+      }
+    end
+
+    def on_get_transaction(hash); end
+    def on_get_block(hash); end
+    def on_addr(addr); end
+    def on_inv_transaction(hash)
+      log.info { "peer told us about transaction: #{hth(hash)}" }
+      log.info { "asking peer for transaction: #{hth(hash)}" }
+      send_data Bitcoin::Protocol.getdata_pkt(:tx, [hash])
+    end
+
+    def on_inv_block(hash)
+      log.info { "peer told us about block: #{hth(hash)}" }
+      log.info { "asking peer for block: #{hth(hash)}" }
+      send_data Bitcoin::Protocol.getdata_pkt(:block, [hash])
+    end
+
+    def on_handshake_begin
+      log.info { "handshake started" }
+
+      version = Bitcoin::Protocol::Version.new({
+        :user_agent => "/Satoshi:0.8.1/",
+        :last_block => 0,
+        :from       => "127.0.0.1:#{Bitcoin.network[:default_port]}",
+        :to         => "#{@host}:#{@port}",
+      })
+
+      log.info { "sending version:  Version:%d (%s)  Block:%d" % version.fields.values_at(:version, :user_agent, :last_block) }
+      send_data(version.to_pkt)
+    end
+
+    def on_version(version)
+      @version ||= version
+      log.info { "received version:  Version:%d (%s)  Block:%d" % version.fields.values_at(:version, :user_agent, :last_block) }
+      send_data( Bitcoin::Protocol.verack_pkt )
+      on_handshake_complete
+    end
+
+    def initialize(host, port, node=nil, opts={})
+      set_host(host, port)
+      @node   = node
+      @parser = Bitcoin::Protocol::Parser.new( self )
+
+      @args = opts
+      @ask_tx, @ask_block, @send_tx = opts.values_at(:ask_tx, :ask_block, :send_tx)
+    end
+
+    def receive_data(data); @parser.parse(data); end
+    def post_init; log.info { "peer connected" }; on_handshake_begin; end
+    def unbind; log.info { "peer disconnected" }; end
+    def set_host(host, port=8333); @host, @port = host, port; end
+
+    def log
+      return @log if @log
+      return (@log = (stub=Object.new; def stub.method_missing(*a); end; stub)) if @args[:nolog]
+      @logger ||= Bitcoin::Logger.create(:network, :info) unless @node.respond_to?(:log)
+      @log = Bitcoin::Logger::LogWrapper.new("#@host:#@port", @logger || @node.log)
+    end
+
+    def hth(h); h.unpack("H*")[0]; end
+    def htb(h); [h].pack("H*"); end
+
+
+    def self.connect(host, port, *args)
+      EM.connect(host, port, self, host, port, *args)
+    end
+
+    def self.connect_random_from_dns(seeds=[], count=1, *args)
+      seeds = Bitcoin.network[:dns_seeds] unless seeds.any?
+      if seeds.any?
+        seeds.sample(count).map{|dns|
+          host = IPSocket.getaddress(dns)
+          connect(host, Bitcoin.network[:default_port], *args)
+        }
+      else
+        raise "No DNS seeds available. Provide IP, configure seeds, or use different network."
+      end
+    end
+
+    def self.connect_known_nodes(count=1)
+      connect_random_from_dns(Bitcoin.network[:known_nodes], count)
+    end
+  end
+end
+
+
+if $0 == __FILE__
+
+  args = {
+    ask_tx:    ARGV.find{|a| a[/tx=(.+)/, 1] } && $1,
+    ask_block: ARGV.find{|a| a[/block=(.+)/, 1] } && $1,
+    use_node:  ARGV.find{|a| a[/node=(.+)/, 1] } && $1,
+    send_tx:   ARGV.find{|a| a[/send_tx=(.+)/, 1] } && $1,
+    set_project:  ARGV.find{|a| a[/project=(.+)/, 1] } && $1,
+    callback:  proc{|i|
+                 case i
+                 when Bitcoin::Protocol::Block
+                   puts "INFO  network: SAVING @ask_block: #{i.hash}"
+                   File.open("block-#{i.hash}.bin", 'wb'){|f| f.print i.payload }
+                   File.open("block-#{i.hash}.json", 'wb'){|f| f.print i.to_json }
+                 when Bitcoin::Protocol::Tx
+                   puts "INFO  network: SAVING @ask_tx: #{i.hash}"
+                   File.open("tx-#{i.hash}.bin", 'wb'){|f| f.print i.payload }
+                   File.open("tx-#{i.hash}.json", 'wb'){|f| f.print i.to_json }
+                 end
+                 EM.stop
+               }
+  }
+
+  
+  EM.run do
+    if args[:set_project]
+      Bitcoin.network = args[:set_project].to_sym
+      p Bitcoin.network_project
+    end
+    if args[:use_node]
+      SimpleNode::Connection.connect_random_from_dns([args[:use_node]], 1, nil, args)
+    else
+      SimpleNode::Connection.connect_random_from_dns([], 1, nil, args)
+    end
+  end
+
+end