bitcoin-ruby 0.0.5 → 0.0.6

data/lib/bitcoin/key.rb

@@ -7,8 +7,8 @@ module Bitcoin
 
     # Generate a new keypair.
     #  Bitcoin::Key.generate
-    def self.generate
-      k = new; k.generate; k
+    def self.generate(opts={compressed: true})
+      k = new(nil, nil, opts); k.generate; k
     end
 
     # Import private key from base58 fromat as described in
@@ -24,7 +24,7 @@ module Bitcoin
       key = new(key, nil, compressed)
     end
 
-    def == other
+    def ==(other)
       self.priv == other.priv
     end
 
@@ -32,11 +32,12 @@ module Bitcoin
     #  Bitcoin::Key.new
     #  Bitcoin::Key.new(privkey)
     #  Bitcoin::Key.new(nil, pubkey)
-    def initialize privkey = nil, pubkey = nil, compressed = false
+    def initialize(privkey = nil, pubkey = nil, opts={compressed: true})
+      compressed = opts.is_a?(Hash) ? opts.fetch(:compressed, true) : opts
       @key = Bitcoin.bitcoin_elliptic_curve
       @pubkey_compressed = pubkey ? self.class.is_compressed_pubkey?(pubkey) : compressed
       set_priv(privkey)  if privkey
-      set_pub(pubkey)  if pubkey
+      set_pub(pubkey, @pubkey_compressed)  if pubkey
     end
 
     # Generate new priv/pub key.
@@ -59,21 +60,17 @@ module Bitcoin
     # In case the key was initialized with only
     # a private key, the public key is regenerated.
     def pub
+      regenerate_pubkey unless @key.public_key
+      return nil        unless @key.public_key
       @pubkey_compressed ? pub_compressed : pub_uncompressed
     end
 
     def pub_compressed
-      regenerate_pubkey unless @key.public_key
-      return nil        unless @key.public_key
       @key.public_key.group.point_conversion_form = :compressed
-      hex = @key.public_key.to_hex.rjust(66, '0')
-      @key.public_key.group.point_conversion_form = :uncompressed
-      hex
+      @key.public_key.to_hex.rjust(66, '0')
     end
 
     def pub_uncompressed
-      regenerate_pubkey unless @key.public_key
-      return nil        unless @key.public_key
       @key.public_key.group.point_conversion_form = :uncompressed
       @key.public_key.to_hex.rjust(130, '0')
     end
@@ -99,7 +96,7 @@ module Bitcoin
 
     # Sign +data+ with the key.
     #  key1 = Bitcoin::Key.generate
-    #  sig = key.sign("some data")
+    #  sig = key1.sign("some data")
     def sign(data)
       @key.dsa_sign_asn1(data)
     end
@@ -108,6 +105,7 @@ module Bitcoin
     #  key2 = Bitcoin::Key.new(nil, key1.pub)
     #  key2.verify("some data", sig)
     def verify(data, sig)
+      regenerate_pubkey unless @key.public_key
       @key.dsa_verify_asn1(data, sig)
     end
 
@@ -162,12 +160,87 @@ module Bitcoin
       Bitcoin.int_to_base58( hex.to_i(16) )
     end
 
+
+    # Export private key to bip38 (non-ec-multiply) format as described in
+    # https://github.com/bitcoin/bips/blob/master/bip-0038.mediawiki
+    # See also Key.from_bip38
+    def to_bip38(passphrase)
+      flagbyte = compressed ? "\xe0" : "\xc0"
+      addresshash = Digest::SHA256.digest( Digest::SHA256.digest( self.addr ) )[0...4]
+
+      require 'scrypt' unless defined?(::SCrypt::Engine)
+      buf = SCrypt::Engine.__sc_crypt(passphrase, addresshash, 16384, 8, 8, 64)
+      derivedhalf1, derivedhalf2 = buf[0...32], buf[32..-1]
+
+      aes = proc{|k,a,b|
+        cipher = OpenSSL::Cipher::AES.new(256, :ECB); cipher.encrypt; cipher.padding = 0; cipher.key = k
+        cipher.update [ (a.to_i(16) ^ b.unpack("H*")[0].to_i(16)).to_s(16).rjust(32, '0') ].pack("H*")
+      }
+
+      encryptedhalf1 = aes.call(derivedhalf2, self.priv[0...32], derivedhalf1[0...16])
+      encryptedhalf2 = aes.call(derivedhalf2, self.priv[32..-1], derivedhalf1[16..-1])
+
+      encrypted_privkey = "\x01\x42" + flagbyte + addresshash + encryptedhalf1 + encryptedhalf2
+      encrypted_privkey += Digest::SHA256.digest( Digest::SHA256.digest( encrypted_privkey ) )[0...4]
+
+      encrypted_privkey = Bitcoin.encode_base58( encrypted_privkey.unpack("H*")[0] )
+    end
+
+    # Import private key from bip38 (non-ec-multiply) fromat as described in
+    # https://github.com/bitcoin/bips/blob/master/bip-0038.mediawiki
+    # See also #to_bip38
+    def self.from_bip38(encrypted_privkey, passphrase)
+      version, flagbyte, addresshash, encryptedhalf1, encryptedhalf2, checksum =
+        [ Bitcoin.decode_base58(encrypted_privkey) ].pack("H*").unpack("a2aa4a16a16a4")
+      compressed = (flagbyte == "\xe0") ? true : false
+
+      raise "Invalid version"   unless version == "\x01\x42"
+      raise "Invalid checksum"  unless Digest::SHA256.digest(Digest::SHA256.digest(version + flagbyte + addresshash + encryptedhalf1 + encryptedhalf2))[0...4] == checksum
+
+      require 'scrypt' unless defined?(::SCrypt::Engine)
+      buf = SCrypt::Engine.__sc_crypt(passphrase, addresshash, 16384, 8, 8, 64)
+      derivedhalf1, derivedhalf2 = buf[0...32], buf[32..-1]
+
+      aes = proc{|k,a|
+        cipher = OpenSSL::Cipher::AES.new(256, :ECB); cipher.decrypt; cipher.padding = 0; cipher.key = k
+        cipher.update(a)
+      }
+
+      decryptedhalf2 = aes.call(derivedhalf2, encryptedhalf2)
+      decryptedhalf1 = aes.call(derivedhalf2, encryptedhalf1)
+
+      priv = decryptedhalf1 + decryptedhalf2
+      priv = (priv.unpack("H*")[0].to_i(16) ^ derivedhalf1.unpack("H*")[0].to_i(16)).to_s(16).rjust(64, '0')
+      key = Bitcoin::Key.new(priv, nil, compressed)
+
+      if Digest::SHA256.digest( Digest::SHA256.digest( key.addr ) )[0...4] != addresshash
+        raise "Invalid addresshash! Password is likely incorrect."
+      end
+
+      key
+    end
+
+    # Import private key from warp fromat as described in
+    # https://github.com/keybase/warpwallet
+    # https://keybase.io/warp/
+    def self.from_warp(passphrase, salt="", compressed=false)
+      require 'scrypt' unless defined?(::SCrypt::Engine)
+      s1 = SCrypt::Engine.scrypt(passphrase+"\x01", salt+"\x01", 2**18, 8, 1, 32)
+      s2 = OpenSSL::PKCS5.pbkdf2_hmac(passphrase+"\x02", salt+"\x02", 2**16, 32, OpenSSL::Digest::SHA256.new)
+      s3 = s1.bytes.zip(s2.bytes).map{|a,b| a ^ b }.pack("C*")
+
+      key = Bitcoin::Key.new(s3.unpack("H*")[0], nil, compressed)
+      # [key.addr, key.to_base58, [s1,s2,s3].map{|i| i.unpack("H*")[0] }, compressed]
+      key
+    end
+
+
     protected
 
     # Regenerate public key from the private key.
     def regenerate_pubkey
       return nil unless @key.private_key
-      set_pub(Bitcoin::OpenSSL_EC.regenerate_key(priv)[1])
+      set_pub(Bitcoin::OpenSSL_EC.regenerate_key(priv)[1], @pubkey_compressed)
     end
 
     # Set +priv+ as the new private key (converting from hex).
@@ -176,8 +249,8 @@ module Bitcoin
     end
 
     # Set +pub+ as the new public key (converting from hex).
-    def set_pub(pub)
-      @pubkey_compressed ||= self.class.is_compressed_pubkey?(pub)
+    def set_pub(pub, compressed = nil)
+      @pubkey_compressed = compressed == nil ? self.class.is_compressed_pubkey?(pub) : compressed
       @key.public_key = OpenSSL::PKey::EC::Point.from_hex(@key.group, pub)
     end
 

data/lib/bitcoin/litecoin.rb

@@ -3,12 +3,6 @@ require 'openssl'
 module Litecoin
   module Scrypt
 
-    def scrypt_1024_1_1_256(input)
-      input = [input].pack("H*") if input.bytesize == 160
-      #scrypt_1024_1_1_256_sp(input, scratchpad = Array.new(131072 + 63){ 0 })
-      scrypt_1024_1_1_256_sp(input)
-    end
-
     def scrypt_1024_1_1_256_sp(input, scratchpad=[])
       b = pbkdf2_sha256(input, input, 1, 128)
       x = b.unpack("V*")
@@ -27,7 +21,7 @@ module Litecoin
         xor_salsa8(x, x, 16, 0)
       }
 
-      pbkdf2_sha256(input, x.pack("V*"), 1, 32).reverse.unpack("H*")[0]
+      pbkdf2_sha256(input, x.pack("V*"), 1, 32)
     end
 
     def pbkdf2_sha256(pass, salt, c=1, dk_len=128)
@@ -70,12 +64,20 @@ end
 
 if $0 == __FILE__
   secret_hex = "020000004c1271c211717198227392b029a64a7971931d351b387bb80db027f270411e398a07046f7d4a08dd815412a8712f874a7ebf0507e3878bd24e20a3b73fd750a667d2f451eac7471b00de6659"
-  p Litecoin::Scrypt.scrypt_1024_1_1_256(secret_hex) == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806"
+  secret_bytes = [secret_hex].pack("H*")
+ 
+  begin
+    require "scrypt"
+    hash = SCrypt::Engine.__sc_crypt(secret_bytes, secret_bytes, 1024, 1, 1, 32)
+    p hash.reverse.unpack("H*")[0] == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806"
+  rescue LoadError
+    puts "scrypt gem not found, using native scrypt"
+    p Litecoin::Scrypt.scrypt_1024_1_1_256_sp(secret_bytes).reverse.unpack("H*")[0] == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806"
+  end
 
   require 'benchmark'
-  secret_bytes = [secret_hex].pack("H*")
   Benchmark.bmbm{|x|
-    #x.report("v1"){ p Litecoin::Scrypt.scrypt_1024_1_1_256_sp_old(secret_bytes) == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806" }
-    x.report("v2"){ p Litecoin::Scrypt.scrypt_1024_1_1_256_sp(secret_bytes) == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806" }
+    x.report("v1"){ SCrypt::Engine.__sc_crypt(secret_bytes, secret_bytes, 1024, 1, 1, 32).reverse.unpack("H*") rescue nil }
+    x.report("v2"){ Litecoin::Scrypt.scrypt_1024_1_1_256_sp(secret_bytes).reverse.unpack("H*")[0] }
   }
 end

data/lib/bitcoin/namecoin.rb

@@ -32,6 +32,7 @@ module Bitcoin::Namecoin
         def get_hash160
           return @chunks[2..-3][0].unpack("H*")[0]  if is_hash160?
           return @chunks[-3].unpack("H*")[0]        if is_namecoin?
+          return @chunks[-2].unpack("H*")[0]        if is_p2sh?
           return Bitcoin.hash160(get_pubkey)        if is_pubkey?
         end
 
@@ -262,12 +263,12 @@ module Bitcoin::Namecoin
         end
 
         def expires_in
-          Namecoin::EXPIRATION_DEPTH - (@store.get_depth - get_block.depth) rescue nil
+          Bitcoin::Namecoin::EXPIRATION_DEPTH - (@store.get_depth - get_block.depth) rescue nil
         end
 
-        def to_json(opts = {})
-          JSON.pretty_generate({ name: @name, value: @value, txid: get_tx.hash,
-                                 address: get_address, expires_in: expires_in }, opts)
+        def as_json(opts = {})
+          { name: @name, value: @value, txid: get_tx.hash,
+                                 address: get_address, expires_in: expires_in }
         end
 
       end

data/lib/bitcoin/network/command_client.rb

@@ -19,6 +19,8 @@ class Bitcoin::Network::CommandClient < EM::Connection
     instance_eval &block  if block
     @buffer = BufferedTokenizer.new("\x00")
     @connection_attempts = 0
+    @requests = {}
+    @i = 0
   end
 
   def log;
@@ -32,7 +34,7 @@ class Bitcoin::Network::CommandClient < EM::Connection
   # call +connected+ callback
   def post_init
     log.debug { "Connected" }
-    callback :connected
+    request(:connected) { callback(:connected) }
   end
 
   # call +disconnected+ callback and try to reconnect
@@ -47,21 +49,29 @@ class Bitcoin::Network::CommandClient < EM::Connection
   end
 
   # request command +cmd+ with +args+ from the server
-  def request cmd, *args
+  def request cmd, params = nil, &block
+    id = @i += 1
+    @requests[id] = block  if block
     log.debug { "request: #{cmd} #{args.inspect}" }
-    register_monitor_callbacks  if cmd.to_sym == :monitor
-    send_data([cmd, args].to_json + "\x00")
+    register_monitor_callbacks(params)  if cmd.to_sym == :monitor
+    request = { id: id, method: cmd }
+    request[:params] = params  if params
+    send_data(request.to_json + "\x00")
   end
 
   # receive response from server
   def receive_data data
     @connection_attempts = 0
     @buffer.extract(data).each do |packet|
-      cmd, *data = *JSON.load(packet)
-      log.debug { d = data.inspect
-        "response: #{cmd} #{d[0...50]}#{d.size > 50 ? '...' : ''}" }
-      callback(:response, cmd, *data)
-      callback(cmd.to_sym, *data)
+      response = JSON.parse(packet)
+      log.debug { d = response['result'].inspect
+        "response: #{response['method']} #{d[0...50]}#{d.size > 50 ? '...' : ''}" }
+      if cb = @requests[response['id']]
+        cb.call(response['result'])
+      else
+        callback(:response, response['method'], response['result'])
+        callback(response['method'].to_sym, response['result'])
+      end
     end
   end
 
@@ -84,10 +94,10 @@ class Bitcoin::Network::CommandClient < EM::Connection
   end
 
   # register callbacks for monitor
-  def register_monitor_callbacks
-    on_monitor do |type, data|
-      type, *params = type.split("_")
-      callback(type, *((data || []) + (params || [])))
+  def register_monitor_callbacks params
+    on_monitor do |data|
+      next  if data.is_a?(Hash) && data.keys == ["id"]
+      callback(params["channel"], data)
     end
   end
 

data/lib/bitcoin/network/command_handler.rb

@@ -13,6 +13,7 @@ class Bitcoin::Network::CommandHandler < EM::Connection
     @node.command_connections << self
     @buf = BufferedTokenizer.new("\x00")
     @lock = Monitor.new
+    @monitors = []
   end
 
   # wrap logger and append prefix
@@ -21,10 +22,12 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   end
 
   # respond to a command; send serialized response to the client
-  def respond(cmd, data)
+  def respond(request, data)
     return  unless data
+    request[:result] = data
+    request.delete(:params)
     @lock.synchronize do
-      send_data([cmd, data].to_json + "\x00")
+      send_data(request.to_json + "\x00")
     end
   end
 
@@ -32,79 +35,159 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   def receive_data data
     @buf.extract(data).each do |packet|
       begin
-        cmd, args = JSON::parse(packet)
-        log.debug { [cmd, args] }
-        if cmd == "relay_tx"
-          handle_relay_tx(*args)
-          return
-        end
-        if respond_to?("handle_#{cmd}")
-          respond(cmd, send("handle_#{cmd}", *args))
+        request = symbolize_keys(JSON::parse(packet))
+        log.debug { request }
+        case request[:method]
+        when "relay_tx"
+          return handle_relay_tx(request, request[:params])
+        when "monitor"
+          respond(request, handle_monitor(request, request[:params]))
         else
-          respond(cmd, { error: "unknown command: #{cmd}. send 'help' for help." })
+          if respond_to?("handle_#{request[:method]}")
+            if request[:params] && request[:params].any?
+              respond(request, send("handle_#{request[:method]}", request[:params]))
+            else
+              respond(request, send("handle_#{request[:method]}"))
+            end
+          else
+            respond(request, { error: "unknown command: #{request[:method]}. send 'help' for help." })
+          end
         end
-      rescue ArgumentError
-        respond(cmd, { error: $!.message })
+      rescue
+        respond(request, { error: $!.message })
+        p $!; puts *$@
       end
     end
-  rescue Exception
+  rescue
     p $!; puts *$@
   end
 
-  # handle +monitor+ command; subscribe client to specified channels
+  def handle_connected
+    "connected"
+  end
+
+  # Handle +monitor+ command; subscribe client to specified channels
   # (+block+, +tx+, +output+, +connection+).
-  # Some commands can have parameters, e.g. the number of confirmations
+  # Parameters can be appended to the channel name, e.g. the number of confirmations
   # +tx+ or +output+ should have. Parameters are appended to the command
   # name after an underscore (_), e.g. subscribe to channel "tx_6" to
   # receive only transactions with 6 confirmations.
-  # 
+  # You can send the last block/tx/output you know about, and it will also send you
+  # all the objects you're missing.
+  #
   # Receive new blocks:
   #  bitcoin_node monitor block
+  # Receive blocks since block 123, and new ones as they come in:
+  #  bitcoin_node monitor block_123
   # Receive new (unconfirmed) transactions:
   #  bitcoin_node monitor tx
   # Receive transactions with 6 confirmations:
-  #  bitcoin_node monitor tx_6 
-  # Receive [txhash, address, value] for each output:
+  #  bitcoin_node monitor tx_6
+  # Receive transactions since <txhash>, and new ones as they come in:
+  #  bitcoin_node monitor tx_1_<txhash>
+  # Receive [txhash, idx, address, value] for each output:
   #  bitcoin_node monitor output
+  # Receive outputs since <txhash>:<idx>, and new ones as they come in:
+  #  bitcoin_node monitor output_1_<txhash>:<idx>
   # Receive peer connections/disconnections:
   #  bitcoin_node monitor connection"
   # Combine multiple channels:
   #  bitcoin_node monitor "block tx tx_1 tx_6 connection"
-  # 
+  #
   # NOTE: When a new block is found, it might include transactions that we
   # didn't previously receive as unconfirmed. To make sure you receive all
   # transactions, also subscribe to the tx_1 channel.
-  def handle_monitor *channels
-    channels.map(&:to_sym).each do |channel|
-      @node.subscribe(channel) {|*data| respond("monitor", [channel, *data]) }
-      name, *params = channel.to_s.split("_")
-      send("handle_monitor_#{name}", *params)
-      log.info { "Client subscribed to channel #{channel}" }
+  def handle_monitor request, params
+    log.info { "Client subscribed to channel #{params[:channel].inspect}" }
+    { id: send("handle_monitor_#{params[:channel]}", request, params) }
+  end
+
+  # Handle +unmonitor+ command; cancel given subscription.
+  # Parameter +id+ must be the subscription ID that was returned when calling +monitor+.
+  def handle_unmonitor request
+    id = request[:id]
+    raise "Monitor #{id} not found."  unless @monitors[id]
+    @monitors[id][:channels].each {|name, id| @node.unsubscribe(name, id) }
+    { id: id }
+  end
+
+  # Handle +monitor block+ command;
+  def handle_monitor_block request, params
+    monitor_id = @monitors.size
+    id = @node.subscribe(:block) {|blk, depth| respond_monitor_block(request, blk, depth) }
+    add_monitor(params, [[:block, id]])
+    respond_missed_blocks(request, monitor_id)  if params[:last]
+    monitor_id
+  end
+
+  def respond_missed_blocks request, monitor_id
+    params = @monitors[monitor_id][:params]
+    blk = @node.store.get_block(params[:last])
+    respond_monitor_block(request, blk)
+    while blk = blk.get_next_block
+      respond_monitor_block(request, blk)
     end
-    nil
   end
 
-  # Handle +monitor block+ command; send the current chain head
-  # after client is subscribed to :block channel
-  def handle_monitor_block
-    head = Bitcoin::P::Block.new(@node.store.get_head.to_payload) rescue nil
-    respond("monitor", ["block", [head, @node.store.get_depth]])  if head
+  def respond_monitor_block request, block, depth = nil
+    depth ||= block.depth
+    respond(request, { hash: block.hash, hex: block.to_payload.hth, depth: depth })
+  end
+
+  # TODO: params (min reorg depth)
+  def handle_monitor_reorg request, params
+    id = @node.subscribe(:reorg) do |new_main, new_side|
+      respond(request, { new_main: new_main, new_side: new_side })
+    end
+
+    add_monitor(params, [[:reorg, id]])
   end
 
   # Handle +monitor tx+ command.
   # When +conf+ is given, don't subscribe to the :tx channel for unconfirmed
   # transactions. Instead, subscribe to the :block channel, and whenever a new
   # block comes in, send all transactions that now have +conf+ confirmations.
-  def handle_monitor_tx conf = nil
-    return  unless conf
-    if conf.to_i == 0 # 'tx_0' is just an alias for 'tx'
-      return @node.subscribe(:tx) {|*a| @node.notifiers[:tx_0].push(*a) }
+  def handle_monitor_tx request, params
+    monitor_id = @monitors.size
+    tx_id = @node.subscribe(:tx) {|tx, conf| respond_monitor_tx(request, monitor_id, tx, conf) }
+
+    conf = params[:conf].to_i
+    block_id = @node.subscribe(:block) do |block, depth|
+      next  unless block = @node.store.get_block_by_depth(depth - conf + 1)
+      block.tx.each {|tx| respond_monitor_tx(request, monitor_id, tx, conf) }
+    end
+
+    add_monitor(params, [[:tx, tx_id], [:block, block_id]])
+
+    respond_missed_txs(request, params, monitor_id)  if params[:last]
+
+    monitor_id
+  end
+
+  def respond_missed_txs request, params, monitor_id
+    return  unless last_tx = @node.store.get_tx(params[:last])
+    notify = false; depth = @node.store.get_depth
+    (last_tx.get_block.depth..depth).each do |i|
+      blk = @node.store.get_block_by_depth(i)
+      blk.tx.each do |tx|
+        respond_monitor_tx(request, monitor_id, tx, (depth - blk.depth + 1))  if notify
+        notify = true  if tx.hash == last_tx.hash
+      end
     end
-    @node.subscribe(:block) do |block, depth|
-      block = @node.store.get_block_by_depth(depth - conf.to_i + 1)
-      next  unless block
-      block.tx.each {|tx| @node.notifiers["tx_#{conf}".to_sym].push([tx, conf.to_i]) }
+  end
+
+  def respond_monitor_tx request, monitor_id, tx, conf = nil
+    conf ||= tx.confirmations
+
+    params = @monitors[monitor_id][:params]
+
+    # filter by addresses
+    if params[:addresses]
+      addrs = tx.out.map(&:parsed_script).map(&:get_address)
+      return  unless (params[:addresses] & addrs).any?
     end
+
+    respond(request, { hash: tx.hash, nhash: tx.nhash, hex: tx.to_payload.hth, conf: conf })
   end
 
   # Handle +monitor output+ command.
@@ -112,27 +195,82 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   # This allows easy scanning for new payments without parsing the
   # tx format and running scripts.
   # See #handle_monitor_tx for confirmation behavior.
-  def handle_monitor_output conf = 0
-    return  unless (conf = conf.to_i) > 0
-    @node.subscribe(:block) do |block, depth|
-      block = @node.store.get_block_by_depth(depth - conf + 1)
-      next  unless block
-      block.tx.each do |tx|
-        tx.out.each do |out|
-          addr = Bitcoin::Script.new(out.pk_script).get_address
-          res = [tx.hash, addr, out.value, conf]
-          @node.push_notification("output_#{conf}".to_sym, res)
+  def handle_monitor_output request, params
+    monitor_id = @monitors.size
+
+    tx_id = @node.subscribe(:tx) do |tx, conf|
+      tx.out.each.with_index do |out, idx|
+        respond_monitor_output(request, monitor_id, tx, out, idx, conf)
+      end
+    end
+
+    if (conf = params[:conf].to_i) > 0
+      block_id = @node.subscribe(:block) do |block, depth|
+        block = @node.store.get_block_by_depth(depth - conf + 1)
+        next  unless block
+        block.tx.each do |tx|
+          tx.out.each.with_index do |out, idx|
+            respond_monitor_output(request, monitor_id, tx, out, idx, conf)
+          end
         end
       end
     end
+
+    add_monitor(params, [[:tx, tx_id], [:block, block_id]])
+
+    respond_missed_outputs(request, monitor_id)  if params[:last]
+
+    monitor_id
+  end
+
+  def respond_missed_outputs request, monitor_id
+    params = @monitors[monitor_id][:params]
+    last_hash, last_idx = *params[:last].split(":"); last_idx = last_idx.to_i
+    return  unless last_tx = @node.store.get_tx(last_hash)
+    return  unless last_out = last_tx.out[last_idx]
+    notify = false
+    depth = @node.store.get_depth
+    (last_tx.get_block.depth..depth).each do |i|
+      blk = @node.store.get_block_by_depth(i)
+      blk.tx.each do |tx|
+        tx.out.each.with_index do |out, idx|
+          if notify
+            respond_monitor_output(request, monitor_id, tx, out, idx, (depth - blk.depth + 1))
+          else
+            notify = true  if tx.hash == last_hash && idx == last_idx
+          end
+        end
+      end
+    end
+  end
+
+  def respond_monitor_output request, monitor_id, tx, out, idx, conf
+    addr = out.parsed_script.get_address
+
+    params = @monitors[monitor_id][:params]
+
+    # filter by addresses
+    return  if params[:addresses] && !params[:addresses].include?(addr)
+
+    respond(request, { nhash: tx.nhash, hash: tx.hash, idx: idx,
+        address: addr, value: out.value, conf: conf })
+  end
+
+  # Handle +filter monitor output+ command; add given +address+ to the list of
+  # filtered addresses in the params of the given monitor.
+  def handle_filter_monitor_output request
+    @monitors[request[:id]][:params][:addresses] << request[:address]
+    { id: request[:id] }
   end
 
   # Handle +monitor connection+ command; send current connections
   # after client is subscribed to :connection channel.
-  def handle_monitor_connection
-    @node.connections.select {|c| c.connected?}.each do |conn|
-      respond("monitor", [:connection, [:connected, conn.info]])
+  def handle_monitor_connection request, params
+    id = @node.subscribe(:connection) {|data| respond(request, data) }
+      @node.connections.select {|c| c.connected?}.each do |conn|
+      respond(request, conn.info.merge(type: :connected))
     end
+    add_monitor(params, [[:connection, id]])
   end
 
   # Get various statistics.
@@ -141,21 +279,39 @@ class Bitcoin::Network::CommandHandler < EM::Connection
     blocks = @node.connections.map(&:version).compact.map(&:last_block) rescue nil
     established = @node.connections.select {|c| c.state == :connected }
     info = {
-      :blocks => "#{@node.store.get_depth} (#{(blocks.inject{|a,b| a+=b; a } / blocks.size rescue '?' )})#{@node.store.in_sync? ? ' sync' : ''}",
-      :addrs => "#{@node.addrs.select{|a| a.alive?}.size} (#{@node.addrs.size})",
-      :connections => "#{established.size} established (#{established.select(&:outgoing?).size} out, #{established.select(&:incoming?).size} in), #{@node.connections.size - established.size} connecting",
-      :queue => @node.queue.size,
-      :inv_queue => @node.inv_queue.size,
-      :inv_cache => @node.inv_cache.size,
-      :network => @node.config[:network],
-      :storage => @node.config[:storage],
-      :version => Bitcoin.network[:protocol_version],
-      :external_ip => @node.external_ip,
-      :uptime => format_uptime(@node.uptime),
+      blocks: {
+        depth: @node.store.get_depth,
+        peers: (blocks.inject{|a,b| a+=b; a } / blocks.size rescue '?' ),
+        sync: @node.store.in_sync?,
+      },
+      addrs: {
+        alive: @node.addrs.select{|a| a.alive?}.size,
+        total: @node.addrs.size,
+      },
+      connections: {
+        established: established.size,
+        outgoing: established.select(&:outgoing?).size,
+        incoming: established.select(&:incoming?).size,
+        connecting: @node.connections.size - established.size,
+      },
+      queue: @node.queue.size,
+      inv_queue: @node.inv_queue.size,
+      inv_cache: @node.inv_cache.size,
+      network: @node.config[:network],
+      storage: @node.config[:storage],
+      version: Bitcoin.network[:protocol_version],
+      external_ip: @node.external_ip,
+      uptime: @node.uptime,
     }
-    Bitcoin.namecoin? ? {:names => @node.store.db[:names].count}.merge(info) : info
+    Bitcoin.namecoin? ? {names: @node.store.db[:names].count}.merge(info) : info
+  end
+
+  def add_monitor params, channels
+    @monitors << { params: params, channels: channels }
+    @monitors.size - 1
   end
 
+
   # Get the currently active configuration.
   #  bitcoin_node config
   def handle_config
@@ -166,49 +322,65 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   #  bitcoin_node connections
   def handle_connections
     @node.connections.sort{|x,y| y.uptime <=> x.uptime}.map{|c|
-      "#{c.host.rjust(15)}:#{c.port} [#{c.direction}, state: #{c.state}, " +
-      "version: #{c.version.version rescue '?'}, " +
-      "block: #{c.version.block rescue '?'}, " +
-      "uptime: #{format_uptime(c.uptime) rescue 0}, " +
-      "client: #{c.version.user_agent rescue '?'}]" }
+      {
+        type: c.direction, host: c.host, port: c.port, state: c.state,
+        uptime: c.uptime,
+        version: {
+          version: c.version.version,
+          services: c.version.services,
+          time: c.version.time,
+          nonce: c.version.nonce,
+          block: c.version.last_block,
+          client: (c.version.user_agent rescue '?'),
+          relay: c.version.relay,
+        }
+      }
+    }
   end
 
   # Connect to given peer(s).
-  #  bitcoin_node connect <ip>:<port>[,<ip>:<port>]
-  def handle_connect *args
-    args.each {|a| @node.connect_peer(*a.split(':')) }
-    {:state => "Connecting..."}
+  #  { method: "connect", params: {host: "localhost", port: 12345 }
+  def handle_connect params
+    @node.connect_peer(params[:host], params[:port])
+    { state: :connecting }
   end
 
   # Disconnect given peer(s).
-  #  bitcoin_node disconnect <ip>:<port>[,<ip>,<port>]
-  def handle_disconnect *args
-    args.each do |c|
-      host, port = *c.split(":")
-      conn = @node.connections.select{|c| c.host == host && c.port == port.to_i}.first
-      conn.close_connection  if conn
-    end
-    {:state => "Disconnected"}
+  #  { method: "disconnect", params: {host: "localhost", port: 12345 }
+  def handle_disconnect params
+    conn = @node.connections.find {|c| c.host == params[:host] && c.port == params[:port].to_i}
+    conn.close_connection  if conn
+    { state: :disconnected }
   end
 
   # Trigger the node to ask its peers for new blocks.
-  #  bitcoin_node getblocks
+  #  { method: "getblocks", params: {} }
   def handle_getblocks
-    @node.connections.sample.send_getblocks
-    {:state => "Sending getblocks..."}
+    conn = @node.connections.sample
+    if conn
+      conn.send_getblocks
+      { state: :sent, peer: { host: conn.host, port: conn.port } }
+    else
+      raise "No peer connected"
+    end
   end
 
   # Trigger the node to ask its for new peer addresses.
-  #  bitcoin_node getaddr
+  #  { method: "getaddr", params: {} }
   def handle_getaddr
-    @node.connections.sample.send_getaddr
-    {:state => "Sending getaddr..."}
+    conn = @node.connections.sample
+    if conn
+      conn.send_getaddr
+      { state: :sent, peer: { host: conn.host, port: conn.port } }
+    else
+      raise "No peer connected"
+    end
   end
 
   # Get known peer addresses (used by bin/bitcoin_dns_seed).
-  #  bitcoin_node addrs [count]
-  def handle_addrs count = 32
-    @node.addrs.weighted_sample(count.to_i) do |addr|
+  #  { method: "getaddr", params: { count: 32 } }
+  def handle_addrs params = { count: 32 }
+    @node.addrs.weighted_sample(params[:count].to_i) do |addr|
       Time.now.tv_sec + 7200 - addr.time
     end.map do |addr|
       [addr.ip, addr.port, Time.now.tv_sec - addr.time] rescue nil
@@ -216,10 +388,16 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   end
 
   # Trigger a rescan operation when used with a UtxoStore.
-  #  bitcoin_node rescan
+  #  { method: "rescan" }
   def handle_rescan
-    EM.defer { @node.store.rescan }
-    {:state => "Rescanning ..."}
+    EM.defer {
+      begin
+        @node.store.rescan
+      rescue
+        puts "rescan: #{$!}"
+      end
+      }
+    { state: :rescanning }
   end
 
   # Get Time Since Last Block.
@@ -236,9 +414,11 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   # After creating an unsigned transaction, one just needs to sign the sig_hashes
   # and send everything to #assemble_tx, to receive the complete transaction that
   # can be relayed to the network.
-  def handle_create_tx keys, recipients, fee = 0
+  def handle_create_tx params = {}
+    params[:fee] ||= 0
+    #keys, recipients, fee = 0
     keystore = Bitcoin::Wallet::SimpleKeyStore.new(file: StringIO.new("[]"))
-    keys.each do |k|
+    params[:keys].each do |k|
       begin
         key = Bitcoin::Key.from_base58(k)
         key = { addr: key.addr, key: key }
@@ -257,21 +437,25 @@ class Bitcoin::Network::CommandHandler < EM::Connection
       keystore.add_key(key)
     end
     wallet = Bitcoin::Wallet::Wallet.new(@node.store, keystore)
-    tx = wallet.new_tx(recipients.map {|r| [:address, r[0], r[1]]}, fee)
+
+    tx = wallet.new_tx(params[:recipients].map {|r| [:address, r[0], r[1]]}, params[:fee])
     return { error: "Error creating tx." }  unless tx
-    [ tx.to_payload.hth, tx.in.map {|i| [i.sig_hash.hth, i.sig_address] rescue nil } ]
+    { hash: tx.hash, hex: tx.to_payload.hth,
+      missing_sigs: tx.in.map {|i| [i.sig_hash.hth, i.sig_address] rescue nil } }
   rescue
     { error: "Error creating tx: #{$!.message}" }
+    p $!; puts *$@
   end
 
-  # Assemble an unsigned transaction from the +tx_hex+ and +sig_pubkeys+.
-  # The +tx_hex+ is the regular transaction structure, with empty input scripts
+  # Assemble an unsigned transaction from the +tx+ and +sig_pubkeys+ params.
+  # The +tx+ is the regular transaction structure, with empty input scripts
   # (as returned by #create_tx when called without privkeys).
   # +sig_pubkeys+ is an array of [signature, pubkey] pairs used to build the
   # input scripts.
-  def handle_assemble_tx tx_hex, sig_pubs
-    tx = Bitcoin::P::Tx.new(tx_hex.htb)
-    sig_pubs.each.with_index do |sig_pub, idx|
+  def handle_assemble_tx params = {}
+    # tx_hex, sig_pubs
+    tx = Bitcoin::P::Tx.new(params[:tx].htb)
+    params[:sig_pubs].each.with_index do |sig_pub, idx|
       sig, pub = *sig_pub.map(&:htb)
       script_sig = Bitcoin::Script.to_signature_pubkey_script(sig, pub)
       tx.in[idx].script_sig_length = script_sig.bytesize
@@ -279,51 +463,56 @@ class Bitcoin::Network::CommandHandler < EM::Connection
     end
     tx = Bitcoin::P::Tx.new(tx.to_payload)
     tx.validator(@node.store).validate(raise_errors: true)
-    tx.to_payload.hth
+    { hash: tx.hash, hex: tx.to_payload.hth }
   rescue
     { error: "Error assembling tx: #{$!.message}" }
+    p $!; puts *$@
   end
 
   # Relay given transaction (in hex).
   #  bitcoin_node relay_tx <tx in hex>
-  def handle_relay_tx hex, send = 3, wait = 3
+  def handle_relay_tx request, params = {}
+    params[:send] ||= 3
+    params[:wait] ||= 3
+    # request, hex, send = 3, wait = 3
     begin
-      tx = Bitcoin::P::Tx.new(hex.htb)
+      tx = Bitcoin::P::Tx.new(params[:hex].htb)
     rescue
-      return respond("relay_tx", { error: "Error decoding transaction." })
+      return respond(request, { error: "Error decoding transaction." })
     end
 
     validator = tx.validator(@node.store)
     unless validator.validate(rules: [:syntax])
-      return respond("relay_tx", { error: "Transaction syntax invalid.",
+      return respond(request, { error: "Transaction syntax invalid.",
                      details: validator.error })
     end
     unless validator.validate(rules: [:context])
-      return respond("relay_tx", { error: "Transaction context invalid.",
+      return respond(request, { error: "Transaction context invalid.",
                      details: validator.error })
     end
 
     #@node.store.store_tx(tx)
     @node.relay_tx[tx.hash] = tx
     @node.relay_propagation[tx.hash] = 0
-    @node.connections.select(&:connected?).sample(send).each {|c| c.send_inv(:tx, tx.hash) }
+    @node.connections.select(&:connected?).sample(params[:send]).each {|c| c.send_inv(:tx, tx.hash) }
 
-    EM.add_timer(wait) do
+    EM.add_timer(params[:wait]) do
       received = @node.relay_propagation[tx.hash]
-      total = @node.connections.select(&:connected?).size - send
+      total = @node.connections.select(&:connected?).size - params[:send]
       percent = 100.0 / total * received
-      respond("relay_tx", { success: true, hash: tx.hash, propagation: {
-                  received: received, sent: 1, percent: percent } })
+      respond(request, { success: true, hash: tx.hash, propagation: {
+            received: received, sent: 1, percent: percent } })
     end
   rescue
-    respond("relay_tx", { error: $!.message, backtrace: $@ })
+    respond(request, { error: $!.message, backtrace: $@ })
+    p $!; puts *$@
   end
 
   # Stop the bitcoin node.
   #  bitcoin_node stop
   def handle_stop
     Thread.start { sleep 0.1; @node.stop }
-    {:state => "Stopping..."}
+    { state: :stopping }
   end
 
   # List all available commands.
@@ -333,28 +522,28 @@ class Bitcoin::Network::CommandHandler < EM::Connection
   end
 
   # Validate and store given block (in hex) as if it was received by a peer.
-  #  bitcoin_node store_block <block in hex>
-  def handle_store_block hex
-    block = Bitcoin::P::Block.new(hex.htb)
+  #  { method: "store_block", params: { hex: <block data in hex> } }
+  def handle_store_block params
+    block = Bitcoin::P::Block.new(params[:hex].htb)
     @node.queue << [:block, block]
-    { queued: [ :block, block.hash ] }
+    { queued: block.hash }
   end
 
   # Store given transaction (in hex) as if it was received by a peer.
-  #  bitcoin_node store_tx <tx in hex>
-  def handle_store_tx hex
-    tx = Bitcoin::P::Tx.new(hex.htb)
+  #  { method: "store_tx", params: { hex: <tx data in hex> } }
+  def handle_store_tx params
+    tx = Bitcoin::P::Tx.new(params[:hex].htb)
     @node.queue << [:tx, tx]
-    { queued: [ :tx, tx.hash ] }
+    { queued: tx.hash }
   end
 
-  # format node uptime
-  def format_uptime t
-    mm, ss = t.divmod(60)            #=> [4515, 21]
-    hh, mm = mm.divmod(60)           #=> [75, 15]
-    dd, hh = hh.divmod(24)           #=> [3, 3]
-    "%02d:%02d:%02d:%02d" % [dd, hh, mm, ss]
-  end
+  # # format node uptime
+  # def format_uptime t
+  #   mm, ss = t.divmod(60)            #=> [4515, 21]
+  #   hh, mm = mm.divmod(60)           #=> [75, 15]
+  #   dd, hh = hh.divmod(24)           #=> [3, 3]
+  #   "%02d:%02d:%02d:%02d" % [dd, hh, mm, ss]
+  # end
 
   # disconnect notification clients when connection is closed
   def unbind
@@ -362,4 +551,20 @@ class Bitcoin::Network::CommandHandler < EM::Connection
     @node.command_connections.delete(self)
   end
 
+  private
+
+  def symbolize_keys(obj)
+    return obj  unless [Hash, Array].include?(obj.class)
+    return obj.map {|v| symbolize_keys(v) }  if obj.is_a?(Array)
+    obj.inject({}){|result, (key, value)|
+      new_key = key.is_a?(String) ? key.to_sym : key
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  when Array then value.map {|v| symbolize_keys(v) }
+                  else value; end
+      result[new_key] = new_value
+      result
+    }
+  end
+
 end