bitcoin-ruby 0.0.6 → 0.0.7

data/lib/bitcoin/wallet/keystore.rb

@@ -1,207 +0,0 @@
-# encoding: ascii-8bit
-
-require 'json'
-require 'stringio'
-
-module Bitcoin::Wallet
-
-  # JSON-file-based keystore used by the Wallet.
-  class SimpleKeyStore
-
-    attr_reader :config
-
-    # Initialize keystore.
-    # [config] Hash of settings ({:file => "/foo/bar.json"})
-    def initialize config
-      @config = Hash[config.map{|k,v|[k.to_sym,v]}]
-      @config[:file].sub!("~", ENV["HOME"])  if @config[:file].is_a?(String)
-      @keys = []
-      load_keys
-    end
-
-    # List all stored keys.
-    def keys(need = nil)
-      @keys.select do |key|
-        next !(key[:hidden] && key[:hidden] == "true")  unless need
-        case need
-        when :label
-          !!key[:label]
-        when :pub
-          !!key[:key].pub
-        when :priv
-          !!key[:key].priv
-        when :hidden
-          !!key[:hidden]
-        when :mine
-          !!key[:mine]
-        end
-      end
-    end
-
-    # Get key for given +label+, +addr+ or +pubkey+.
-    def key(name)
-      find_key(name)
-    end
-
-    # Generate and store a new key.
-    def new_key(label = nil)
-      raise ArgumentError, "Label #{label} already in use"  if label && find_key(label)
-      key = Bitcoin::Key.generate
-      @keys << {:label => label, :addr => key.addr, :key => key}
-      save_keys
-      key
-    end
-
-    # Add a key which can consist only of +addr+ and +label+.
-    def add_key key
-      label = key[:label]
-      raise ArgumentError, "Label #{label} already in use"  if label && find_key(label)
-      addr = key[:addr]
-      raise ArgumentError, "Address #{addr} is invalid"  if addr && !Bitcoin.valid_address?(addr)
-      @keys << key
-      save_keys
-      key
-    end
-
-    def label_key(name, label)
-      find_key(name) do |key|
-        key[:label] = label
-      end
-      save_keys
-    end
-
-    def flag_key(name, flag, value)
-      find_key(name, true) do |key|
-        key[flag.to_sym] = value
-      end
-      save_keys
-    end
-
-    # Delete key for given +label+, +addr+ or +pubkey+.
-    def delete(name)
-      key = find_key(name)
-      @keys.delete(key)
-      save_keys
-    end
-
-    # Export key for given +name+ to base58 format.
-    # (See Bitcoin::Key#to_base58)
-    def export(name)
-      find_key(name)[:key].to_base58 rescue nil
-    end
-
-    # Import key from given +base58+ string.
-    # (See Bitcoin::Key.from_base58)
-    def import(base58, label = nil)
-      raise ArgumentError, "Label #{label} already in use"  if label && find_key(label)
-      key = Bitcoin::Key.from_base58(base58)
-      raise ArgumentError, "Address #{key.addr} already in use"  if label && find_key(key.addr)
-      @keys << {:label => label, :addr => key.addr, :key => key}
-      save_keys
-      key
-    end
-
-    # Load keys from file.
-    # If file is empty this will generate a new key
-    # and store it, creating the file.
-    def load_keys
-      loader = proc{|keys|
-        keys.map!{|k| Hash[k.map{|k,v| [k.to_sym, v] }]}
-        keys.map do |key|
-          key[:key] = Bitcoin::Key.new(key[:priv], key[:pub])
-          key[:priv], key[:pub] = nil
-          @keys << key
-        end
-      }
-      if @config[:file].is_a?(StringIO)
-        json = JSON.load(@config[:file].read)
-        loader.call(json)
-      elsif File.exist?(@config[:file])
-        json = JSON.load(File.read(@config[:file]))
-        loader.call(json)
-      else
-        new_key; save_keys
-      end
-    end
-
-    # Save keys to file.
-    def save_keys
-      dumper = proc{|file|
-        keys = @keys.map do |key|
-          key = key.dup
-          if key[:key]
-            key[:priv] = key[:key].priv
-            key[:pub] = key[:key].pub
-            key.delete(:key)
-          end
-          key
-        end
-        file.write(JSON.pretty_generate(keys))
-      }
-
-      if @config[:file].is_a?(StringIO)
-        @config[:file].reopen
-        dumper.call(@config[:file])
-        @config[:file].rewind
-      else
-        File.open(@config[:file], 'w'){|file| dumper.call(file) }
-      end
-    end
-
-    private
-
-    def find_key(name, hidden = false)
-      key = if Bitcoin.valid_address?(name)
-              @keys.find{|k| k[:addr] == name }
-            elsif name.size == 130
-              @keys.find{|k| k[:key].pub == name }
-            else
-              @keys.find{|k| k[:label] == name }
-            end
-      return nil  if !key || (!hidden && key[:hidden] == "true")
-      block_given? ? yield(key) : key
-    end
-
-  end
-
-  # Deterministic keystore.
-  class DeterministicKeyStore
-
-    attr_reader :generator
-
-    # Initialize keystore.
-    # [config] Hash of settings ({:keys => 1, :seed => ..., :nonce => ...})
-    def initialize config
-      @config = Hash[config.map{|k,v|[k.to_sym,v]}]
-      @config[:keys] = (@config[:keys] || 1).to_i
-      @generator = Bitcoin::Wallet::KeyGenerator.new(@config[:seed], @config[:nonce])
-    end
-
-    # List all keys upto configured limit.
-    def keys
-      1.upto(@config[:keys].to_i).map {|i| @generator.get_key(i) }
-    end
-
-    # Get key for given +addr+.
-    def key(addr)
-      1.upto(@config[:keys].to_i).map do |i|
-        key = @generator.get_key(i)
-        return key  if key.addr == addr
-      end
-    end
-
-    # Get new key (actually just increase the key limit).
-    def new_key
-      @config[:keys] += 1
-      @generator.get_key(@config[:keys])
-    end
-
-    # Export key for given +addr+ to base58.
-    # (See Bitcoin::Key.to_base58)
-    def export(addr)
-      key(addr).to_base58 rescue nil
-    end
-
-  end
-
-end

data/lib/bitcoin/wallet/txdp.rb

@@ -1,118 +0,0 @@
-# encoding: ascii-8bit
-
-class Bitcoin::Wallet::TxDP
-
-  attr_accessor :id, :tx, :inputs
-  def initialize tx = []
-    @id = Bitcoin.int_to_base58(rand(1e14))
-    @tx = tx
-    @inputs = []
-    return  unless tx.any?
-    @tx[0].in.each_with_index do |input, i|
-      prev_out_hash = input.prev_out.reverse_hth
-      prev_tx = @tx[1..-1].find {|tx| tx.hash == prev_out_hash}
-      raise "prev tx #{prev_out_hash} not found"  unless prev_tx
-      prev_out = prev_tx.out[input.prev_out_index]
-      raise "prev out ##{input.prev_out_index} not found in tx #{@tx.hash}"  unless prev_out
-      out_script = Bitcoin::Script.new(prev_out.pk_script)
-      out_script.get_addresses.each do |addr|
-        add_sig(i, prev_out.value, addr, input.script_sig)
-      end
-    end
-  end
-
-  def add_sig(in_idx, value, addr, sig)
-    sig = sig ? [[addr, sig.unpack("H*")[0]]] : []
-    @inputs[in_idx] = [value, sig]
-  end
-
-  def sign_inputs
-    @inputs.each_with_index do |txin, i|
-      input = @tx[0].in[i]
-      prev_out_hash = input.prev_out.reverse_hth
-      prev_tx = @tx[1..-1].find {|tx| tx.hash == prev_out_hash}
-      raise "prev tx #{prev_out_hash} not found"  unless prev_tx
-      prev_out = prev_tx.out[input.prev_out_index]
-      raise "prev out ##{input.prev_out_index} not found in tx #{@tx.hash}"  unless prev_out
-      out_script = Bitcoin::Script.new(prev_out.pk_script)
-      out_script.get_addresses.each do |addr|
-        sig = yield(@tx[0], prev_tx, i, addr)
-        if sig
-          @inputs[i][1] ||= []
-          @inputs[i][1] << [addr, sig]
-          break
-        end
-      end
-    end
-  end
-
-  def serialize
-    lines = []
-    lines << "-----BEGIN-TRANSACTION-#{@id}".ljust(80, '-')
-    size = [@tx.first.to_payload.bytesize].pack("C").ljust(2, "\x00").reverse_hth
-    lines << "_TXDIST_#{Bitcoin.network[:magic_head].unpack("H*")[0]}_#{@id}_#{size}"
-    tx = @tx.map(&:to_payload).join.unpack("H*")[0]
-    tx_str = ""; tx.split('').each_with_index{|c,i| tx_str << (i % 80 == 0 ? "\n#{c}" : c)}
-    lines << tx_str.strip
-    @inputs.each_with_index do |input, idx|
-      lines << "_TXINPUT_#{idx.to_s.rjust(2, '0')}_#{"%.8f" % (input[0].to_f / 1e8)}"
-      next  unless input[1]
-      input[1].each do |sig|
-        size = [sig[1]].pack("H*").bytesize
-        size = [size].pack("C").ljust(2, "\x00").reverse_hth
-        lines << "_SIG_#{sig[0]}_#{idx.to_s.rjust(2, '0')}_#{size}"
-        sig_str = ""; sig[1].split('').each_with_index{|c,i| sig_str << (i % 80 == 0 ? "\n#{c}" : c)}
-        lines << sig_str.strip
-      end
-    end
-    lines << "-------END-TRANSACTION-#{@id}".ljust(80, '-')
-    lines.join("\n")
-  end
-
-  def parse str
-    str.match(/-+BEGIN-TRANSACTION-(.*?)-+$(.*?)END-TRANSACTION-#{$1}/m) do |m|
-      _, id, content = *m
-      txdist, *inputs = content.split(/_TXINPUT_/)
-      @id = id
-      @txdist = parse_txdist(txdist)
-      inputs.each {|input| parse_input(input) }
-    end
-    self
-  end
-
-  def parse_txdist txdist
-    _, magic, txdp_id, size, serialized_tx = *txdist.match(/_TXDIST_(.*?)_(.*?)_(.*?)$(.*)/m)
-    raise "Wrong network magic"  unless [magic].pack("H*") == Bitcoin.network[:magic_head]
-    tx = Bitcoin::P::Tx.new(nil)
-    rest = [serialized_tx.gsub!("\n", '')].pack("H*")
-    while rest = tx.parse_data(rest)
-      @tx << tx
-      break  if rest == true
-      tx = Bitcoin::P::Tx.new(nil)
-    end
-  end
-
-  def parse_input input
-    m = input.match(/(\d+)_(\d+\.\d+)\n(.*)/m)
-    _, idx, value, sigs = *m
-    value = (value.sub('.','').to_i)
-    sigs = parse_sigs(sigs)
-    @inputs[idx.to_i] = [value, sigs]
-  end
-
-  def parse_sigs sigs
-    return nil  unless sigs["_SIG_"]
-    sigs = sigs.split("_SIG_").map do |s|
-      if s == ""
-        nil
-      else
-        m = s.match(/(.*?)_(\d+)_(.*?)\n(.*)/m)
-        [$1, $4.gsub("\n", '').gsub('-', '')]
-      end
-    end.compact
-  end
-
-  def self.parse str
-    new.parse str
-  end
-end

data/lib/bitcoin/wallet/wallet.rb

@@ -1,281 +0,0 @@
-# encoding: ascii-8bit
-
-Bitcoin.require_dependency :eventmachine, exit: false
-
-# The wallet implementation consists of several concepts:
-# Wallet::             the high-level API used to manage a wallet
-# SimpleKeyStore::     key store to manage keys/addresses/labels
-# SimpleCoinSelector:: coin selector to find unspent outputs to use when creating tx
-module Bitcoin::Wallet
-
-  # A wallet manages a set of keys (through a +keystore+), can
-  # list transactions/balances for those keys (using a Storage backend for
-  # blockchain data).
-  # It can also create transactions with various kinds of outputs and
-  # connect with a CommandClient to relay those transactions through a node.
-  #
-  # TODO: new tx notification, keygenerators, keystore cleanup
-  class Wallet
-
-    include Bitcoin
-    include Builder
-
-    # the keystore (SimpleKeyStore) managing keys/addresses/labels
-    attr_reader :keystore
-
-    # the Storage which holds the blockchain
-    attr_reader :storage
-
-    # open wallet with given +storage+ Storage backend, +keystore+ SimpleKeyStore
-    # and +selector+ SimpleCoinSelector
-    def initialize storage, keystore, selector = SimpleCoinSelector
-      @storage = storage
-      @keystore = keystore
-      @selector = selector
-      @callbacks = {}
-
-      @keystore.keys.each {|key| @storage.add_watched_address(key[:addr]) }
-      # connect_node  if defined?(EM)
-
-    end
-
-    def connect_node
-      return  unless EM.reactor_running?
-      host, port = "127.0.0.1", 9999
-      @node = Network::CommandClient.connect(host, port, self, @storage) do
-        on_connected { request :monitor, "block", "tx" }
-        on_block do |block, depth|
-          EM.defer do
-            block['tx'].each do |tx|
-              relevant, tx = @args[0].check_tx(tx['hash'])
-              @args[0].callback(:tx, :confirmed, tx)  if relevant
-            end
-          end
-        end
-
-        on_tx do |response|
-          EM.defer do
-            relevant, tx = @args[0].check_tx(response['hash'])
-            @args[0].callback(:tx, relevant, tx)  if relevant
-          end
-        end
-      end
-    end
-
-    def check_tx tx_hash
-      relevant = false
-      addrs = addrs
-      tx = @storage.get_tx(tx_hash)
-      unless tx
-        log.warn { "Received tx #{response['hash']} but not found in storage" }
-        binding.pry
-        return false
-      end
-      addrs = @keystore.keys.map {|k| k[:addr] }
-      tx.out.each do |txout|
-        return :incoming, tx  if (txout.get_addresses & addrs).any?
-      end
-      tx.in.each do |txin|
-        next unless  prev_out = txin.get_prev_out
-        return :outgoing, tx  if (prev_out.get_addresses & addrs).any?
-      end
-      return false
-    end
-
-    def log
-      return @log  if @log
-      @log = Logger.create("wallet")
-      @log.level = :debug
-      @log
-    end
-
-    # call the callback specified by +name+ passing in +args+
-    def callback name, *args
-      cb = @callbacks[name.to_sym]
-      return  unless cb
-      log.debug { "callback: #{name}" }
-      cb.call(*args)
-    end
-
-    # register callback methods
-    def method_missing(name, *args, &block)
-      if name =~ /^on_/
-        @callbacks[name.to_s.split("on_")[1].to_sym] = block
-        log.debug { "callback #{name} registered" }
-      else
-        super(name, *args)
-      end
-    end
-
-    # get all Storage::Models::TxOut concerning any address from this wallet
-    def get_txouts(unconfirmed = false)
-      txouts = @keystore.keys.map {|k|
-        @storage.get_txouts_for_address(k[:addr])}.flatten.uniq
-      (unconfirmed || @storage.class.name =~ /Utxo/) ? txouts : txouts.select {|o| !!o.get_tx.get_block}
-    end
-
-    # get total balance for all addresses in this wallet
-    def get_balance(unconfirmed = false)
-      values = get_txouts(unconfirmed).select{|o| !o.get_next_in}.map(&:value)
-      ([0] + values).inject(:+)
-    end
-
-    # list all addresses in this wallet
-    def addrs
-      @keystore.keys.map{|k| k[:addr]}
-    end
-
-    # add +key+ to wallet
-    def add_key key
-      @keystore.add_key(key)
-      @storage.add_watched_address(key[:addr])
-    end
-
-    # set label for key +old+ to +new+
-    def label old, new
-      @keystore.label_key(old, new)
-    end
-
-    # set +flag+ for key +name+ to +value+
-    def flag name, flag, value
-      @keystore.flag_key(name, flag, value)
-    end
-
-    # list all keys along with their balances
-    def list
-      @keystore.keys.map do |key|
-        [key, @storage.get_balance(Bitcoin.hash160_from_address(key[:addr]))]
-      end
-    end
-
-    # create new key and return its address
-    def get_new_addr
-      key = @keystore.new_key
-      @storage.add_watched_address(key.addr)
-      key.addr
-    end
-
-    def import_key base58, label = nil
-      key = @keystore.import(base58, label)
-      @storage.add_watched_address(key.addr)
-      key.addr
-    end
-
-    def rescan
-      @storage.rescan
-    end
-
-    # get SimpleCoinSelector with txouts for this wallet
-    def get_selector
-      @selector.new(get_txouts)
-    end
-
-    # create a transaction with given +outputs+, +fee+ and +change_policy+.
-    #
-    # outputs are of the form
-    #  [<type>, <recipients>, <value>]
-    # examples:
-    #  [:address, <addr>, <value>]
-    #  [:multisig, 2, 3, <addr>, <addr>, <addr>, <value>]
-    #
-    # inputs are selected automatically by the SimpleCoinSelector.
-    #
-    # change_policy controls where the change_output is spent to.
-    # see #get_change_addr
-    def new_tx outputs, fee = 0, change_policy = :back
-      output_value = outputs.map{|o| o[-1] }.inject(:+)
-
-      prev_outs = get_selector.select(output_value)
-      raise "Insufficient funds."  if !prev_outs
-      if Bitcoin.namecoin?
-        prev_out = nil
-        outputs.each do |out|
-          if out[0] == :name_firstupdate
-            name_hash = Bitcoin.hash160(out[2] + out[1].hth)
-            break  if prev_out = get_txouts.find {|o|
-              o.type == :name_new && o.script.get_namecoin_hash == name_hash }
-          elsif out[0] == :name_update
-            break  if prev_out = storage.name_show(out[1]).get_txout rescue nil
-          end
-        end
-        if outputs.find{|o| [:name_firstupdate, :name_update].include?(o[0]) }
-          raise "previous name tx not found in wallet."  unless prev_out
-          prev_outs += [prev_out]
-        end
-      end
-
-      input_value = prev_outs.map(&:value).inject(:+)
-      raise "Insufficient funds."  unless input_value >= (output_value + fee)
-
-      tx = build_tx do |t|
-        t.version 0x7100  if Bitcoin.namecoin? && outputs.find {|o| o[0].to_s =~ /^name_/ }
-        outputs.each do |type, *addrs, value|
-          t.output do |o|
-            o.value value
-            o.script do |s|
-              s.type type
-              s.recipient *addrs
-            end
-          end
-        end
-
-        change_value = input_value - output_value - fee
-        if change_value > 0
-          change_addr = get_change_addr(change_policy, prev_outs.sample.get_address)
-          t.output do |o|
-            o.value change_value
-            o.script do |s|
-              s.type :address
-              s.recipient change_addr
-            end
-          end
-        end
-
-        prev_outs.each_with_index do |prev_out, idx|
-          t.input do |i|
-            prev_tx = prev_out.get_tx
-            i.prev_out prev_tx
-            i.prev_out_index prev_tx.out.index(prev_out)
-            pk_script = Script.new(prev_out.pk_script)
-            if pk_script.is_pubkey? || pk_script.is_hash160? || pk_script.is_namecoin?
-              i.signature_key @keystore.key(prev_out.get_address)[:key]
-            elsif pk_script.is_multisig?
-              raise "multisig not implemented"
-            end
-          end
-        end
-      end
-
-      # TODO: spend multisig outputs again
-      # TODO: verify signatures
-      raise "Payload Error"  unless P::Tx.new(tx.to_payload).to_payload == tx.to_payload
-
-      tx
-    end
-
-    protected
-
-    # get address to send change output to.
-    # +policy+ controls which address is chosen:
-    # first:: send to the first key in the wallets keystore
-    # random:: send to a random key from the wallets keystore
-    # new:: send to a new key generated in the wallets keystore
-    # back:: send to the address given as +in_addr+
-    def get_change_addr(policy, in_addr)
-      case policy
-      when :first
-        @keystore.keys[0].addr
-      when :random
-        @keystore.keys.sample.addr
-      when :new
-        @keystore.new_key.addr
-      when :back
-        in_addr
-      else
-        policy
-      end
-    end
-
-  end
-
-end