coin-op 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dfeba45649380d25bdb450efa635c4abfeb97808
+  data.tar.gz: 9163ba6bb9a926d3e68ac56d52cfedf8a58f5896
+SHA512:
+  metadata.gz: 5dc4eb2daff6a91ed33309ef74562ec21573c165708825bf616b03f3bf6df2d1ef20ee277d726889fb808b4f99325cee05916e77cd4099eb04ef91ad9969cc4d
+  data.tar.gz: 8186166830812cf399ad01542cc936e156589d42bef51be532e39a61d57324b99c2f72e47022f6799425703b15a2982db6ab270ea995f106113c71c214102c5a

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 BitVault, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,28 @@
+# Coin-Op
+
+Install:
+
+    gem install coin-op
+
+
+Use:
+
+```ruby
+require "coin-op"
+
+include CoinOp::Bit
+
+```
+
+# Developers
+
+Installing dependencies:
+
+    gem install starter
+    rake gem:deps
+
+Running the tests:
+
+    rake test
+
+

data/lib/coin-op.rb

@@ -0,0 +1,12 @@
+
+# Establish the namespace.
+module CoinOp
+
+end
+
+require_relative "coin-op/encodings"
+require_relative "coin-op/crypto"
+require_relative "coin-op/bit"
+require_relative "coin-op/blockchain/mockchain"
+require_relative "coin-op/blockchain/blockr"
+

data/lib/coin-op/bit.rb

@@ -0,0 +1,21 @@
+require "bitcoin"
+require "money-tree"
+
+# establish the namespace
+module CoinOp
+  module Bit
+  end
+end
+
+require_relative "encodings"
+
+# Wrappers
+require_relative "bit/script"
+require_relative "bit/output"
+require_relative "bit/input"
+require_relative "bit/transaction"
+require_relative "bit/spendable"
+
+# Augmented functionality
+require_relative "bit/multi_wallet"
+

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

@@ -0,0 +1,73 @@
+
+module CoinOp::Bit
+
+  class SparseInput
+    include CoinOp::Encodings
+
+    def initialize(binary_hash, index)
+      @output = {
+        # the binary hash is the result of 
+        # [tx.hash].pack("H*").reverse
+        :transaction_hash => hex(binary_hash.reverse),
+        :index => index,
+      }
+    end
+
+    def to_json(*a)
+      {
+        :output => @output,
+      }.to_json(*a)
+    end
+
+  end
+
+
+  class Input
+    include CoinOp::Encodings
+
+    attr_reader :native, :output, :binary_sig_hash,
+      :signatures, :sig_hash, :script_sig, :index
+
+    def initialize(options={})
+      @transaction, @index, @output =
+        options.values_at :transaction, :index, :output
+
+      unless @output.is_a? Output
+        @output = Output.new(@output)
+      end
+
+      @native = Bitcoin::Protocol::TxIn.new
+
+      @native.prev_out = decode_hex(@output.transaction_hash).reverse
+      @native.prev_out_index = @output.index
+
+      @signatures = []
+    end
+
+    def binary_sig_hash=(blob)
+      @binary_sig_hash = blob
+      @sig_hash = base58(blob)
+    end
+
+    def script_sig=(blob)
+      script = Script.new(:blob => blob)
+      @script_sig = script.to_s
+      @native.script_sig = blob
+    end
+
+
+    def to_json(*a)
+      {
+        :output => self.output,
+        :signatures => self.signatures.map {|b| base58(b) },
+        :sig_hash => self.sig_hash || "",
+        :script_sig => self.script_sig || ""
+      }.to_json(*a)
+    end
+
+  end
+
+
+end
+
+

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

@@ -0,0 +1,261 @@
+require "money-tree"
+require "bitcoin"
+
+module CoinOp::Bit
+
+  class MultiWallet
+    include CoinOp::Encodings
+
+    def self.generate(names, network=:bitcoin_testnet)
+      masters = {}
+      names.each do |name|
+        name = name.to_sym
+        masters[name] = MoneyTree::Master.new(:network => network)
+      end
+      self.new(:private => masters)
+    end
+
+    attr_reader :trees
+
+    def initialize(options)
+      # FIXME: must accept option for which network to use.
+      @private_trees = {}
+      @public_trees = {}
+      @trees = {}
+      private_trees = options[:private]
+
+      if !private_trees
+        raise "Must supply :private"
+      end
+
+      private_trees.each do |name, arg|
+        name = name.to_sym
+        @private_trees[name] = @trees[name] = self.get_node(arg)
+      end
+
+      if public_trees = options[:public]
+        public_trees.each do |name, arg|
+          name = name.to_sym
+          @public_trees[name] = @trees[name] = self.get_node(arg)
+        end
+      end
+    end
+
+    def drop(*names)
+      names = names.map(&:to_sym)
+      options = {:private => {}, :public => {}}
+      @private_trees.each do |name, node|
+        unless names.include?(name.to_sym)
+          options[:private][name] = node
+        end
+      end
+      @public_trees.each do |name, node|
+        unless names.include?(name.to_sym)
+          options[:private][name] = node
+        end
+      end
+      self.class.new options
+    end
+
+    def drop_private(*names)
+      names.each do |name|
+        name = name.to_sym
+        tree = @private_trees.delete(name)
+        address = tree.to_serialized_address
+        @public_trees[name] = MoneyTree::Master.from_serialized_address(address)
+      end
+    end
+
+    def import(addresses)
+      addresses.each do |name, address|
+        node = MoneyTree::Master.from_serialized_address(address)
+        if node.private_key
+          @private_trees[name] = node
+        else
+          @public_trees[name] = node
+        end
+      end
+    end
+
+    def private_seed(name)
+      raise "No such node: '#{name}'" unless (node = @private_trees[name.to_sym])
+      node.to_serialized_address(:private)
+    end
+
+    alias_method :private_address, :private_seed
+
+    def public_seed(name)
+      name = name.to_sym
+      if node = (@public_trees[name] || @private_trees[name])
+        node.to_serialized_address
+      else
+        raise "No such node: '#{name}'"
+      end
+    end
+
+    alias_method :public_address, :public_seed
+
+    def private_addresses
+      out = {}
+      @private_trees.each do |name, tree|
+        out[name] = self.private_address(name)
+      end
+      out
+    end
+
+    def public_addresses
+      out = {}
+      @private_trees.each do |name, node|
+        out[name] = node.to_serialized_address
+      end
+      out
+    end
+
+    def get_node(arg)
+      case arg
+      when MoneyTree::Node
+        arg
+      when String
+        MoneyTree::Node.from_serialized_address(arg)
+      else
+        raise "Unusable type: #{node.class}"
+      end
+    end
+
+    def path(path)
+      options = {
+        :path => path,
+        :private => {},
+        :public => {}
+      }
+      @private_trees.each do |name, node|
+        options[:private][name] = node.node_for_path(path)
+      end
+      @public_trees.each do |name, node|
+        options[:public][name] = node.node_for_path(path)
+      end
+
+      MultiNode.new(options)
+    end
+
+    def valid_output?(output)
+      if path = output.metadata.wallet_path
+        node = self.path(path)
+        node.p2sh_script.to_s == output.script.to_s
+      else
+        true
+      end
+    end
+
+    # Takes a Transaction ready to be signed.
+    #
+    # Returns an Array of signature dictionaries.
+    def signatures(transaction)
+      transaction.inputs.map do |input|
+        path = input.output.metadata[:wallet_path]
+        node = self.path(path)
+        sig_hash = transaction.sig_hash(input, node.script)
+        node.signatures(sig_hash)
+      end
+    end
+
+
+    # Takes a Transaction and any number of Arrays of signature dictionaries.
+    # Each sig_dict in an Array corresponds to the Input with the same index.
+    #
+    # Uses the combined signatures from all the signers to generate and set
+    # the script_sig for each Input.
+    #
+    # Returns the transaction.
+    def authorize(transaction, *signers)
+      transaction.set_script_sigs *signers do |input, *sig_dicts|
+        node = self.path(input.output.metadata[:wallet_path])
+        signatures = combine_signatures(*sig_dicts)
+        node.script_sig(signatures)
+      end
+      transaction
+    end
+
+    # Takes any number of "signature dictionaries", which are Hashes where
+    # the keys are tree names, and the values are base58-encoded signatures
+    # for a single input.
+    #
+    # Returns an Array of the signatures in binary, sorted by their tree names.
+    def combine_signatures(*sig_dicts)
+      combined = {}
+      sig_dicts.each do |sig_dict|
+        sig_dict.each do |tree, signature|
+          combined[tree] = decode_base58(signature)
+        end
+      end
+
+      # Order of signatures is important for validation, so we always
+      # sort public keys and signatures by the name of the tree
+      # they belong to.
+      combined.sort_by { |tree, value| tree }.map { |tree, sig| sig }
+    end
+
+  end
+
+  class MultiNode
+    include CoinOp::Encodings
+
+    attr_reader :path, :keys, :public_keys
+    def initialize(options)
+      # m of n 
+      # TODO: take @m from the options
+      @m = 2
+      @path = options[:path]
+
+      @keys = {}
+      @public_keys = {}
+      @private = options[:private]
+      @public = options[:public]
+
+      @private.each do |name, node|
+        key = Bitcoin::Key.new(node.private_key.to_hex, node.public_key.to_hex)
+        @keys[name] = key
+        @public_keys[name] = key
+      end
+      @public.each do |name, node|
+        @public_keys[name] = Bitcoin::Key.new(nil, node.public_key.to_hex)
+      end
+    end
+
+    def script
+      keys = @public_keys.sort_by {|name, key| name }.map {|name, key| key.pub }
+      Script.new(:public_keys => keys, :needed => @m)
+    end
+
+    def p2sh_address
+      self.script.p2sh_address
+    end
+
+    def p2sh_script
+      Script.new(:address => self.script.p2sh_address)
+    end
+
+    def sign(name, value)
+      raise "No such key: '#{name}'" unless (key = @keys[name.to_sym])
+      # \x01 means the hash type is SIGHASH_ALL
+      # https://en.bitcoin.it/wiki/OP_CHECKSIG#Hashtype_SIGHASH_ALL_.28default.29
+      key.sign(value) + "\x01"
+    end
+
+    def signatures(value)
+      out = {}
+      @keys.each do |name, key|
+        out[name] = base58(self.sign(name, value))
+      end
+      out
+    end
+
+    def script_sig(signatures)
+      self.script.p2sh_sig(:signatures => signatures)
+    end
+
+  end
+
+
+end
+

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

@@ -0,0 +1,79 @@
+
+module CoinOp::Bit
+
+  class Output
+    include CoinOp::Encodings
+
+    attr_accessor :metadata
+    attr_reader :native, :transaction, :index, :value, :script, :address
+
+    # Takes a Hash with required keys:
+    #
+    # * either :transaction (an instance of Transaction)
+    #   or :transaction_hash (the hex-encoded hash of a Bitcoin transaction)
+    # * :index
+    # * :script
+    #
+    # optional keys:
+    #
+    # * :value
+    # * :metadata
+    # 
+    def initialize(options)
+      if options[:transaction]
+        @transaction = options[:transaction]
+      elsif options[:transaction_hash]
+        @transaction_hash = options[:transaction_hash]
+      end
+
+      # FIXME: be aware of string bitcoin values versus
+      # integer satoshi values
+      @index, @value, @address = options.values_at :index, :value, :address
+      @metadata = options[:metadata] || {}
+
+      if options[:script]
+        @script = Script.new(options[:script])
+      else
+        raise ArgumentError, "No script supplied"
+      end
+
+      @native = Bitcoin::Protocol::TxOut.from_hash(
+        "value" => @value.to_s,
+        "scriptPubKey" => @script.to_s
+      )
+    end
+
+    def set_transaction(transaction, index)
+      @transaction_hash = nil
+      @transaction, @index = transaction, index
+    end
+
+    def transaction_hash
+      if @transaction
+        @transaction.hex_hash
+      elsif @transaction_hash
+        @transaction_hash
+      else
+        ""
+      end
+    end
+
+
+    def to_hash
+      {
+        :transaction_hash => self.transaction_hash,
+        :index => self.index,
+        :value => self.value,
+        :script => self.script,
+        :address => self.address,
+        :metadata => self.metadata
+      }
+    end
+
+    def to_json(*a)
+      self.to_hash.to_json(*a)
+    end
+
+  end
+
+end