bitcoin 0.1.0 → 0.1.2

data/lib/bitcoin/console/stream_bundle.rb

@@ -0,0 +1,21 @@
+module Bitcoin
+  module Console
+    # StreamBundles are objects that encapsulate the standard unix pipes
+    # (STDIN, STDOUT, STDERR)
+    class StreamBundle
+      def initialize(input, output, error)
+        @input  = input
+        @output = output
+        @error  = error
+      end
+
+      def puts_output(stringlike)
+        @output.puts(stringlike)
+      end
+
+      def puts_error(stringlike)
+        @error.puts(stringlike)
+      end
+    end
+  end
+end

data/lib/bitcoin/data_access/satoshi/bdb_satoshi_wallet_repository.rb

@@ -0,0 +1,155 @@
+require 'sbdb'
+require 'bdb/base'
+
+module Bitcoin
+  module DataAccess
+    module Satoshi
+      # Raw Berkeley DB access (thin wrapper around SBDB) for wallet data
+      # WARNING! This code is in really bad shape. It works, but is verbose
+      # and full of duplication. It needs massive refactoring.
+      class BDBSatoshiWalletRepository
+        def initialize(db_filename, options)
+          @db_filename  = db_filename
+          @db_dirname   = options[:db_dirname]
+        end
+
+        def bdb_bytes_to_utf8_string(bytes)
+          bytes.pack("C*").force_encoding("UTF-8")
+        end
+
+        def get_value_immediate_uint32le(key_name)
+          with_bdb_db do |db|
+            db[make_key(key_name)].unpack("V").first
+          end
+        end
+
+        def set_value_immediate_uint32le(key_name, value_data)
+          with_bdb_db do |db|
+            db[make_key(key_name)] = [ value_data ].pack("V")
+          end
+        end
+
+        def get_key_and_value_data_string_utf8(key_name)
+          with_bdb_db do |db|
+            db_records(db).select { |record|
+              record.first == key_name
+            }.map { |name, data_hash|
+              data_hash
+            }.map { |data_hash|
+              [ data_hash[:key_data], data_hash[:value_data] ].map { |value|
+                bdb_bytes_to_utf8_string(value)
+              }
+            }
+          end
+        end
+
+        def get_value_with_key_data_string_utf8(key_name, key_data)
+          with_bdb_db do |db|
+            value_data = db[make_key_with_data(key_name, key_data)]
+            return unless value_data
+            value_bytes = value_data.unpack("C*")
+            value_bytes.shift(read_compact_size(value_bytes)).pack("C*")
+          end
+        end
+
+        def set_value_with_key_data_string_utf8(key_name, key_data, value_data)
+          with_bdb_db do |db|
+            db[make_key_with_data(key_name, key_data)] = make_key(value_data)
+          end
+        end
+
+        def make_key(key_name)
+          key = [ ]
+          key << write_compact_size(key_name)
+          key.concat(key_name.unpack("C*"))
+          key.pack("C*")
+        end
+
+        def make_key_with_data(key_name, key_data)
+          make_key(key_name) + make_key(key_data)
+        end
+
+        # Maybe allow changing read/write & read-only when calling this?
+        def with_bdb_env(&block)
+          # This doesn't yet exactly mirror the DB setup in CWalletDB::LoadWallet
+          SBDB::Env.new(
+            dir:    File.expand_path(@db_dirname),
+            lg_max: 10_000_000,
+            flags:  Bdb::DB_CREATE     | # Create the environment if it does not already exist.
+                    Bdb::DB_INIT_LOCK  | # Initialize locking.
+                    Bdb::DB_INIT_LOG   | # Initialize logging
+                    Bdb::DB_INIT_MPOOL | # Initialize the in-memory cache.
+                    Bdb::DB_INIT_TXN   | # Initialize transactions
+                    Bdb::DB_THREAD     | # TODO: What?
+                    Bdb::DB_RECOVER      # TODO: What?
+          ) do |env|
+            yield env
+          end
+        end
+
+        def with_bdb_db(&block)
+          with_bdb_env do |env|
+            bitcoin_logical_database_name = "main"
+            # Leaving this here for reference: we could offer a read-only mode if we wanted (see Env flags though)
+            read_write_flags = Bdb::DB_CREATE | Bdb::DB_AUTO_COMMIT
+            read_only_flags = Bdb::DB_RDONLY
+            env.open(SBDB::Btree, File.expand_path(@db_filename), name: bitcoin_logical_database_name, flags: read_write_flags) do |db|
+              yield db
+        		end
+          end
+        end
+
+        def db_records(db)
+          db.to_hash.map { |key, value|
+            # Key name
+            key_bytes       = key.bytes.to_a
+            key_name_length = read_compact_size(key_bytes)
+            key_name        = key_bytes.shift(key_name_length).pack("C*").force_encoding("UTF-8")
+
+            # Key data
+            key_data_length = read_compact_size(key_bytes)
+            key_data_raw    = key_bytes.shift(key_data_length)
+
+            # Value data
+            value_bytes     = value.bytes.to_a
+            value_data_raw  =
+              case key_name
+              when "version" # values that don't start with a length
+                value_bytes
+              else # variable-length values
+                value_length = read_compact_size(value_bytes)
+                value_bytes.shift(value_length)
+              end
+
+            [ key_name, { key_data: key_data_raw, value_data: value_data_raw } ]
+          }
+        end
+
+        def write_compact_size(string)
+          string.bytesize
+        end
+
+        def read_compact_size(byte_array)
+          # The Satoshi client throws an error here if the determined length is greater
+          # than (uint64)MAX_SIZE - I don't know if we need to worry about it
+
+          byte_1 = byte_array.shift
+          if byte_1.nil?
+            0
+          elsif byte_1 < 253
+            byte_1
+          elsif byte_1 == 253
+            # Little-endian 16-bit
+            byte_array.shift(2).pack("C*").unpack("v").first
+          elsif byte_1 == 254
+            # Little-endian 32-bit int
+            byte_array.shift(4).pack("C*").unpack("V").first
+          else
+            # 64-bit int (is this little-endian or native?)
+            byte_array.shift(8).pack("C*").unpack("Q").first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/data_access/satoshi/satoshi_version.rb

@@ -0,0 +1,58 @@
+module Bitcoin
+  module DataAccess
+    module Satoshi
+      class SatoshiVersion
+        include Comparable
+
+        class << self
+          # Takes an array of unsigned bytes as extracted from a BDB wallet
+          def from_wallet_bytes(bytes)
+            from_wallet_int(bytes.pack("C*").unpack("V").first)
+          end
+
+          # Takes an 4-byte unsigned little-endian integer as extracted from a BDB wallet
+          def from_wallet_int(int_version)
+            new(*[int_version / 1_000_000, (int_version / 10_000) % 100, (int_version / 100) % 100, int_version % 100])
+          end
+        end
+
+        def initialize(*version_components)
+          @version_components = pad_4(version_components)
+        end
+
+        def <=>(other)
+          other.compare_version_components(@version_components)
+        end
+
+        def to_s
+          components = @version_components.dup
+          components.delete_at(3) if components[3] == 0
+          components.join(".")
+        end
+
+        alias_method :to_str, :to_s
+
+        def to_wallet_bytes
+          [
+            @version_components.zip([1_000_000, 10_000, 100, 1]).map { |component, multiplier|
+              component * multiplier
+            }.inject(:+)
+          ].pack("V").unpack("C*")
+        end
+
+        protected
+
+        def compare_version_components(other_version_components)
+          other_version_components <=> @version_components
+        end
+
+        # Pads 3-digit arrays with a 4th 0 value if necessary
+        def pad_4(components)
+          ([0] * 4).tap do |padded|
+            padded[0...components.length] = components
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/data_access/satoshi/satoshi_wallet.rb

@@ -0,0 +1,39 @@
+require 'bitcoin/data_access/satoshi/bdb_satoshi_wallet_repository'
+require 'bitcoin/data_access/satoshi/satoshi_version'
+require 'bitcoin/domain/address_book'
+require 'bitcoin/domain/bitcoin_address'
+
+module Bitcoin
+  module DataAccess
+    module Satoshi
+      class SatoshiWallet
+        class << self
+          def open(options, &block)
+            raise ArgumentError.new("You must provide a block to SatoshiWallet.new") unless block_given?
+            yield(new(BDBSatoshiWalletRepository.new(options[:wallet_filename], db_dirname: options[:db_dirname])))
+          end
+        end
+
+        def initialize(wallet_repository)
+          @wallet_repository = wallet_repository
+        end
+
+        def version
+          SatoshiVersion.from_wallet_int(@wallet_repository.get_value_immediate_uint32le("version"))
+        end
+
+        def addresses
+          addresses =
+            @wallet_repository.get_key_and_value_data_string_utf8("name").map { |key_data, value_data|
+              { address: Domain::BitcoinAddress.new(key_data), name: value_data }
+            }
+          Domain::AddressBook.new(addresses)
+        end
+
+        def add_address(bitcoin_address, options)
+          @wallet_repository.set_value_with_key_data_string_utf8("name", bitcoin_address.to_s, options[:name])
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/domain/address_book.rb

@@ -0,0 +1,19 @@
+module Bitcoin
+  module Domain
+    class AddressBook
+      def initialize(address_list = [])
+        @address_list = Marshal.load(Marshal.dump(address_list))
+      end
+
+      def to_a
+        @address_list
+      end
+
+      def to_s
+        @address_list.map { |address|
+          "#{address[:address]} #{address[:name]}"
+        }.join("\n")
+      end
+    end
+  end
+end

data/lib/bitcoin/domain/bitcoin_address.rb

@@ -0,0 +1,33 @@
+module Bitcoin
+  module Domain
+    # A Value Object representing a Bitcoin address
+    class BitcoinAddress
+      # An error indicating that we tried to create a BitcoinAddress with an invalid string
+      class InvalidBitcoinAddressError < ArgumentError
+        def initialize(address)
+          super(%'The address "#{address}" is not a valid Bitcoin address')
+        end
+      end
+
+      def initialize(string_address)
+        raise InvalidBitcoinAddressError.new(string_address) unless string_address.length == 34
+        @string_address = string_address
+      end
+
+      def to_s
+        @string_address
+      end
+
+      def ==(other)
+        other.is_a?(BitcoinAddress) &&
+          other.has_string_address_representation?(@string_address)
+      end
+
+      protected
+
+      def has_string_address_representation?(string_representation)
+        @string_address == string_representation
+      end
+    end
+  end
+end

data/lib/bitcoin/filesystem/empty_temp_dir.rb

@@ -0,0 +1,74 @@
+require 'fileutils'
+
+module Bitcoin
+  module FileSystem
+    # A class for managing temporary directories
+    #
+    # Example:
+    #
+    #     EmptyTempDir.new(with_name: "foo", parallel_to: "/tmp/myfile") do |temp_dir|
+    #       # ...
+    #     end
+    #
+    # creates the directory "/tmp/foo". It will be deleted at the end of the block,
+    # regardless of whether it existed before or not.
+    #
+    # If it existed before, it will be emptied before the block starts.
+    #
+    # If the requested directory name exists but is a file, the behaviour is undefined
+    class EmptyTempDir
+      class << self
+        def open(options, &block)
+          raise ArgumentError.new("You must provide a block to EmptyTempDir.open") if block.nil?
+          BlockRunner.new(dirname(options[:with_name], options[:parallel_to])).run(block)
+        end
+
+        private
+
+        def dirname(name, parallel_to)
+          File.expand_path(File.join(File.dirname(parallel_to), name))
+        end
+      end
+
+      class BlockRunner
+        def initialize(path)
+          @path = path
+          raise_if_path_is_unsafe
+        end
+
+        def run(proc)
+          ensure_empty_directory(absolute_path)
+          result = proc.(self)
+        ensure
+          FileUtils.rm_rf(absolute_path)
+          result
+        end
+
+        def absolute_path
+          @path
+        end
+
+        private
+
+        def ensure_empty_directory(absolute_path)
+          if File.directory?(@path)
+            File.join(@path, "*")
+            FileUtils.rm_rf(Dir[path_entries_wildcard])
+          else
+            FileUtils.mkdir(@path)
+          end
+        end
+
+        def raise_if_path_is_unsafe
+          if path_entries_wildcard =~ %r"^/+\*"
+            raise ArgumentError.new("Unacceptable directory name for EmptyTempDir")
+          end
+        end
+
+        def path_entries_wildcard
+          File.join(@path, "*")
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/rspec/argument_matchers.rb

@@ -0,0 +1 @@
+require_relative 'argument_matchers/block_evaluating_to_matcher'

data/lib/bitcoin/rspec/argument_matchers/block_evaluating_to_matcher.rb

@@ -0,0 +1,23 @@
+module Bitcoin
+  module RSpec
+    module ArgumentMatchers
+      class BlockEvaluatingToMatcher
+        def initialize(expected_value)
+          @expected_value = expected_value
+        end
+
+        def description
+          "block_evaluating_to(#{@expected_value.inspect})"
+        end
+
+        def ==(other)
+          @expected_value == other.()
+        end
+      end
+
+      def block_evaluating_to(expected_value)
+        BlockEvaluatingToMatcher.new(expected_value)
+      end
+    end
+  end
+end

data/lib/bitcoin/rspec/directory_helpers.rb

@@ -0,0 +1,22 @@
+module Bitcoin
+  module RSpec
+    module DirectoryHelpers
+      module ClassMethods
+        def ensure_empty_test_dir(dirname)
+          before(:each) do
+            ensure_empty_directory(dirname)
+          end
+        end
+      end
+
+      def self.included(host)
+        host.extend(ClassMethods)
+      end
+
+      def ensure_empty_directory(dirname)
+        FileUtils.rm_rf(dirname)
+        FileUtils.mkdir_p(dirname)
+      end
+    end
+  end
+end