straight 0.1.0

data/lib/straight/gateway.rb

@@ -0,0 +1,182 @@
+module Straight
+
+  # This module should be included into your own class to extend it with Gateway functionality.
+  # For example, if you have a ActiveRecord model called Gateway, you can include GatewayModule into it
+  # and you'll now be able to do everything Straight::Gateway can do, but you'll also get AR Database storage
+  # funcionality, its validations etc.
+  #
+  # The right way to implement this would be to do it the other way: inherit from Straight::Gateway, 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::Gateway class and simply create new instances of it.
+  # However, if you are contributing to the library, all new funcionality should go to either Straight::GatewayModule::Includable or
+  # Straight::GatewayModule::Prependable (most likely the former).
+  module GatewayModule
+
+    # Only add getters and setters for those properties in the extended class
+    # that don't already have them. This is very useful with ActiveRecord for example
+    # where we don't want to override AR getters and setters that set attributes.
+    def self.included(base)
+      base.class_eval do
+        [
+          :pubkey,
+          :confirmations_required,
+          :status_check_schedule,
+          :blockchain_adapters,
+          :exchange_rate_adapters,
+          :order_callbacks,
+          :order_class,
+          :default_currency,
+          :name
+        ].each do |field|
+          attr_reader field unless base.method_defined?(field)
+          attr_writer field unless base.method_defined?("#{field}=")
+          prepend Prependable
+          include Includable
+        end
+      end
+    end
+
+    # Determines the algorithm for consequitive checks of the order status.
+    DEFAULT_STATUS_CHECK_SCHEDULE = -> (period, iteration_index) do
+      return false if period > 640
+      iteration_index += 1
+      if iteration_index > 5
+        period          *= 2
+        iteration_index  = 0
+      end
+      return { period: period, iteration_index: iteration_index }
+    end
+
+    # If you are defining methods in this module, it means you most likely want to
+    # call super() somehwere inside those methods.
+    #
+    # In short, the idea is to let the class we're being prepended to do its magic
+    # after out methods are finished.
+    module Prependable
+    end
+
+    module Includable
+
+      # Creates a new order for the address derived from the pubkey and the keychain_id argument provided.
+      # See explanation of this keychain_id argument is in the description for the #address_for_keychain_id method.
+      def order_for_keychain_id(amount:, keychain_id:, currency: nil, btc_denomination: :satoshi)
+
+        amount = amount_from_exchange_rate(
+          amount,
+          currency:         currency,
+          btc_denomination: btc_denomination
+        )
+
+        order             = Kernel.const_get(order_class).new
+        order.amount      = amount
+        order.gateway     = self
+        order.address     = address_for_keychain_id(keychain_id)
+        order.keychain_id = keychain_id
+        order
+      end
+
+      # Returns a Base58-encoded Bitcoin address to which the payment transaction
+      # is expected to arrive. id is an an integer > 0 (hopefully not too large and hopefully
+      # the one a user of this class is going to properly increment) that is used to generate a
+      # an BIP32 bitcoin address deterministically.
+      def address_for_keychain_id(id)
+        keychain.node_for_path(id.to_s).to_address
+      end
+      
+      def fetch_transaction(tid, address: nil)
+        try_adapters(@blockchain_adapters) { |b| b.fetch_transaction(tid, address: address) }
+      end
+      
+      def fetch_transactions_for(address)
+        try_adapters(@blockchain_adapters) { |b| b.fetch_transactions_for(address) }
+      end
+      
+      def fetch_balance_for(address)
+        try_adapters(@blockchain_adapters) { |b| b.fetch_balance_for(address) }
+      end
+
+      def keychain
+        @keychain ||= MoneyTree::Node.from_serialized_address(@pubkey)
+      end
+
+      # This is a callback method called from each order
+      # whenever an order status changes.
+      def order_status_changed(order)
+        @order_callbacks.each do |c|
+          c.call(order)
+        end
+      end
+
+      # Gets exchange rates from one of the exchange rate adapters,
+      # then calculates how much BTC does the amount in the given currency represents.
+      # 
+      # You can also feed this method various bitcoin denominations.
+      # It will always return amount in Satoshis.
+      def amount_from_exchange_rate(amount, currency:, btc_denomination: :satoshi)
+        currency         = self.default_currency if currency.nil?
+        btc_denomination = :satoshi              if btc_denomination.nil?
+        currency = currency.to_s.upcase
+        if currency == 'BTC'
+          return Satoshi.new(amount, from_unit: btc_denomination).to_i
+        end
+
+        try_adapters(@exchange_rate_adapters) do |a|
+          a.convert_from_currency(amount, currency: currency)
+        end
+      end
+
+      private
+        
+        # Calls the block with each adapter until one of them does not fail.
+        # Fails with the last exception.
+        def try_adapters(adapters, &block)
+          last_exception = nil
+          adapters.each do |adapter|
+            begin
+              result = yield(adapter)
+              last_exception = nil
+              return result
+            rescue Exception => e
+              last_exception = e
+              # If an Exception is raised, it passes on
+              # to the next adapter and attempts to call a method on it.
+            end
+          end
+          raise last_exception if last_exception
+        end
+
+    end
+
+  end
+
+
+  class Gateway
+
+    include GatewayModule
+
+    def initialize
+      @default_currency = 'BTC'
+      @blockchain_adapters = [
+        Blockchain::BlockchainInfoAdapter.mainnet_adapter,
+        Blockchain::HelloblockIoAdapter.mainnet_adapter
+      ]
+      @exchange_rate_adapters = [
+        ExchangeRate::BitpayAdapter.new,
+        ExchangeRate::CoinbaseAdapter.new,
+        ExchangeRate::BitstampAdapter.new
+      ]
+      @status_check_schedule = DEFAULT_STATUS_CHECK_SCHEDULE
+    end
+
+    def order_class
+      "Straight::Order"
+    end
+
+  end
+
+end

data/lib/straight/order.rb

@@ -0,0 +1,195 @@
+module Straight
+
+  # This module should be included into your own class to extend it with Order functionality.
+  # For example, if you have a ActiveRecord model called Order, you can include OrderModule into it
+  # and you'll now be able to do everything to check order's status, but you'll also get AR Database storage
+  # funcionality, its validations etc.
+  #
+  # 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 funcionality should go to either Straight::OrderModule::Includable or
+  # Straight::OrderModule::Prependable (most likely the former).
+  module OrderModule
+
+    # Only add getters and setters for those properties in the extended class
+    # that don't already have them. This is very useful with ActiveRecord for example
+    # where we don't want to override AR getters and setters that set attribtues.
+    def self.included(base)
+      base.class_eval do
+        [:amount, :address, :gateway, :keychain_id, :status, :tid].each do |field|
+          attr_reader field unless base.method_defined?(field)
+          attr_writer field unless base.method_defined?("#{field}=")
+        end
+        prepend Prependable
+        include Includable
+      end
+    end
+
+    # Worth noting that statuses above 1 are immutable. That is, an order status cannot be changed
+    # if it is more than 1. It makes sense because if an order is paid (5) or expired (2), nothing
+    # else should be able to change the status back. Similarly, if an order is overpaid (4) or
+    # underpaid (5), it requires admin supervision and possibly a new order to be created.
+    STATUSES = {
+      new:          0, # no transactions received
+      unconfirmed:  1, # transaction has been received doesn't have enough confirmations yet
+      paid:         2, # transaction received with enough confirmations and the correct amount
+      underpaid:    3, # amount that was received in a transaction was not enough
+      overpaid:     4, # amount that was received in a transaction was too large
+      expired:      5  # too much time passed since creating an order
+    }
+
+    class IncorrectAmount < Exception; end
+
+    # If you are defining methods in this module, it means you most likely want to
+    # call super() somehwere inside those methods. An example would be the #status=
+    # setter. We do our thing, then call super() so that the class this module is prepended to
+    # could do its thing. For instance, if we included it into ActiveRecord, then after
+    # #status= is executed, it would call ActiveRecord model setter #status=
+    #
+    # In short, the idea is to let the class we're being prepended to do its magic
+    # after out methods are finished.
+    module Prependable
+
+      # Checks #transaction and returns one of the STATUSES based
+      # on the meaning of each status and the contents of transaction
+      # If as_sym is set to true, then each status is returned as Symbol, otherwise
+      # an equivalent Integer from STATUSES is returned.
+      def status(as_sym: false, reload: false)
+        @status = super() if defined?(super)
+        # Prohibit status update if the order was paid in some way.
+        # This is just a caching workaround so we don't query
+        # the blockchain needlessly. The actual safety switch is in the setter.
+        # Therefore, even if you remove the following line, status won't actually
+        # be allowed to change.
+        return @status if @status && @status > 1 
+
+        if reload || !@status
+          t = transaction(reload: reload)
+          self.status = if t.nil?
+            STATUSES[:new]
+          else
+            if t[:confirmations] >= gateway.confirmations_required
+              if t[:total_amount] == amount
+                STATUSES[:paid]
+              elsif t[:total_amount] < amount
+                STATUSES[:underpaid]
+              else
+                STATUSES[:overpaid]
+              end
+            else
+              STATUSES[:unconfirmed]
+            end
+          end
+        end
+        as_sym ? STATUSES.invert[@status] : @status 
+      end
+
+      def status=(new_status)
+        # Prohibit status update if the order was paid in some way,
+        # so statuses above 1 are in fact immutable.
+        return false if @status && @status > 1
+
+        self.tid = transaction[:tid] if transaction
+        
+        # Pay special attention to the order of these statements. If you place
+        # the assignment @status = new_status below the callback call,
+        # you may get a "Stack level too deep" error if the callback checks
+        # for the status and it's nil (therefore, force reload and the cycle continues).
+        # 
+        # The order in which these statements currently are prevents that error, because
+        # by the time a callback checks the status it's already set.
+        @status_changed = (@status != new_status)
+        @status         = new_status
+        gateway.order_status_changed(self) if @status_changed
+        super if defined?(super)
+      end
+
+    end
+
+    module Includable
+
+      # Returns an array of transactions for the order's address, each as a hash:
+      #   [ {tid: "feba9e7bfea...", amount: 1202000, ...} ]
+      #
+      # An order is supposed to have only one transaction to its address, but we cannot
+      # always guarantee that (especially when a merchant decides to reuse the address
+      # for some reason -- he shouldn't but you know people).
+      #
+      # Therefore, this method returns all of the transactions.
+      # For compliance, there's also a #transaction method which always returns
+      # the last transaction made to the address.
+      def transactions(reload: false)
+        @transactions = gateway.fetch_transactions_for(address) if reload || !@transactions
+        @transactions
+      end
+
+      # Last transaction made to the address. Always use this method to check whether a transaction
+      # for this order has arrived. We pick last and not first because an address may be reused and we
+      # always assume it's the last transaction that we want to check.
+      def transaction(reload: false)
+        transactions(reload: reload).first
+      end
+
+      # Starts a loop which calls #status(reload: true) according to the schedule
+      # determined in @status_check_schedule. This method is supposed to be
+      # called in a separate thread, for example:
+      #
+      #   Thread.new do
+      #     order.start_periodic_status_check
+      #   end
+      #
+      def start_periodic_status_check
+        check_status_on_schedule
+      end
+      
+      # Recursion here! Keeps calling itself according to the schedule until
+      # either the status changes or the schedule tells it to stop.
+      def check_status_on_schedule(period: 10, iteration_index: 0)
+        self.status(reload: true)
+        schedule = gateway.status_check_schedule.call(period, iteration_index)
+        if schedule && self.status < 2 # Stop checking if status is >= 2
+          sleep period
+          check_status_on_schedule(
+            period:          schedule[:period],
+            iteration_index: schedule[:iteration_index]
+          )
+        else
+          self.status = STATUSES[:expired]
+        end
+      end
+
+      def to_json
+        to_h.to_json
+      end
+
+      def to_h
+        { status: status, amount: amount, address: address, tid: tid }
+      end
+
+    end
+
+  end
+
+  # Instances of this class are generated when we'd like to start watching
+  # some addresses to check whether a transaction containing a certain amount
+  # has arrived to it.
+  #
+  # It is worth noting that instances do not know how store themselves anywhere,
+  # so as the class is written here, those instances are only supposed to exist
+  # in memory. Storing orders is entirely up to you.
+  class Order
+    include OrderModule
+
+    def initialize
+      @status = 0
+    end
+
+  end
+
+end

data/lib/straight.rb

@@ -0,0 +1,18 @@
+require 'money-tree'
+require 'satoshi-unit'
+require 'json'
+require 'uri'
+require 'open-uri'
+require 'yaml'
+
+require_relative 'straight/blockchain_adapter'
+require_relative 'straight/blockchain_adapters/blockchain_info_adapter'
+require_relative 'straight/blockchain_adapters/helloblock_io_adapter'
+
+require_relative 'straight/exchange_rate_adapter'
+require_relative 'straight/exchange_rate_adapters/bitpay_adapter'
+require_relative 'straight/exchange_rate_adapters/coinbase_adapter'
+require_relative 'straight/exchange_rate_adapters/bitstamp_adapter'
+
+require_relative 'straight/order'
+require_relative 'straight/gateway'

data/spec/lib/blockchain_adapters/blockchain_info_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+RSpec.describe Straight::Blockchain::BlockchainInfoAdapter do
+
+  subject(:adapter) { Straight::Blockchain::BlockchainInfoAdapter.mainnet_adapter }
+
+  it "fetches all transactions for the current address" do
+    address = "3B1QZ8FpAaHBgkSB5gFt76ag5AW9VeP8xp"
+    expect(adapter).to receive(:straighten_transaction).with(anything, address: address).at_least(:once)
+    expect(adapter.fetch_transactions_for(address)).not_to be_empty
+  end
+
+  it "fetches the balance for a given address" do
+    address = "3B1QZ8FpAaHBgkSB5gFt76ag5AW9VeP8xp"
+    expect(adapter.fetch_balance_for(address)).to be_kind_of(Integer)
+  end
+
+  it "fetches a single transaction" do
+    tid = 'ae0d040f48d75fdc46d9035236a1782164857d6f0cca1f864640281115898560'
+    expect(adapter.fetch_transaction(tid)[:total_amount]).to eq(832947)
+  end
+
+  it "calculates the number of confirmations for each transaction" do
+    tid = 'ae0d040f48d75fdc46d9035236a1782164857d6f0cca1f864640281115898560'
+    expect(adapter.fetch_transaction(tid)[:confirmations]).to be > 0
+  end
+
+  it "gets a transaction id among other data" do
+    tid = 'ae0d040f48d75fdc46d9035236a1782164857d6f0cca1f864640281115898560'
+    expect(adapter.fetch_transaction(tid)[:tid]).to eq(tid)
+  end
+
+  it "caches blockchain.info latestblock requests" do
+    expect(adapter).to receive(:http_request).once.and_return('{ "height": 1 }')
+    adapter.send(:calculate_confirmations, { "block_height" => 1 }, force_latest_block_reload: true)
+    adapter.send(:calculate_confirmations, { "block_height" => 1 })
+    adapter.send(:calculate_confirmations, { "block_height" => 1 })
+    adapter.send(:calculate_confirmations, { "block_height" => 1 })
+    adapter.send(:calculate_confirmations, { "block_height" => 1 })
+  end
+  
+  it "raises an exception when something goes wrong with fetching datd" do
+    allow_any_instance_of(URI).to receive(:read).and_raise(OpenURI::HTTPError)
+    expect( -> { adapter.http_request("http://blockchain.info/a-timed-out-request") }).to raise_error(Straight::Blockchain::Adapter::RequestError)
+  end
+
+  it "calculates total_amount of a transaction for the given address only" do
+    t = { 'out' => [{ 'value' => 1, 'addr' => 'address1'}, { 'value' => 1, 'addr' => 'address2'}] }
+    expect(adapter.send(:straighten_transaction, t, address: 'address1')[:total_amount]).to eq(1)
+  end
+
+end

data/spec/lib/blockchain_adapters/helloblock_io_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe Straight::Blockchain::HelloblockIoAdapter do
+
+  subject(:adapter) { Straight::Blockchain::HelloblockIoAdapter.mainnet_adapter }
+
+  it "fetches all transactions for the current address" do
+    address = "3B1QZ8FpAaHBgkSB5gFt76ag5AW9VeP8xp"
+    expect(adapter).to receive(:straighten_transaction).with(anything, address: address).at_least(:once)
+    expect(adapter.fetch_transactions_for(address)).not_to be_empty
+  end
+
+  it "fetches the balance for a given address" do
+    address = "3B1QZ8FpAaHBgkSB5gFt76ag5AW9VeP8xp"
+    expect(adapter.fetch_balance_for(address)).to be_kind_of(Integer)
+  end
+
+  it "fetches a single transaction" do
+    tid = 'ae0d040f48d75fdc46d9035236a1782164857d6f0cca1f864640281115898560'
+    expect(adapter.fetch_transaction(tid)[:total_amount]).to eq(832947)
+  end
+
+  it "gets a transaction id among other data" do
+    tid = 'ae0d040f48d75fdc46d9035236a1782164857d6f0cca1f864640281115898560'
+    expect(adapter.fetch_transaction(tid)[:tid]).to eq(tid)
+  end
+
+  it "returns the number of confirmations for a transaction" do
+    tid = 'ae0d040f48d75fdc46d9035236a1782164857d6f0cca1f864640281115898560'
+    expect(adapter.fetch_transaction(tid)[:confirmations]).to be > 0
+  end
+
+  it "raises an exception when something goes wrong with fetching datd" do
+    allow_any_instance_of(URI).to receive(:read).and_raise(OpenURI::HTTPError)
+    expect( -> { adapter.http_request("http://blockchain.info/a-timed-out-request") }).to raise_error(Straight::Blockchain::Adapter::RequestError)
+  end
+
+  it "calculates total_amount of a transaction for the given address only" do
+    t = { 'outputs' => [{ 'value' => 1, 'address' => 'address1'}, { 'value' => 1, 'address' => 'address2'}] }
+    expect(adapter.send(:straighten_transaction, t, address: 'address1')[:total_amount]).to eq(1)
+  end
+
+end

data/spec/lib/exchange_rate_adapter_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe Straight::ExchangeRate::Adapter do
+
+  class Straight::ExchangeRate::Adapter
+    FETCH_URL = ''
+  end
+
+  before(:each) do
+    @exchange_adapter = Straight::ExchangeRate::Adapter.new
+  end
+
+  describe "converting currencies" do
+
+    before(:each) do
+      allow(@exchange_adapter).to receive(:fetch_rates!)
+      allow(@exchange_adapter).to receive(:rate_for).with('USD').and_return(450.5412)
+    end
+
+    it "converts amount from currency into BTC" do
+      expect(@exchange_adapter.convert_from_currency(2252.706, currency: 'USD')).to eq(500000000)
+    end
+
+    it "converts from btc into currency" do
+      expect(@exchange_adapter.convert_to_currency(500000000, currency: 'USD')).to eq(2252.706)
+    end
+
+    it "shows btc amounts in various denominations" do
+      expect(@exchange_adapter.convert_from_currency(2252.706, currency: 'USD', btc_denomination: :btc)).to eq(5)
+      expect(@exchange_adapter.convert_to_currency(5, currency: 'USD', btc_denomination: :btc)).to eq(2252.706)
+    end
+
+    it "accepts string as amount and converts it properly" do
+      expect(@exchange_adapter.convert_from_currency('2252.706', currency: 'USD', btc_denomination: :btc)).to eq(5)
+      expect(@exchange_adapter.convert_to_currency('5', currency: 'USD', btc_denomination: :btc)).to eq(2252.706)
+    end
+
+  end
+
+  it "when checking for rates, only calls fetch_rates! if they were checked long time ago or never" do
+    uri_mock = double('uri mock')
+    expect(URI).to      receive(:parse).and_return(uri_mock).twice
+    expect(uri_mock).to receive(:read).and_return('{ "USD": 534.4343 }').twice
+    @exchange_adapter.rate_for('USD')
+    @exchange_adapter.rate_for('USD') # not calling fetch_rates! because we've just checked
+    @exchange_adapter.instance_variable_set(:@rates_updated_at, Time.now-1900)
+    @exchange_adapter.rate_for('USD')
+  end
+
+end

data/spec/lib/exchange_rate_adapters/bitpay_adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe Straight::ExchangeRate::BitpayAdapter do
+
+  before(:each) do
+    @exchange_adapter = Straight::ExchangeRate::BitpayAdapter.new
+  end
+
+  it "finds the rate for currency code" do
+    expect(@exchange_adapter.rate_for('USD')).to be_kind_of(Float)
+    expect( -> { @exchange_adapter.rate_for('FEDcoin') }).to raise_error(Straight::ExchangeRate::Adapter::CurrencyNotSupported)
+  end
+
+end

data/spec/lib/exchange_rate_adapters/bitstamp_adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe Straight::ExchangeRate::BitstampAdapter do
+
+  before(:each) do
+    @exchange_adapter = Straight::ExchangeRate::BitstampAdapter.new
+  end
+
+  it "finds the rate for currency code" do
+    expect(@exchange_adapter.rate_for('USD')).to be_kind_of(Float)
+    expect( -> { @exchange_adapter.rate_for('FEDcoin') }).to raise_error(Straight::ExchangeRate::Adapter::CurrencyNotSupported)
+  end
+
+end

data/spec/lib/exchange_rate_adapters/coinbase_adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe Straight::ExchangeRate::CoinbaseAdapter do
+
+  before(:each) do
+    @exchange_adapter = Straight::ExchangeRate::CoinbaseAdapter.new
+  end
+
+  it "finds the rate for currency code" do
+    expect(@exchange_adapter.rate_for('USD')).to be_kind_of(Float)
+    expect( -> { @exchange_adapter.rate_for('FEDcoin') }).to raise_error(Straight::ExchangeRate::Adapter::CurrencyNotSupported)
+  end
+
+end

data/spec/lib/gateway_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe Straight::Gateway do
+
+  before(:each) do
+    @mock_adapter                  = double("mock blockchain adapter")
+    @gateway                       = Straight::Gateway.new
+    @gateway.pubkey                = "pubkey"
+    @gateway.order_class           = "Straight::Order"
+    @gateway.blockchain_adapters   = [@mock_adapter]
+    @gateway.status_check_schedule = Straight::Gateway::DEFAULT_STATUS_CHECK_SCHEDULE
+    @gateway.order_callbacks       = []
+  end
+
+  it "passes methods on to the available adapter" do
+    @gateway.instance_variable_set('@blockchain_adapters', [@mock_adapter])
+    expect(@mock_adapter).to receive(:fetch_transaction).once 
+    @gateway.fetch_transaction("xxx")
+  end
+
+  it "uses the next availabale adapter when something goes wrong with the current one" do
+    another_mock_adapter = double("another_mock blockchain adapter")
+    @gateway.instance_variable_set('@blockchain_adapters', [@mock_adapter, another_mock_adapter])
+    allow(@mock_adapter).to receive(:fetch_transaction).once.and_raise(Exception) 
+    expect(another_mock_adapter).to receive(:fetch_transaction).once 
+    @gateway.fetch_transaction("xxx")
+  end
+
+  it "creates new orders and addresses for them" do
+    @gateway.pubkey   = MoneyTree::Master.new.to_serialized_address 
+    expected_address  = MoneyTree::Node.from_serialized_address(@gateway.pubkey).node_for_path("1").to_address
+    expect(@gateway.order_for_keychain_id(amount: 1, keychain_id: 1).address).to eq(expected_address)
+  end
+
+  it "calls all the order callbacks" do
+    callback1                = double('callback1')
+    callback2                = double('callback1')
+    @gateway.pubkey          = MoneyTree::Master.new.to_serialized_address
+    @gateway.order_callbacks = [callback1, callback2]
+
+    order = @gateway.order_for_keychain_id(amount: 1, keychain_id: 1)
+    expect(callback1).to receive(:call).with(order)
+    expect(callback2).to receive(:call).with(order)
+    @gateway.order_status_changed(order)
+  end
+
+  describe "exchange rate calculation" do
+
+    it "sets order amount in satoshis calculated from another currency" do
+      adapter = Straight::ExchangeRate::BitpayAdapter.new
+      allow(adapter).to receive(:rate_for).and_return(450.5412)
+      @gateway.exchange_rate_adapters = [adapter]
+      expect(@gateway.amount_from_exchange_rate(2252.706, currency: 'USD')).to eq(500000000)
+    end
+
+    it "tries various exchange adapters until one of them actually returns an exchange rate" do
+      adapter1 = Straight::ExchangeRate::BitpayAdapter.new
+      adapter2 = Straight::ExchangeRate::BitpayAdapter.new
+      allow(adapter1).to receive(:rate_for).and_return( -> { raise "connection problem" })
+      allow(adapter2).to receive(:rate_for).and_return(450.5412)
+      @gateway.exchange_rate_adapters = [adapter1, adapter2]
+      expect(@gateway.amount_from_exchange_rate(2252.706, currency: 'USD')).to eq(500000000)
+    end
+
+    it "converts btc denomination into satoshi if provided with :btc_denomination" do
+      expect(@gateway.amount_from_exchange_rate(5, currency: 'BTC', btc_denomination: :btc)).to eq(500000000)
+    end
+
+    it "accepts string as amount and converts it properly" do
+      expect(@gateway.amount_from_exchange_rate('0.5', currency: 'BTC', btc_denomination: :btc)).to eq(50000000)
+    end
+
+  end
+
+end