bitcoin-ruby 0.0.1

data/lib/bitcoin/storage/sequel_store/sequel_migrations.rb

@@ -0,0 +1,84 @@
+module Bitcoin::Storage::Backends::SequelMigrations
+
+  def migrate
+    unless @db.tables.include?(:blk)
+      @db.create_table :blk do
+        primary_key :id
+        column :hash, :bytea, :null => false, :unique => true, :index => true
+        column :depth, :int, :null => false, :index => true
+        column :version, :bigint, :null => false
+        column :prev_hash, :bytea, :null => false, :index => true
+        column :mrkl_root, :bytea, :null => false
+        column :time, :bigint, :null => false
+        column :bits, :bigint, :null => false
+        column :nonce, :bigint, :null => false
+        column :blk_size, :int, :null => false
+        column :chain, :int, :null => false
+      end
+    end
+
+    unless @db.tables.include?(:tx)
+      @db.create_table :tx do
+        primary_key :id
+        column :hash, :bytea, :null => false, :unique => true, :index => true
+        column :version, :bigint, :null => false
+        column :lock_time, :bigint, :null => false
+        column :coinbase, :bool, :null => false
+        column :tx_size, :int, :null => false
+      end
+    end
+
+    unless @db.tables.include?(:blk_tx)
+      @db.create_table :blk_tx do
+        column :blk_id, :int, :null => false, :index => true
+        column :tx_id, :int, :null => false, :index => true
+        column :idx, :int, :null => false
+      end
+    end
+
+    unless @db.tables.include?(:txin)
+      @db.create_table :txin do
+        primary_key :id
+        column :tx_id, :int, :null => false, :index => true
+        column :tx_idx, :int, :null => false
+        column :script_sig, :bytea, :null => false
+        column :prev_out, :bytea, :null => false, :index => true
+        column :prev_out_index, :bigint, :null => false
+        column :sequence, :bigint, :null => false
+      end
+    end
+
+    unless @db.tables.include?(:txout)
+      @db.create_table :txout do
+        primary_key :id
+        column :tx_id, :int, :null => false, :index => true
+        column :tx_idx, :int, :null => false
+        column :pk_script, :bytea, :null => false, :index => true
+        column :value, :bigint
+        column :type, :int, :null => false, :index => true
+      end
+    end
+
+    unless @db.tables.include?(:addr)
+      @db.create_table :addr do
+        primary_key :id
+        column :hash160, String, :null => false, :index => true
+      end
+    end
+
+    unless @db.tables.include?(:addr_txout)
+      @db.create_table :addr_txout do
+        column :addr_id, :int, :null => false, :index => true
+        column :txout_id, :int, :null => false, :index => true
+      end
+    end
+
+    unless @db.views.include?(:unconfirmed)
+      @db.create_view(:unconfirmed,
+        "SELECT * FROM tx WHERE NOT EXISTS " +
+        "(SELECT 1 FROM blk_tx WHERE blk_tx.tx_id = tx.id)" +
+        "ORDER BY tx.id DESC")
+    end
+  end
+
+end

data/lib/bitcoin/storage/storage.rb

@@ -0,0 +1,243 @@
+# The storage implementation supports different backends, which inherit from
+# Storage::StoreBase and implement the same interface.
+# Each backend returns Storage::Models objects to easily access helper methods and metadata.
+#
+# The most stable backend is Backends::SequelStore, which uses sequel and can use all
+# kinds of SQL database backends.
+module Bitcoin::Storage
+
+  autoload :Models, 'bitcoin/storage/models'
+
+  @log = Bitcoin::Logger.create(:storage)
+  def self.log; @log; end
+
+  BACKENDS = [:dummy, :sequel]
+  BACKENDS.each do |name|
+    module_eval <<-EOS
+      def self.#{name} config, *args
+        Backends.const_get("#{name.capitalize}Store").new(config, *args)
+      end
+    EOS
+  end
+
+  module Backends
+
+    BACKENDS.each {|b| autoload("#{b.to_s.capitalize}Store", "bitcoin/storage/#{b}") }
+
+    # Base class for storage backends.
+    # Every backend must overwrite the "Not implemented" methods
+    # and provide an implementation specific to the storage.
+    # Also, before returning the objects, they should be wrapped
+    # inside the appropriate Bitcoin::Storage::Models class.
+    class StoreBase
+
+      # main branch (longest valid chain)
+      MAIN = 0
+
+      # side branch (connected, valid, but too short)
+      SIDE = 1
+
+      # orphan branch (not connected to main branch / genesis block)
+      ORPHAN = 2
+
+      attr_reader :log
+
+      def initialize(config = {}, getblocks_callback = nil)
+        @config = config
+        @getblocks_callback = getblocks_callback
+        @log    = config[:log] || Bitcoin::Storage.log
+      end
+
+      # reset the store; delete all data
+      def reset
+        raise "Not implemented"
+      end
+
+      # store given block +blk+.
+      # determine branch/chain and dept of block. trigger reorg if side branch becomes longer
+      # than current main chain and connect orpans.
+      def store_block blk
+        log.debug { "new block #{blk.hash}" }
+
+        existing = get_block(blk.hash)
+        return [existing.depth, existing.chain]  if existing && existing.chain == MAIN
+
+        prev_block = get_block(hth(blk.prev_block.reverse))
+        if !prev_block || prev_block.chain == ORPHAN
+          if blk.hash == Bitcoin.network[:genesis_hash]
+            log.debug { "=> genesis (0)" }
+            return persist_block(blk, MAIN, 0)
+          else
+            depth = prev_block ? prev_block.depth + 1 : 0
+            log.debug { "=> orphan (#{depth})" }
+            return persist_block(blk, ORPHAN, depth)
+          end
+        end
+        depth = prev_block.depth + 1
+        if prev_block.chain == MAIN
+          next_block = prev_block.get_next_block
+          if next_block && next_block.chain == MAIN
+            log.debug { "=> side (#{depth})" }
+            return persist_block(blk, SIDE, depth)
+          else
+            log.debug { "=> main (#{depth})" }
+            return persist_block(blk, MAIN, depth)
+          end
+        else
+          head = get_head
+          if prev_block.depth + 1 <= head.depth
+            log.debug { "=> side (#{depth})" }
+            return persist_block(blk, SIDE, depth)
+          else
+            log.debug { "=> reorg" }
+            new_main, new_side = [], []
+            fork_block = prev_block
+            while fork_block.chain != MAIN
+              new_main << fork_block.hash
+              fork_block = fork_block.get_prev_block
+            end
+            b = fork_block
+            while b = b.get_next_block
+              new_side << b.hash
+            end
+            log.debug { "new main: #{new_main.inspect}" }
+            log.debug { "new side: #{new_side.inspect}" }
+            update_blocks([[new_main, {:chain => MAIN}], [new_side, {:chain => SIDE}]])
+            return persist_block(blk, MAIN, depth)
+          end
+        end
+      end
+
+      # persist given block +blk+ to storage.
+      def persist_block(blk)
+        raise "Not implemented"
+      end
+
+      # update +attrs+ for block with given +hash+.
+      # typically used to update chain.
+      def update_block(hash, attrs)
+        raise "Not implemented"
+      end
+
+      # store given +tx+
+      def store_tx(tx)
+        raise "Not implemented"
+      end
+
+      # check if block with given +blk_hash+ is already stored
+      def has_block(blk_hash)
+        raise "Not implemented"
+      end
+
+      # check if tx with given +tx_hash+ is already stored
+      def has_tx(tx_hash)
+        raise "Not implemented"
+      end
+
+      # get the hash of the leading block
+      def get_head
+        raise "Not implemented"
+      end
+
+      # return depth of the head block
+      def get_depth
+        raise "Not implemented"
+      end
+
+      # compute blockchain locator
+      def get_locator pointer = get_head
+        return [Bitcoin::hth("\x00"*32)]  if get_depth == -1
+        locator = []
+        step = 1
+        while pointer && pointer.hash != Bitcoin::network[:genesis_hash]
+          locator << pointer.hash
+          depth = pointer.depth - step
+          break unless depth > 0
+          prev_block = get_block_by_depth(depth) # TODO
+          break unless prev_block
+          pointer = prev_block
+          step *= 2  if locator.size > 10
+        end
+        locator << Bitcoin::network[:genesis_hash]
+        locator
+      end
+
+      # get block with given +blk_hash+
+      def get_block(blk_hash)
+        raise "Not implemented"
+      end
+
+      # get block with given +depth+ from main chain
+      def get_block_by_depth(depth)
+        raise "Not implemented"
+      end
+
+      # get block with given +prev_hash+
+      def get_block_by_prev_hash(prev_hash)
+        raise "Not implemented"
+      end
+
+      # get block that includes tx with given +tx_hash+
+      def get_block_by_tx(tx_hash)
+        raise "Not implemented"
+      end
+
+      # get block by given +block_id+
+      def get_block_by_id(block_id)
+        raise "Not implemented"
+      end
+
+      # get corresponding txin for the txout in
+      # transaction +tx_hash+ with index +txout_idx+
+      def get_txin_for_txout(tx_hash, txout_idx)
+        raise "Not implemented"
+      end
+
+      # get tx with given +tx_hash+
+      def get_tx(tx_hash)
+        raise "Not implemented"
+      end
+
+      # get tx with given +tx_id+
+      def get_tx_by_id(tx_id)
+        raise "Not implemented"
+      end
+
+      # collect all txouts containing the
+      # given +script+
+      def get_txouts_for_pk_script(script)
+        raise "Not implemented"
+      end
+
+      # collect all txouts containing a
+      # standard tx to given +address+
+      def get_txouts_for_address(address, unconfirmed = false)
+        hash160 = Bitcoin.hash160_from_address(address)
+        get_txouts_for_hash160(hash160, unconfirmed)
+      end
+
+      # get balance for given +hash160+
+      def get_balance(hash160, unconfirmed = false)
+        txouts = get_txouts_for_hash160(hash160, unconfirmed)
+        unspent = txouts.select {|o| o.get_next_in.nil?}
+        unspent.map(&:value).inject {|a,b| a+=b; a} || 0
+      rescue
+        nil
+      end
+
+      # import satoshi bitcoind blk0001.dat blockchain file
+      def import filename, max_depth = nil
+        File.open(filename) do |file|
+          until file.eof?
+            magic = file.read(4)
+            raise "invalid network magic"  unless Bitcoin.network[:magic_head] == magic
+            size = file.read(4).unpack("L")[0]
+            blk = Bitcoin::P::Block.new(file.read(size))
+            depth, chain = store_block(blk)
+            break  if max_depth && depth >= max_depth
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/version.rb

@@ -0,0 +1,3 @@
+module Bitcoin
+  VERSION = "0.0.1"
+end

data/lib/bitcoin/wallet/coinselector.rb

@@ -0,0 +1,30 @@
+module Bitcoin::Wallet
+
+  # select unspent txouts to be used by the Wallet when creating a new transaction
+  class SimpleCoinSelector
+
+    # create coinselector with given +txouts+
+    def initialize txouts
+      @txouts = txouts
+    end
+
+    # select txouts needed to spend +value+ btc (base units)
+    def select(value)
+      txouts = []
+      @txouts.each do |txout|
+        begin
+          next  if txout.get_next_in
+          next  unless txout.get_address
+          next  unless txout.get_tx.get_block
+          txouts << txout
+          return txouts  if txouts.map(&:value).inject(:+) >= value
+        rescue
+          p $!
+        end
+      end
+      nil
+    end
+
+  end
+
+end

data/lib/bitcoin/wallet/keygenerator.rb

@@ -0,0 +1,75 @@
+module Bitcoin::Wallet
+
+  # Deterministic key generator as described in
+  # https://bitcointalk.org/index.php?topic=11665.0.
+  # 
+  # Takes a seed and generates an arbitrary amount of keys.
+  # Protects against brute-force attacks by requiring the
+  # key hash to fit a difficulty target, much like the block chain.
+  class KeyGenerator
+
+    # difficulty target (0x0000FFFF00000000000000000000000000000000000000000000000000000000)
+    DEFAULT_TARGET = 0x0000FFFF00000000000000000000000000000000000000000000000000000000
+
+    attr_accessor :seed, :nonce, :target
+
+    # Initialize key generator with optional +seed+ and +nonce+ and +target+.
+    # [seed] the seed data for the keygenerator (default: random)
+    # [nonce] the nonce required to satisfy the target (default: computed)
+    # [target] custom difficulty target (default: DEFAULT_TARGET)
+    #
+    # Example:
+    #  g = KeyGenerator.new # random seed, computed nonce, default target
+    #  KeyGenerator.new(g.seed)
+    #  KeyGenerator.new(g.seed, g.nonce)
+    #  g.get_key(0) #=> <Bitcoin::Key>
+    #
+    # Note: When initializing without seed, you should obviously save the
+    # seed once it is generated. Saving the nonce is optional; it only saves time.
+    def initialize seed = nil, nonce = nil, target = nil
+      @seed = seed || OpenSSL::Random.random_bytes(64)
+      @target = target || DEFAULT_TARGET
+      @nonce = check_nonce(nonce)
+    end
+
+    # get key number +n+ from chain
+    def get_key(n = 0)
+      key = get_hash(@seed, @nonce)
+      (n + 1).times { key = sha256(key) }
+      key
+      Bitcoin::Key.new(key.unpack("H*")[0])
+    end
+
+    # find a nonce that leads to the privkey satisfying the target
+    def find_nonce
+      n = 0
+      n += 1  while !check_target(get_hash(@seed, n))
+      n
+    end
+
+    protected
+
+    # check the nonce; compute if missing, raise if invalid.
+    def check_nonce(nonce)
+      return find_nonce  unless nonce
+      # check_target(get_hash(@seed, nonce)) ? nonce : find_nonce
+      raise ArgumentError, "Nonce invalid."  unless check_target(get_hash(@seed, nonce))
+      nonce
+    end
+
+    # check if given +hash+ satisfies the difficulty target
+    def check_target(hash)
+      hash.unpack("H*")[0].to_i(16) < @target
+    end
+
+    # compute a single SHA256 hash for +d+.
+    def sha256(d); Digest::SHA256.digest(d); end
+
+    # get the hash corresponding to +seed+ and +n+.
+    def get_hash(seed, n)
+      sha256( sha256(seed) + sha256(n.to_s) )
+    end
+
+  end
+
+end

data/lib/bitcoin/wallet/keystore.rb

@@ -0,0 +1,203 @@
+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]}]
+      @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)
+      @keys << {:label => label, :addr => key.addr, :key => key}
+      save_keys
+      key.addr
+    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
+      elsif File.exists?(@config[:file])
+        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