straight 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b001bb2871da76e4b657fc5d3e8812ee1e829f3
+  data.tar.gz: ff86dddd47ec116ee7f2f8de5c799aaedd872473
+SHA512:
+  metadata.gz: b5fc18e1b66e8c2548dc0d515374437f467ccb8821ae45228e562ad0676568ff3ee7fd30468e50302b7cd9d294b881766f83ce45349bae78337e986bbc83c8c2
+  data.tar.gz: b15b7209e215e81bfa18bb260ec358368640122d83718591b3b1a09cb409f056b52badae4a2506582f8477caeea174798978f25d473422254e8fdfce3b88f13e

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# Used to generate bip32 addresses
+gem 'money-tree'
+
+# Used in exchange rate adapters
+gem 'satoshi-unit'
+
+group :development do
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+  gem "github_api", "0.11.3"
+end
+
+group :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,76 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.6)
+    builder (3.2.2)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.2.5)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.9.3)
+    git (1.2.8)
+    github_api (0.11.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.1)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 1.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.0)
+      oauth2
+    hashie (3.3.1)
+    highline (1.6.21)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (1.0.0)
+    mini_portile (0.6.0)
+    money-tree (0.8.7)
+      ffi
+    multi_json (1.10.1)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.3.1)
+      mini_portile (= 0.6.0)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.3.2)
+    rdoc (4.1.2)
+      json (~> 1.4)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.2)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.0)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.0)
+    satoshi-unit (0.1.6)
+    thread_safe (0.3.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  github_api (= 0.11.3)
+  jeweler (~> 2.0.1)
+  money-tree
+  rspec
+  satoshi-unit

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Roman Snitko
+
+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,132 @@
+Straight
+========
+> Receive bitcoin payments directly into your wallet
+> Website: http://straight.romansnitko.com
+
+Straight is a built-in stateless gateway to receive bitcoin payments for 
+your online store. Drop in this library, set your public key and start receiving payments.
+Your BIP32-compatible wallet will see payments automatically without any need for integration
+with your database.
+
+Straight cares about security and privacy. No private keys are stored on the server,
+each order uses unique payment address. Straight notifies your application when payment is 
+confirmed so you can ship away.
+
+IMPORTANT: this is a gem, not a server. It has no state and is intended to use within
+an application, such as Ruby On Rails. Most likely, you want
+[straight-server](https://github.com/snitko/straight-server), it is a server,
+which holds the state of all orders for you and has a RESTful API you can use
+with any application written in in language or platform.
+
+Bitcoin donations are appreciated: 1D3PknG4Lw1gFuJ9SYenA7pboF9gtXtdcD 
+
+How it works
+------------
+1. Get a wallet that supports BIP32 keychains (e.g. bitWallet for iOS). 
+2. Create an "account" and export its root extended public key (looks like xpub572b9e85...).
+3. Install Straight via Gemfile into your Ruby application.
+4. Create new Gateway with `Straight::Gateway.new`, set its properties.
+5. Start creating bitcoin orders by calling `gateway.order_for_keychain_id(...)``
+6. Set callbacks to get notified when payment is confirmed.
+7. Your wallet automatically detects incoming funds. Profit!
+
+A little bit of explanation is due here. *Gateway* is a class, which instances are payment processors for
+each online store. That is, if you have 2 online stores, you'll probably want to have a Gateway for each.
+
+This is because each instance would have different properties specific for each store (see Usage section).
+For example, each gateway may have a different callback or a different number of transaction confirmations
+required to set the order status to PAID.
+
+A new *Order* is created when you would like to give your customer an address to pay for your product or service.
+It will track whether new transactions arrived at the address, check how much money was sent and change its status
+accordingly.
+
+Installation
+------------
+
+    gem install straight
+
+Usage
+-----
+
+    require 'straight'
+
+    # Create a new gateway first and configure all the settings
+    #
+    gateway = Gateway.new
+    gateway.pubkey                 = 'xpub12345'
+    gateway.confirmations_required = 0
+    gateway.order_class            = 'Straight::Order'
+    gateway.default_currency       = 'BTC'
+    gateway.name                   = 'my gateway'
+
+    # Set the callback for orders' status changes
+    #
+    gateway.order_callbacks = [
+      lambda { |order| puts "Order status changed to #{order.status}" }
+    ]
+
+    # Create a new order
+    #
+    # Remember you should always use a new, unique keychain_id, should preferably
+    # be consecutive.
+    #
+    order = gateway.order_for_keychain_id(amount: 1, keychain_id: 1)
+
+    # Start tracking the order
+    #
+    Thread.new { order.start_periodic_status_check }
+
+
+Including Straight::Module vs Using Straight::Order class
+---------------------------------------------------------
+As this library is intended to use within an application and is not a standalone software itself,
+I made a decision to provide a simple way to integrate it into existing ORMs. While there is currently
+no official documentation as to how integrate it into ActiveRecord, you should be able to easily do it
+like this:
+
+    class Order < ActiveRecord::Base
+      include Straight::OrderModule
+      ...
+    end
+
+Same goes for the `GatewayModule`. It works the same way with other ORMs, such as Sequel (on which
+StraightServer is built).
+
+The right way to implement this would be to do it the other way: inherit from `Straight::Order`, then
+include `ActiveRecord`, but at this point `ActiveRecord` doesn't work this way. Furthermore, some other libraries, like `Sequel`,
+also require you to inherit from them. Thus, the module.
+
+When this module is included, it doesn't actually *include* all the methods, some are prepended (see Ruby docs on #prepend).
+It is important specifically for getters and setters and as a general rule only getters and setters are prepended.
+
+If you don't want to bother yourself with modules, please use `Straight::Order` class and simply create new instances of it.
+However, if you are contributing to the library, all new functionality should go to either Straight::OrderModule::Includable or
+Straight::OrderModule::Prependable (most likely the former).
+
+
+Important Considerations
+------------------------
+There is no magical link between the wallet and your server. Server creates new addresses for each order
+based on sequential indexes. Your wallet scans blockchain generating the same sequential addresses too
+(using a sliding window of several addresses). In order for this to work, as you may have guessed already,
+all orders should be indexed sequentially, not randomly.
+
+Why can't we just derive new addresses from order UUID, or assign them to orders? The reason is that your
+wallet will have to integrate with your very own database and it may be enormously cumbersome to implement
+in a generic way. Alternative would be to create a wallet within Straight and make it generate and keep the
+private keys, but this would be highly insecure. Keys stored on popular hosting solutions would quickly invite 
+all sorts of attacks to get money from them.
+
+Requirements
+------------
+Ruby 2.1 or later.
+
+
+Credits
+-------
+Authors:
+[Roman Snitko](http://romansnitko.com) and
+[Oleg Andreev](http://oleganza.com)
+
+Licence: MIT (see the LICENCE file)

data/Rakefile

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "straight"
+  gem.homepage = "http://github.com/snitko/straight"
+  gem.license = "MIT"
+  gem.summary = %Q{An engine for the Straight payment gateway software}
+  gem.description = %Q{An engine for the Straight payment gateway software. Requires no state to be saved (that is, no storage or DB). Its responsibilities only include processing data coming from an actual gateway.}
+  gem.email = "roman.snitko@gmail.com"
+  gem.authors = ["Roman Snitko"]
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/straight/blockchain_adapter.rb

@@ -0,0 +1,49 @@
+module Straight
+
+  module Blockchain
+    # A base class, providing guidance for the interfaces of
+    # all blockchain adapters as well as supplying some useful methods.
+    class Adapter
+
+      # Raised when blockchain data cannot be retrived for any reason.
+      # We're not really intereste in the precise reason, although it is
+      # stored in the message.
+      class RequestError < Exception; end
+
+      # This method is a wrapper for creating an HTTP request
+      # to various services that ancestors of this class may use
+      # to retrieve blockchain data. Why do we need a wrapper?
+      # Because it respects timeouts.
+      def http_request(url)
+        uri = URI.parse(url)
+        begin
+          http = uri.read(read_timeout: 4)
+        rescue OpenURI::HTTPError => e
+          raise RequestError, YAML::dump(e)
+        end
+      end
+
+      def fetch_transaction(tid)
+        raise "Please implement #fetch_transaction in #{self.to_s}"
+      end
+
+      def fetch_transactions_for(address)
+        raise "Please implement #fetch_transactions_for in #{self.to_s}"
+      end
+
+      def fetch_balance_for(address)
+        raise "Please implement #fetch_balance_for in #{self.to_s}"
+      end
+
+      private
+
+        # Converts transaction info received from the source into the
+        # unified format expected by users of BlockchainAdapter instances.
+        def straighten_transaction(transaction)
+          raise "Please implement #straighten_transaction in #{self.to_s}"
+        end
+
+    end
+
+  end
+end

data/lib/straight/blockchain_adapters/blockchain_info_adapter.rb

@@ -0,0 +1,84 @@
+module Straight
+  module Blockchain
+
+    class BlockchainInfoAdapter < Adapter
+
+      def self.mainnet_adapter
+        self.new("http://blockchain.info")
+      end
+      
+      def self.testnet_adapter
+        raise "Not Supported Yet"
+      end
+      
+      def initialize(base_url)
+        @latest_block = { cache_timestamp: nil, block: nil }
+        @base_url = base_url
+      end
+
+      # Returns transaction info for the tid
+      def fetch_transaction(tid, address: nil)
+        straighten_transaction JSON.parse(http_request("#{@base_url}/rawtx/#{tid}"), address: address)
+      end
+
+      # Returns all transactions for the address
+      def fetch_transactions_for(address)
+        transactions = JSON.parse(http_request("#{@base_url}/rawaddr/#{address}"))['txs']
+        transactions.map { |t| straighten_transaction(t, address: address) }
+      end
+
+      # Returns the current balance of the address
+      def fetch_balance_for(address)
+        JSON.parse(http_request("#{@base_url}/rawaddr/#{address}"))['final_balance']
+      end
+
+      private
+
+        # Converts transaction info received from the source into the
+        # unified format expected by users of BlockchainAdapter instances.
+        def straighten_transaction(transaction, address: nil)
+          outs         = []
+          total_amount = 0
+          transaction['out'].each do |out|
+            total_amount += out['value'] if address.nil? || address == out['addr']
+            outs << { amount: out['value'], receiving_address: out['addr'] }
+          end
+
+          {
+            tid:           transaction['hash'],
+            total_amount:  total_amount,
+            confirmations: calculate_confirmations(transaction),
+            outs:          outs
+          }
+        end
+
+
+        # When we call #calculate_confirmations, it doesn't always make a new
+        # request to the blockchain API. Instead, it checks if cached_id matches the one in
+        # the hash. It's useful when we want to calculate confirmations for all transactions for
+        # a certain address without making any new requests to the Blockchain API.
+        def calculate_confirmations(transaction, force_latest_block_reload: false)
+
+          # If we checked Blockchain.info latest block data
+          # more than a minute ago, check again. Otherwise, use cached version.
+          if @latest_block[:cache_timestamp].nil?              ||
+             @latest_block[:cache_timestamp] < (Time.now - 60) ||
+             force_latest_block_reload
+            @latest_block = {
+              cache_timestamp: Time.now,
+              block: JSON.parse(http_request("#{@base_url}/latestblock"))
+            }
+          end
+
+          if transaction["block_height"]
+            @latest_block[:block]["height"] - transaction["block_height"] + 1
+          else
+            0
+          end
+
+        end
+
+    end
+
+  end
+end

data/lib/straight/blockchain_adapters/helloblock_io_adapter.rb

@@ -0,0 +1,53 @@
+module Straight
+  module Blockchain
+
+    class HelloblockIoAdapter < Adapter
+      
+      def self.mainnet_adapter
+        self.new("https://mainnet.helloblock.io/v1")
+      end
+      
+      def self.testnet_adapter
+        raise "Not Supported Yet"
+      end
+      
+      def initialize(base_url)
+        @base_url = base_url
+      end
+      
+      # Returns transaction info for the tid
+      def fetch_transaction(tid, address: nil)
+        straighten_transaction JSON.parse(http_request("#{@base_url}/transactions/#{tid}"))['data']['transaction'], address: address
+      end
+
+      # Returns all transactions for the address
+      def fetch_transactions_for(address)
+        transactions = JSON.parse(http_request("#{@base_url}/addresses/#{address}/transactions"))['data']['transactions']
+        transactions.map { |t| straighten_transaction(t, address: address) }
+      end
+
+      # Returns the current balance of the address
+      def fetch_balance_for(address)
+        JSON.parse(http_request("#{@base_url}/addresses/#{address}"))['data']['address']['balance']
+      end
+
+      private
+
+        # Converts transaction info received from the source into the
+        # unified format expected by users of BlockchainAdapter instances.
+        def straighten_transaction(transaction, address: nil)
+          outs = transaction['outputs'].map do |out| 
+            { amount: out['value'], receiving_address: out['address'] } if address.nil? || address == out['address']
+          end.compact
+          {
+            tid:           transaction['txHash'],
+            total_amount:  outs.inject(0) { |sum, o| sum + o[:amount] },
+            confirmations: transaction['confirmations'],
+            outs:          outs
+          }
+        end
+
+    end
+
+  end
+end

data/lib/straight/exchange_rate_adapter.rb

@@ -0,0 +1,45 @@
+module Straight
+  module ExchangeRate
+
+    class Adapter
+
+      class CurrencyNotFound     < Exception; end
+      class FetchingFailed       < Exception; end
+      class CurrencyNotSupported < Exception; end
+
+      def initialize(rates_expire_in: 1800)
+        @rates_expire_in = rates_expire_in # in seconds
+      end
+
+      def convert_from_currency(amount_in_currency, btc_denomination: :satoshi, currency: 'USD')
+        btc_amount = amount_in_currency.to_f/rate_for(currency)
+        Satoshi.new(btc_amount, from_unit: :btc, to_unit: btc_denomination).to_unit
+      end
+
+      def convert_to_currency(amount, btc_denomination: :satoshi, currency: 'USD')
+        amount_in_btc = Satoshi.new(amount.to_f, from_unit: btc_denomination).to_btc
+        amount_in_btc*rate_for(currency)
+      end
+
+      def fetch_rates!
+        raise "FETCH_URL is not defined!" unless self.class::FETCH_URL
+        uri = URI.parse(self.class::FETCH_URL)
+        begin
+          @rates            = JSON.parse(uri.read(read_timeout: 4))
+          @rates_updated_at = Time.now
+        rescue OpenURI::HTTPError => e
+          raise FetchingFailed
+        end
+      end
+
+      def rate_for(currency_code)
+        if !@rates_updated_at || (Time.now - @rates_updated_at) > @rates_expire_in
+          fetch_rates!
+        end
+        nil # this should be changed in descendant classes
+      end
+
+    end
+
+  end
+end

data/lib/straight/exchange_rate_adapters/bitpay_adapter.rb

@@ -0,0 +1,19 @@
+module Straight
+  module ExchangeRate
+
+    class BitpayAdapter < Adapter
+      
+      FETCH_URL = 'https://bitpay.com/api/rates'
+
+      def rate_for(currency_code)
+        super
+        @rates.each do |r|
+          return r['rate'].to_f if r['code'] == currency_code
+        end
+        raise CurrencyNotSupported 
+      end
+
+    end
+
+  end
+end

data/lib/straight/exchange_rate_adapters/bitstamp_adapter.rb

@@ -0,0 +1,17 @@
+module Straight
+  module ExchangeRate
+
+    class BitstampAdapter < Adapter
+      
+      FETCH_URL = 'https://www.bitstamp.net/api/ticker/'
+
+      def rate_for(currency_code)
+        super
+        raise CurrencyNotSupported if currency_code != 'USD'
+        @rates['last'].to_f
+      end
+
+    end
+
+  end
+end

data/lib/straight/exchange_rate_adapters/coinbase_adapter.rb

@@ -0,0 +1,19 @@
+module Straight
+  module ExchangeRate
+
+    class CoinbaseAdapter < Adapter
+      
+      FETCH_URL = 'https://coinbase.com/api/v1/currencies/exchange_rates'
+
+      def rate_for(currency_code)
+        super
+        if rate = @rates["btc_to_#{currency_code.downcase}"]
+          return rate.to_f
+        end
+        raise CurrencyNotSupported 
+      end
+
+    end
+
+  end
+end