pochette 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65f4b14b12eac44180a3b5b9cdb863ad6c2aa1bc
+  data.tar.gz: 9ccb9cf9b0991fcaab88913f2d3785780cfc99f2
+SHA512:
+  metadata.gz: dcc3594a14fde23c00a09465ef3a5678b06aa240e4a723dcbd233564660139cf8e98704e5e5a330e8c08c45eeb2164ac579c2bde9fc4e2d7bab8cc606368b189
+  data.tar.gz: 1959ce4d4eb08d4bb558f11e65272cdb9d9f92c9069caca19d4e90dd3ace44a35059f786754defe2e5da853b5dc87544f4c964d01fc2e281ae0c614e03c05e84

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pochette.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Nubis
+
+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,133 @@
+# Pochette
+
+Pochette is a Bitcoin Wallet for developers, or more accurately a tool for building 
+"single purpose wallets".
+
+It's used extensively at [Bitex.la](https://bitex.la) from checking and crediting customer
+bitcoin deposits to preparing transactions with bip32 paths instead of input addresess,
+ready to be signed with a [Trezor Device](https://www.bitcointrezor.com/)
+
+Pochette offers a common interface to full bitcoin nodes like
+[Bitcoin Core](https://bitcoin.org/en/download) or [Toshi](http://toshi.io)
+and will let you run several instances of each one of them simultaneously
+always choosing the most recent node to query.
+
+It also provides a Pochette::TransactionBuilder class which receives a list
+of 'source' addresses and a list of recipients as "address/amount" pairs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pochette'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pochette
+
+## The Pochette::TransactionBuilder
+
+The TransactionBuilder builds transactions from a list of source addresses and a list of recipients,
+using Pochette.backend to fetch unspent outputs and related transaction data.
+Instantiating will perform all the required queries, you'll be left with a
+TransactionBuilder object that is either valid? or not, and if valid,
+you can query the results via to_hash.
+
+The TransactionBuilder's initializer receives a single options hash with:
+  addresses:
+    List of addresses in wallet.
+    We will be spending their unspent outputs.
+  outputs:
+    List of pairs [recipient_address, amount]
+    This will not be all the final outputs in the transaction,
+    as a 'change' output may be added if needed.
+  utxo_blacklist:
+    List of utxos to ignore, a list of pairs [transaction hash, position]
+  change_address:
+    Change address to use. Will default to the first source address.
+  fee_per_kb:
+    Defaults to 10000 satoshis.
+  spend_all:
+    Wether to spend all available utxos or just select enough to
+    cover the given outputs.
+
+TODO: Document as_hash output.
+
+## Building for Trezor with Pochette::TrezorTransactionBuilder
+
+Same as TransactionBuilder but outputs a transaction hash with all the
+required data to create and sign a transaction using a BitcoinTrezor.
+
+* Uses BIP32 addresses instead of regular strings.
+  Each address is represented as a pair, with the public address string
+  and the BIP32 path as a list of integers, for example:
+  ['public-address-as-string', [44, 1, 3, 11]]
+
+* Includes associated transaction data for each input being spent,
+  ready to be consumed by your Trezor device.
+
+* Outputs are represented as JSON with script_type as expected by Trezor.
+  { script_type: 'PAYTOADDRESS',
+    address: '1address-as-string',
+    amount: amount_in_satoshis }
+
+TODO: Document as_hash output.
+
+## Using a Bitcoin-Core backend.
+
+Pochette will connect to your bitcoin-core node via JSON-RPC, using the
+[bitcoin-rpc gem](https://github.com/bitex-la/bitcoin-rpc)
+
+To properly use Pochette you need to be running your bitcoin node with setting the
+"-txindex=1" option to get a full transaction index.
+[Learn more about -txindex=1](http://bitcoin.stackexchange.com/questions/35707/what-are-pros-and-cons-of-txindex-option)
+
+Also, if you're creating new addresses and want bitcoin-core to track them you'll want to import
+them using the bitcoin-rpc gem, like so:
+
+      >>> BitcoinRpc::Client.new('http://user:pass@your_server').importaddress('1PUBLICADDRESS', '', false)
+
+Setting up bitcoin-core as a backend can be done like this:
+
+      >>> Pochette.backend = Pochette::Backends::BitcoinCore.new('http://user:pass@your_server')
+
+## Using a Toshi backend.
+
+Pochette will connect to your Toshi node's postgres database directly.
+It's provided as a separate gem as it depends on the pg gem which needs local
+postgres extensions to work. You may need to add some extra indexes to your postgres
+to speed things up when using Pochette.
+[See the gem readme](https://github.com/bitex-la/pochette-toshi) for more info.
+
+## Using the best of many available backends
+
+Pochette provides a higher level Backend Pochette::Backends::Trendy which chooses
+between a pool of available backends always using the one at the highest block height,
+(but biased towards using the incumbent backend).
+
+This is useful for automatic fallbacks and redundancy, you could also mix Toshi and Bitcoin-Core
+backends and use whatever looks more up to date.
+
+      >>> alpha = Pochette::Backends::BitcoinCore.new('http://user:pass@alpha_host')
+      >>> beta = Pochette::Backends::BitcoinCore.new('http://user:pass@beta_host')
+      >>> Pochette.backend = Pochette::Backends::Trendy.new([alpha, beta])
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/pochette/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pochette"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pochette/backends/bitcoin_core.rb

@@ -0,0 +1,105 @@
+# A bitcoin backend that uses bitcoin-core to retrieve information.
+# See Pochette::Backends::Trendy to learn more about the backend
+# interface and contract.
+class Pochette::Backends::BitcoinCore 
+  def initialize(rpc_url)
+    @rpc_url = rpc_url
+  end
+
+  def client
+    BitcoinRpc::Client.new(@rpc_url)
+  end
+  
+  def incoming_for(addresses, min_date)
+    return [] if addresses.empty?
+
+    addresses = addresses.to_set
+    block_height = client.getblockcount
+    from_block = block_height - ((Time.now - min_date) / 60 / 60 * 6).ceil
+    block_hash = client.getblockhash(from_block)
+    
+    result = []
+    client.listsinceblock(block_hash, 1, true)[:transactions].each do |t|
+      next unless t[:category] == 'receive'
+      next unless addresses.include?(t[:address])
+      senders = []
+      client.getrawtransaction(t[:txid], 1)[:vin].each do |i|
+        raw_sender = client.getrawtransaction(i[:txid], 1)
+        senders += raw_sender[:vout][i[:vout]][:scriptPubKey][:addresses]
+      end
+      result << [(t[:amount] * 1_0000_0000).to_i, t[:address], t[:txid],
+        t[:confirmations], t[:vout], senders.join(',')]
+    end
+    result
+  end
+
+  def balances_for(addresses, confirmations)
+    return {} if addresses.empty?
+    result = addresses.reduce({}) do |accum, address|
+      accum[address] = [0,0,0,0,0,0]
+      accum
+    end
+    
+    # Populate confirmed received
+    client.listreceivedbyaddress(confirmations, false, true).each do |a|
+      next unless result[a[:address]]
+      result[a[:address]][0] = a[:amount]
+      result[a[:address]][1] = a[:amount] # Will substract UTXO from it later.
+    end
+
+    # Populate unconfirmed received
+    client.listreceivedbyaddress(0, false, true).each do |a|
+      next unless result[a[:address]]
+      result[a[:address]][3] = a[:amount]
+      result[a[:address]][4] = a[:amount] # Will substract UTXO from it later.
+    end
+    
+    # Fix sent amounts to not include amounts which werent actually sent.
+    client.listunspent(0, 99999999, addresses).each do |utxo|
+      if utxo[:confirmations] >= confirmations
+        result[utxo[:address]][1] -= utxo[:amount]
+      end
+      result[utxo[:address]][4] -= utxo[:amount]
+    end
+    
+    # Totals are just one substraction away
+    result.each do |k, v| 
+      v[2] = v[0] - v[1]
+      v[5] = v[3] - v[4]
+    end
+
+    result
+  end
+  
+  def list_unspent(addresses)
+    return nil if addresses.empty?
+    client.listunspent(1, 99999999, addresses).collect do |u| 
+      [u[:address], u[:txid], u[:vout], (u[:amount] * 1_0000_0000).to_i]
+    end
+  end
+
+  def list_transactions(txids)
+    return nil if txids.empty?
+    txids.collect do |txid|
+      tx = client.getrawtransaction(txid, 1)
+      inputs = tx[:vin].collect do |i|
+        { prev_hash: i[:txid],
+          prev_index: i[:vout],
+          sequence: i[:sequence],
+          script_sig: i[:scriptSig][:hex] 
+        }
+      end
+
+      outputs = tx[:vout].collect do |o|
+        { amount: (o[:value] * 1_0000_0000).to_i, script_pubkey: o[:scriptPubKey][:hex] }
+      end
+
+      { hash: tx[:txid], version: tx[:version], lock_time: tx[:locktime],
+        inputs: inputs, bin_outputs: outputs}
+    end
+  end
+
+  def block_height
+    client.getinfo[:blocks]
+  end
+end

data/lib/pochette/backends/trendy.rb

@@ -0,0 +1,92 @@
+# The Trendy backend delegates calls to Toshi or BitcoinCore backends
+# to list unspent outputs, incoming payments, etcetera.
+# It chooses the backend to use based on its latest block, trying
+# to always use the most up to date one.
+# Its public instance methods are the contract to be used by any
+# other backend, all Pochette backends must define
+# thes public methods (Except for the initializer).
+class Pochette::Backends::Trendy
+  def initialize(backends)
+    @backends = backends
+  end
+  
+  # Lists all bitcoins received by a list of addresses
+  # after a given date. Includes both confirmed and unconfirmed
+  # transactions, unconfirmed transactions have a nil block height.
+  # Returns a list of lists as following:
+  #   amount: Amount received (in satoshis)
+  #   address: Public address receiving the amount.
+  #   txid: The hash for the transaction that received it.
+  #   confirmations: Transaction confirmations
+  #   output position: To disambiguate in case address received more than once.
+  #   sender addresses: Comma separated list of input addresses,
+  #     used to identify deposits from trusted parties.
+  #     can be used to identify deposits from trusted parties.
+  def incoming_for(addresses, min_date)
+    backend.incoming_for(addresses, min_date)
+  end
+  
+  # Gets the total received, spent and balance for
+  # a list of addresses. Confirmed balances are enforced to have a number
+  # of confirmation, appearing in a block is not enough.
+  # Returns a hash with:
+  # { address: [received, sent, total,
+  #             unconfirmed_received, unconfirmed_sent, unconfirmed_total],
+  #   ...}
+  def balances_for(addresses, confirmations)
+    backend.balances_for(addresses, confirmations)
+  end
+
+  # Get unspent utxos for the given addresses,
+  # returns a list of lists like so:
+  # [[address, txid, position (vout), amount (in satoshis)], ...]
+  def list_unspent(addresses)
+    backend.list_unspent(addresses)
+  end
+
+  # Gets information for the given transactions
+  # returns a list of objects, like so:
+  # [
+  #   { hash: txid,
+  #     version: 1,
+  #     lock_time: 0,
+  #     inputs: [
+  #       { prev_hash: txid,
+  #         prev_index: 0,
+  #         sequence: 0,
+  #         script_sig: hex_signature
+  #       },
+  #       ...
+  #     ],
+  #     bin_outputs: [
+  #       { amount: amount (as satoshis),
+  #         script_pubkey: hex_script
+  #       },
+  #       ...
+  #     ]
+  #   }
+  def list_transactions(txids)
+    backend.list_transactions(txids)
+  end
+
+protected
+
+  # Chooses a backend to use, gives a small advantage to incumbent backend.
+  def backend
+    if @backend.nil?
+      @last_choice_on = Time.now
+      return @backend = @backends.sort_by(&:block_height).last
+    end
+
+    return @backend if @last_choice_on > 10.minutes.ago
+
+    @last_choice_on = Time.now
+    challenger, height = @backends
+      .reject{|b| b == @backend }
+      .collect{|b| [b, b.block_height] }
+      .sort_by(&:last)
+      .last
+
+    @backend = height > (@backend.block_height + 1) ? challenger : @backend
+  end
+end

data/lib/pochette/transaction_builder.rb

@@ -0,0 +1,157 @@
+# Builds transactions from a list of source addresses and a list of recipients.
+# Uses Pochette.backend to fetch unspent outputs and related transaction data.
+# Instantiating will perform all the given queries, you'll be left with a
+# TransactionBuilder object that is either valid? or not, and if valid
+# you can query the results via to_hash.
+# Options:
+#   addresses:
+#     List of addresses in wallet.
+#     We will be spending their unspent outputs.
+#   outputs:
+#     List of pairs [recipient_address, amount]
+#     This will not be all the final outputs in the transaction,
+#     as a 'change' output may be added if needed.
+#   utxo_blacklist:
+#     List of utxos to ignore, a list of pairs [transaction hash, position]
+#   change_address:
+#     Change address to use. Will default to the first source address.
+#   fee_per_kb:
+#     Defaults to 10000 satoshis.
+#   spend_all:
+#     Wether to spend all available utxos or just select enough to
+#     cover the given outputs.
+
+class Pochette::TransactionBuilder
+
+  cattr_accessor(:dust_size){ 546 }
+  cattr_accessor(:output_size){ 149 }
+  cattr_accessor(:input_size){ 35 }
+  cattr_accessor(:network_minimum_fee){ 10000 }
+  cattr_accessor(:default_fee_per_kb){ 10000 }
+
+  def initialize(options)
+    initialize_options(options)
+    return unless valid?
+    initialize_fee
+    initialize_outputs
+    return unless valid?
+    select_utxos
+    add_change_output
+    validate_final_amounts
+  end
+
+  def as_hash
+    return nil unless valid?
+    { amount: inputs_amount,
+      fee: inputs_amount - outputs_amount,
+      inputs: inputs,
+      outputs: outputs}
+  end
+
+  def valid?
+    errors.size == 0
+  end
+
+  attr_reader :errors
+
+protected
+
+  attr_accessor :options
+  attr_accessor :addresses
+  attr_accessor :inputs
+  attr_accessor :outputs
+  attr_writer :errors
+
+  def initialize_options(options)
+    self.options = options
+    self.errors ||= []
+    self.addresses = options[:addresses]
+    if addresses.nil? || addresses.empty?
+      return errors << :no_addresses_given
+    end
+  end
+
+  def initialize_fee
+    @minimum_fee = fee_for_bytes(10)
+  end
+
+  def add_input_fee(count = 1)
+    @minimum_fee += fee_for_bytes(input_size) * count
+  end
+
+  def add_output_fee(count = 1)
+    @minimum_fee += fee_for_bytes(output_size) * count
+  end
+
+  def minimum_fee(stage=0)
+    [@minimum_fee + stage, network_minimum_fee].max
+  end
+
+  def fee_for_bytes(bytes)
+    bytes.to_d / 1000.to_d * (options[:fee_per_kb] || default_fee_per_kb)
+  end
+
+  def initialize_outputs
+    self.outputs = options[:outputs]
+    if (outputs.nil? || outputs.empty?) && !options[:spend_all]
+      errors << :try_with_spend_all
+      return
+    end
+
+    add_output_fee(outputs.size)
+    if outputs.any?{|o| o[1] < dust_size }
+      errors << :dust_in_outputs
+    end
+  end
+
+  def select_utxos
+    utxo_blacklist = options[:utxo_blacklist] || []
+    all_utxos = Pochette.backend.list_unspent(addresses)
+    available_utxos = all_utxos.reject do |utxo|
+      utxo_blacklist.include?(utxo[1]) || utxo_is_blacklisted?(utxo)
+    end
+    
+    self.inputs = []
+    if options[:spend_all]
+      self.inputs = available_utxos
+      add_input_fee(inputs.size)
+    else
+      needed = outputs.collect{|o| o.last }.sum
+      collected = 0.to_d
+      available_utxos.each do |utxo|
+        break if collected >= needed + minimum_fee
+        collected += utxo[3]
+        self.inputs << utxo
+        add_input_fee
+      end
+    end
+  end
+
+  def add_change_output
+    change = inputs_amount - outputs_amount -
+      minimum_fee(fee_for_bytes(output_size))
+    change_address = options[:change_address] || addresses.first
+    if change > dust_size
+      outputs << [change_address, change]
+      add_output_fee
+    end
+  end
+
+  def inputs_amount
+    inputs.collect{|x| x[3] }.sum
+  end
+
+  def outputs_amount
+    outputs.collect(&:last).sum
+  end
+
+  def validate_final_amounts
+    if inputs_amount < (outputs_amount + minimum_fee)
+      errors << :insufficient_funds
+    end
+  end
+
+  def utxo_is_blacklisted?(utxo)
+    false
+  end
+end

data/lib/pochette/trezor_transaction_builder.rb

@@ -0,0 +1,90 @@
+# Same as TransactionBuilder but outputs a transaction hash with all the
+# required data to create and sign a transaction using a BitcoinTrezor.
+# * Uses BIP32 addresses instead of regular strings.
+#   Each address is represented as a pair, with the public address string
+#   and the BIP32 path as a list of integers, for example:
+#   ['public-address-as-string', [44, 1, 3, 11]]
+#
+# * Includes associated transaction data for each input being spent,
+#   ready to be consumed by your Trezor device.
+#
+# * Outputs are represented as JSON with script_type as expected by Trezor.
+#   { script_type: 'PAYTOADDRESS',
+#     address: '1address-as-string',
+#     amount: amount_in_satoshis }
+#
+# Options:
+#   bip32_addresses:
+#     List of [address, path] pairs in wallet.
+#     We will be spending their unspent outputs.
+#   outputs:
+#     List of pairs [recipient_address, amount]
+#     This will not be all the final outputs in the transaction,
+#     as a 'change' output may be added if needed.
+#   utxo_blacklist:
+#     List of utxos to ignore, a list of pairs [transaction hash, position]
+#   change_address:
+#     Change address to use. Will default to the first source address.
+#   fee_per_kb:
+#     Defaults to 10000 satoshis.
+#   spend_all:
+#     Wether to spend all available utxos or just select enough to
+#     cover the given outputs.
+
+class Pochette::TrezorTransactionBuilder < Pochette::TransactionBuilder
+  def initialize(options)
+    options = options.dup
+    initialize_bip32_addresses(options)
+    super(options)
+    return unless valid?
+    build_trezor_inputs
+    build_trezor_outputs
+    build_transactions
+  end
+
+  def as_hash
+    return nil unless valid?
+    { amount: inputs_amount,
+      fee: inputs_amount - outputs_amount,
+      inputs: trezor_inputs,
+      outputs: trezor_outputs,
+      transactions: transactions}
+  end
+
+protected
+  attr_accessor :trezor_outputs
+  attr_accessor :trezor_inputs
+  attr_accessor :transactions
+  attr_accessor :bip32_address_lookup
+
+  def initialize_bip32_addresses(options)
+    if options[:bip32_addresses].blank?
+      self.errors = [:no_bip32_addresses_given]
+      return
+    end
+    options[:addresses] = options[:bip32_addresses].collect(&:first)
+    self.bip32_address_lookup = options[:bip32_addresses].reduce({}) do |accum, addr|
+      accum[addr.first] = addr.last
+      accum
+    end
+  end
+
+  def build_trezor_inputs
+    self.trezor_inputs = inputs.collect do |input|
+      { address_n: bip32_address_lookup[input[0]],
+        prev_hash: input[1], prev_index: input[2] }
+    end
+  end
+
+  def build_trezor_outputs
+    self.trezor_outputs = outputs.collect do |address, amount|
+      type = Bitcoin.address_type(address) == :hash160 ? 'PAYTOADDRESS' : 'PAYTOSCRIPTHASH'
+      { script_type: type, address: address, amount: amount }
+    end
+  end
+
+  def build_transactions
+    txids = inputs.collect{|i| i[1] }
+    self.transactions = Pochette.backend.list_transactions(txids)
+  end
+end

data/lib/pochette/version.rb

@@ -0,0 +1,3 @@
+module Pochette
+  VERSION = "0.1.0"
+end

data/lib/pochette.rb

@@ -0,0 +1,17 @@
+require "pochette/version"
+require "bitcoin_rpc"
+require "active_support"
+require "active_support/core_ext"
+require "bitcoin"
+
+module Pochette
+  mattr_accessor :backend
+
+  module Backends
+  end
+end
+
+require "pochette/backends/bitcoin_core"
+require "pochette/backends/trendy"
+require "pochette/transaction_builder"
+require "pochette/trezor_transaction_builder"

data/pochette.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pochette/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pochette"
+  spec.version       = Pochette::VERSION
+  spec.authors       = ["Nubis", "Eromirou"]
+  spec.email         = ["nb@bitex.la", "tr@bitex.la"]
+
+  spec.summary       = %q{Pochette is a Bitcoin Wallet for developers}
+  spec.description   = %q{Pochette is a Bitcoin Wallet backend offering a common
+    interface to several bitcoin nodes so you can build single purpose wallets.
+    You can pass in a bunch of addresses and outputs and it will select the
+    appropriate unspent outputs for each of them, calculate change, fees, etc.
+    }
+  spec.homepage      = "http://github.com/bitex-la/pochette"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency "activesupport", "~> 4.2"
+  spec.add_dependency "bitcoin_rpc", "~> 0.1.1"
+  spec.add_dependency "bitcoin-ruby", "~> 0.0.7"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3"
+  spec.add_development_dependency "webmock", "~> 1.21"
+  spec.add_development_dependency "timecop", "~> 0.8.0"
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: pochette
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nubis
+- Eromirou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bitcoin_rpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: bitcoin-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: "Pochette is a Bitcoin Wallet backend offering a common\n    interface
+  to several bitcoin nodes so you can build single purpose wallets.\n    You can pass
+  in a bunch of addresses and outputs and it will select the\n    appropriate unspent
+  outputs for each of them, calculate change, fees, etc.\n    "
+email:
+- nb@bitex.la
+- tr@bitex.la
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/pochette.rb
+- lib/pochette/backends/bitcoin_core.rb
+- lib/pochette/backends/trendy.rb
+- lib/pochette/transaction_builder.rb
+- lib/pochette/trezor_transaction_builder.rb
+- lib/pochette/version.rb
+- pochette.gemspec
+homepage: http://github.com/bitex-la/pochette
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Pochette is a Bitcoin Wallet for developers
+test_files: []