coin-op 0.1.0

data/lib/coin-op/bit/script.rb

@@ -0,0 +1,94 @@
+
+module CoinOp::Bit
+
+  class Script
+    include CoinOp::Encodings
+
+    attr_reader :native
+
+    def initialize(options)
+      # literals
+      if options.is_a? String
+        @blob = Bitcoin::Script.binary_from_string options
+      elsif string = options[:string]
+        @blob = Bitcoin::Script.binary_from_string string
+      elsif options[:blob]
+        @blob = options[:blob]
+      elsif options[:hex]
+        @blob = decode_hex(options[:hex])
+      # arguments for constructing
+      else
+        if address = options[:address]
+          @blob = Bitcoin::Script.to_address_script(address)
+        elsif public_key = options[:public_key]
+          @blob = Bitcoin::Script.to_pubkey_script(public_key)
+        elsif (keys = options[:public_keys]) && (needed = options[:needed])
+          @blob = Bitcoin::Script.to_multisig_script(needed, *keys)
+        elsif signatures = options[:signatures]
+          @blob = Bitcoin::Script.to_multisig_script_sig(*signatures)
+        else
+          raise ArgumentError
+        end
+      end
+
+      @hex = hex(@blob)
+      @native = Bitcoin::Script.new @blob
+      @string = @native.to_string
+    end
+
+    def to_s
+      @string
+    end
+
+    def to_hex
+      @hex
+    end
+
+    def to_blob
+      @blob
+    end
+
+    alias_method :to_binary, :to_blob
+
+    def type
+      case self.native.type
+      when :hash160
+        :pubkey_hash
+      when :p2sh
+        :script_hash
+      else
+        self.native.type
+      end
+    end
+
+    def to_hash
+      {
+        :type => self.type,
+        :string => self.to_s
+      }
+    end
+
+    def to_json(*a)
+      self.to_hash.to_json(*a)
+    end
+
+    def hash160
+      Bitcoin.hash160(@hex)
+    end
+
+    def p2sh_script
+      self.class.new Bitcoin::Script.to_p2sh_script(self.hash160)
+    end
+
+    def p2sh_address
+      Bitcoin.hash160_to_p2sh_address(self.hash160)
+    end
+
+    def p2sh_sig(options)
+      string = Script.new(options).to_s
+      Bitcoin::Script.binary_from_string("#{string} #{self.to_hex}")
+    end
+
+  end
+
+end

data/lib/coin-op/bit/spendable.rb

@@ -0,0 +1,85 @@
+module CoinOp::Bit
+  module Spendable
+
+    def network
+      raise "implement #network in your class"
+    end
+
+    def balance
+      raise "implement #balance in your class"
+    end
+
+    def unspent
+      raise "implement #unspent in your class"
+    end
+
+    def select_unspent
+      raise "implement #select_unspent in your class"
+    end
+
+    def authorize
+      raise "implement #authorize in your class"
+    end
+
+    def blockchain
+      # FIXME: use the return value of #network as the arg, once this ticket
+      # is resolved: # https://github.com/BitVault/bitvault/issues/251
+      @blockchain ||= BitVaultAPI::Blockchain::Blockr.new(:test)
+    end
+
+    def lock(outputs)
+      # no op
+      # Mixing classes may wish to lock down these selected outputs
+      # so that concurrent payments or transfers cannot use them.
+      #
+      # When do we release unspents (if a user abandons a transaction)?
+    end
+
+    def unlock(outputs)
+    end
+
+    def create_transaction(outputs, change_address)
+
+      transaction = CoinOp::Bit::Transaction.build do |t|
+        outputs.each do |output|
+          t.add_output(output)
+        end
+      end
+
+      if self.balance < transaction.output_value
+        raise InsufficientFunds
+      end
+
+      unspent = self.select_unspent(transaction.output_value)
+
+      unspent.each do |output|
+        transaction.add_input output
+      end
+
+      input_amount = unspent.inject(0) {|sum, output| sum += output.value }
+      fee = transaction.suggested_fee
+
+      # FIXME: there's likely another unspent output we can add, but the present
+      # implementation of all this can't easily help us.  Possibly stop
+      # using select_unspent(value) and start using a while loop that shifts
+      # outputs off the array.  Then we can start the process over.
+      if input_amount < (transaction.output_value + transaction.suggested_fee)
+        raise InsufficientFunds
+      end
+
+      change = input_amount - (transaction.output_value + fee)
+
+      transaction.add_output(
+        :value => change,
+        :script => {
+          :address => change_address
+        },
+        :address => change_address,
+      )
+
+      self.authorize(transaction)
+      transaction
+    end
+
+  end
+end

data/lib/coin-op/bit/transaction.rb

@@ -0,0 +1,238 @@
+
+module CoinOp::Bit
+
+  class Transaction
+    include CoinOp::Encodings
+
+    def self.build(&block)
+      transaction = self.new
+      yield transaction
+      transaction
+    end
+
+    def self.native(tx)
+      transaction = self.new()
+      # TODO: reconsider use of instance_eval
+      transaction.instance_eval do
+        @native = tx
+        tx.inputs.each_with_index do |input, i|
+          # We use SparseInput because it does not require the retrieval
+          # of the previous output.  Its functionality should probably be
+          # folded into the Input class.
+          @inputs << SparseInput.new(input.prev_out, input.prev_out_index)
+        end
+        tx.outputs.each_with_index do |output, i|
+          @outputs << Output.new(
+            :transaction => transaction,
+            :index => i,
+            :value => output.value,
+            :script => {:blob => output.pk_script}
+          )
+        end
+      end
+
+      report = transaction.validate_syntax
+      unless report[:valid] == true
+        raise "Invalid syntax:  #{report[:errors].to_json}"
+      end
+      transaction
+    end
+
+    def self.raw(raw_tx)
+      self.native ::Bitcoin::Protocol::Tx.new(raw_tx)
+    end
+
+    def self.hex(hex)
+      self.raw CoinOp::Encodings.decode_hex(hex)
+    end
+
+    def self.data(hash)
+      version, lock_time, tx_hash, inputs, outputs = 
+        hash.values_at :version, :lock_time, :tx_hash, :inputs, :outputs
+
+      transaction = self.new
+
+      outputs.each do |data|
+        transaction.add_output Output.new(data)
+      end
+
+      #FIXME: we're not handling sig_scripts for already signed inputs.
+
+      inputs.each_with_index do |data, index|
+        transaction.add_input data[:output]
+
+        ## FIXME: verify that the supplied and computed sig_hashes match
+        #puts :sig_hashes_match => (data[:sig_hash] == input.sig_hash)
+      end
+
+      transaction
+    end
+
+    attr_reader :native, :inputs, :outputs
+
+    def initialize
+      @native = native || Bitcoin::Protocol::Tx.new
+      @inputs = []
+      @outputs = []
+    end
+
+    def update_native
+      yield @native if block_given?
+      @native = Bitcoin::Protocol::Tx.new(@native.to_payload)
+      @inputs.each_with_index do |input, i|
+        native = @native.inputs[i]
+        # Using instance_eval here because I really don't want to expose
+        # Input#native=.  As we consume more and more of the native
+        # functionality, we can dispense with such ugliness.
+        input.instance_eval do
+          @native = native
+        end
+        if input.is_a? Input
+          input.binary_sig_hash = self.sig_hash(input)
+        end
+        # TODO: is this re-nativization necessary for outputs, too?
+      end
+    end
+
+    def validate_syntax
+      update_native
+      validator = Bitcoin::Validation::Tx.new(@native, nil)
+      valid = validator.validate :rules => [:syntax]
+      {:valid => valid, :error => validator.error}
+    end
+
+    def validate_script_sigs
+      bad_inputs = []
+      valid = true
+      @inputs.each_with_index do |input, index|
+        # TODO: confirm whether we need to mess with the block_timestamp arg
+
+        unless self.native.verify_input_signature(index, input.output.transaction.native)
+          valid = false
+          bad_inputs << index
+        end
+
+      end
+      {:valid => valid, :inputs => bad_inputs}
+    end
+
+    # Takes one of
+    #
+    # * an instance of Input
+    # * an instance of Output
+    # * a Hash describing an Output
+    #
+    def add_input(arg)
+      # TODO: allow specifying prev_tx and index with a Hash.
+      # Possibly stop using SparseInput.
+      if arg.is_a? Input
+        input = arg
+      else
+        input = Input.new(
+          :transaction => self,
+          :index => @inputs.size,
+          :output => arg
+        )
+      end
+
+      @inputs << input
+      self.update_native do |native|
+        native.add_in input.native
+      end
+      input
+    end
+
+    def add_output(output)
+      unless output.is_a? Output
+        output = Output.new(output)
+      end
+
+      index = @outputs.size
+      output.set_transaction self, index
+      @outputs << output
+      self.update_native do |native|
+        native.add_out(output.native)
+      end
+    end
+
+    def binary_hash
+      update_native
+      @native.binary_hash
+    end
+
+    def hex_hash
+      update_native
+      @native.hash
+    end
+
+    def version
+      @native.ver
+    end
+
+    def lock_time
+      @native.lock_time
+    end
+
+    def to_hex
+      payload = self.native.to_payload
+      CoinOp::Encodings.hex(payload)
+    end
+
+    def to_json(*a)
+      self.to_hash.to_json(*a)
+    end
+
+    def to_hash
+      {
+        :version => self.version,
+        :lock_time => self.lock_time,
+        :hash => self.hex_hash,
+        :inputs => self.inputs,
+        :outputs => self.outputs,
+      }
+    end
+
+    def sig_hash(input, script=nil)
+      # NOTE: we only allow SIGHASH_ALL at this time
+      # https://en.bitcoin.it/wiki/OP_CHECKSIG#Hashtype_SIGHASH_ALL_.28default.29
+
+      prev_out = input.output
+      script ||= prev_out.script
+
+      @native.signature_hash_for_input(input.index, nil, script.to_blob)
+    end
+
+    def set_script_sigs(*input_args, &block)
+      # No sense trying to authorize when the transaction isn't usable.
+      report = validate_syntax
+      unless report[:valid] == true
+        raise "Invalid syntax:  #{report[:errors].to_json}"
+      end
+
+      # Array#zip here allows us to iterate over the inputs in lockstep with any
+      # number of sets of signatures.
+      self.inputs.zip(*input_args) do |input, *input_arg|
+        input.script_sig = yield input, *input_arg
+      end
+    end
+
+
+    def suggested_fee
+      @native.minimum_block_fee
+    end
+
+
+    # Total value being spent
+    def output_value
+      total = 0
+      @outputs.each do |output|
+        total += output.value
+      end
+
+      total
+    end
+
+
+  end
+
+end

data/lib/coin-op/blockchain/blockr.rb

@@ -0,0 +1,162 @@
+require "http"
+require "json"
+require 'enumerator'
+
+require_relative "../bit"
+
+module CoinOp
+  module Blockchain
+
+    # Blockr.io API documentation:  http://blockr.io/documentation/api
+    class Blockr
+      include CoinOp::Encodings
+
+      def initialize(env=:test)
+        subdomain = (env.to_sym == :test) ? "tbtc" : "btc"
+        @base_url = "http://#{subdomain}.blockr.io/api/v1"
+
+        # Testing says 20 is the absolute max
+        @max_per_request = 20
+
+        @http = HTTP.with_headers(
+          "User-Agent" => "bv-blockchain-worker v0.1.0",
+          "Accept" => "application/json"
+        )
+      end
+
+
+      attr_accessor :max_per_request
+
+
+      def unspent(addresses, confirmations=6)
+
+        result = request(
+          :address, :unspent, addresses,
+          :confirmations => confirmations
+        )
+
+        outputs = []
+        result.each do |record|
+          record[:unspent].each do |output|
+            address = record[:address]
+
+            transaction_hex, index, value, script_hex =
+              output.values_at :tx, :n, :amount, :script
+
+            outputs << CoinOp::Bit::Output.new(
+              :transaction_hex => transaction_hex,
+              :index => index,
+              :value => bitcoins_to_satoshis(value),
+              :script => {:hex => script_hex},
+              :address => address
+            )
+          end
+        end
+
+        outputs.sort_by {|output| -output.value }
+      end
+
+
+      def balance(addresses)
+        result = request(:address, :balance, addresses)
+        balances = {}
+        result.each do |record|
+          balances[record[:address]] = float_to_satoshis(record[:balance])
+        end
+
+        balances
+      end
+
+
+      def transactions(tx_ids)
+        results = request(:tx, :raw, tx_ids)
+        results.map do |record|
+          hex = record[:tx][:hex]
+
+          transaction = CoinOp::Bit::Transaction.hex(hex)
+        end
+      end
+
+
+      def address_info(addresses, confirmations=6)
+        # Useful for testing transactions()
+        request(
+          :address, :info, addresses,
+          :confirmations => confirmations
+        )
+      end
+
+
+      def block_info(block_list)
+        request(:block, :info, block_list)
+      end
+
+
+      def block_txs(block_list)
+        request(:block, :txs, block_list)
+      end
+
+
+      # Helper methods
+
+      def bitcoins_to_satoshis(string)
+        string.gsub(".", "").to_i
+      end
+
+      def float_to_satoshis(float)
+        (float * 100_000_000).to_i
+      end
+
+
+      # Queries the Blockr Bitcoin from_type => to_type API with
+      # list, returning the results or throwing an exception on
+      # failure.
+      def request(from_type, to_type, args, query=nil)
+
+        unless args.is_a? Array
+          args = [args]
+        end
+
+        data = []
+        args.each_slice(@max_per_request) do |arg_slice|
+          # Permit calling with either an array or a scalar
+            slice_string = arg_slice.join(",")
+          url = "#{@base_url}/#{from_type}/#{to_type}/#{slice_string}"
+
+          # Construct query string if any params were passed.
+          if query
+            # TODO: validation.  The value of the "confirmations" parameter
+            # must be an integer.
+            params = query.map { |name, value| "#{name}=#{value}" }.join("&")
+            url = "#{url}?#{params}"
+          end
+
+          response = @http.request "GET", url, :response => :object
+          # FIXME:  rescue any JSON parsing exception and raise an
+          # exception explaining that it's blockr's fault.
+          begin
+            content = JSON.parse(response.body, :symbolize_names => true)
+          rescue JSON::ParserError => e
+            raise "Blockr returned invalid JSON: #{e}"
+          end
+
+          if content[:status] != "success"
+            raise "Blockr.io failure: #{content.to_json}"
+          end
+
+          slice_data = content[:data]
+          if content[:data].is_a? Array
+            data.concat slice_data
+          else
+            data << slice_data
+          end
+        end
+
+        data
+      end
+
+    end
+
+  end
+end
+