cryptocoin_payable 1.0.0

data/lib/cryptocoin_payable/adapters/bitcoin.rb

@@ -0,0 +1,93 @@
+module CryptocoinPayable
+  module Adapters
+    class Bitcoin < Base
+      # Satoshi in Bitcoin
+      def self.subunit_in_main
+        100_000_000
+      end
+
+      def self.coin_symbol
+        'BTC'
+      end
+
+      def fetch_transactions(address)
+        fetch_block_explorer_transactions(address)
+      rescue StandardError
+        fetch_block_cypher_transactions(address)
+      end
+
+      def create_address(id)
+        super.to_address(network: network)
+      end
+
+      private
+
+      def prefix
+        CryptocoinPayable.configuration.testnet ? 'testnet.' : ''
+      end
+
+      def network
+        CryptocoinPayable.configuration.testnet ? :bitcoin_testnet : :bitcoin
+      end
+
+      def parse_total_tx_value_block_explorer(output_transactions, address)
+        output_transactions
+          .select { |out| out['scriptPubKey']['addresses'].try('include?', address) }
+          .sum { |out| (out['value'].to_f * self.class.subunit_in_main).to_i }
+      end
+
+      def fetch_block_explorer_transactions(address)
+        url = "https://#{prefix}blockexplorer.com/api/txs/?address=#{address}"
+        parse_block_explorer_transactions(get_request(url).body, address)
+      end
+
+      def parse_block_explorer_transactions(response, address)
+        json = JSON.parse(response)
+        json['txs'].map { |tx| convert_block_explorer_transactions(tx, address) }
+      rescue JSON::ParserError
+        raise ApiError, response
+      end
+
+      def convert_block_explorer_transactions(transaction, address)
+        {
+          tx_hash: transaction['txid'],
+          block_hash: transaction['blockhash'],
+          block_time: transaction['blocktime'].nil? ? nil : parse_timestamp(transaction['blocktime']),
+          estimated_tx_time: parse_timestamp(transaction['time']),
+          estimated_tx_value: parse_total_tx_value_block_explorer(transaction['vout'], address),
+          confirmations: transaction['confirmations']
+        }
+      end
+
+      def parse_total_tx_value_block_cypher(output_transactions, address)
+        output_transactions
+          .sum { |out| out['addresses'].join.eql?(address) ? out['value'] : 0 }
+      end
+
+      def fetch_block_cypher_transactions(address)
+        url = "https://api.blockcypher.com/v1/btc/main/addrs/#{address}/full"
+        parse_block_cypher_transactions(get_request(url).body, address)
+      end
+
+      def parse_block_cypher_transactions(response, address)
+        json = JSON.parse(response)
+        raise ApiError, json['error'] if json['error']
+
+        json['txs'].map { |tx| convert_block_cypher_transactions(tx, address) }
+      rescue JSON::ParserError
+        raise ApiError, response
+      end
+
+      def convert_block_cypher_transactions(transaction, address)
+        {
+          tx_hash: transaction['hash'],
+          block_hash: transaction['block_hash'],
+          block_time: parse_time(transaction['confirmed']),
+          estimated_tx_time: parse_time(transaction['received']),
+          estimated_tx_value: parse_total_tx_value_block_cypher(transaction['outputs'], address),
+          confirmations: transaction['confirmations'].to_i
+        }
+      end
+    end
+  end
+end

data/lib/cryptocoin_payable/adapters/bitcoin_cash.rb

@@ -0,0 +1,34 @@
+require 'cash_addr'
+
+module CryptocoinPayable
+  module Adapters
+    class BitcoinCash < Bitcoin
+      def self.coin_symbol
+        'BCH'
+      end
+
+      def fetch_transactions(address)
+        raise NetworkNotSupported if CryptocoinPayable.configuration.testnet
+
+        url = "https://#{prefix}blockexplorer.com/api/txs/?address=#{legacy_address(address)}"
+        parse_block_explorer_transactions(get_request(url).body, address)
+      end
+
+      def create_address(id)
+        CashAddr::Converter.to_cash_address(super)
+      end
+
+      private
+
+      def legacy_address(address)
+        CashAddr::Converter.to_legacy_address(address)
+      rescue CashAddr::InvalidAddress
+        raise ApiError
+      end
+
+      def prefix
+        CryptocoinPayable.configuration.testnet ? 'bchtest.' : 'bitcoincash.'
+      end
+    end
+  end
+end

data/lib/cryptocoin_payable/adapters/ethereum.rb

@@ -0,0 +1,77 @@
+require 'eth'
+
+module CryptocoinPayable
+  module Adapters
+    class Ethereum < Base
+      # Wei in Ether
+      def self.subunit_in_main
+        1_000_000_000_000_000_000
+      end
+
+      def self.coin_symbol
+        'ETH'
+      end
+
+      def fetch_transactions(address)
+        api_adapter_key = coin_config.try(:adapter_api_key)
+        url = "https://#{subdomain}.etherscan.io/api?module=account&action=txlist&address=#{address}&tag=latest"
+        url += '?apiKey=' + api_adapter_key if api_adapter_key
+
+        response = get_request(url)
+        json = JSON.parse(response.body)
+
+        raise ApiError, json['message'] if json['status'] == '0' && json['message'] == 'NOTOK'
+
+        json['result'].map { |tx| convert_transactions(tx, address) }
+      end
+
+      def create_address(id)
+        Eth::Utils.public_key_to_address(super.public_key.uncompressed.to_hex)
+      end
+
+      private
+
+      def subdomain
+        @subdomain ||= CryptocoinPayable.configuration.testnet ? 'rinkeby' : 'api'
+      end
+
+      # Example response:
+      # {
+      #   status: "1",
+      #   message: "OK",
+      #   result: [
+      #     {
+      #       blockNumber: "4790248",
+      #       timeStamp: "1514144760",
+      #       hash: "0x52345400e42a15ba883fb0e314d050a7e7e376a30fc59dfcd7b841007d5d710c",
+      #       nonce: "215964",
+      #       block_hash: "0xe6ed0d98586cae04be57e515ca7773c020b441de60a467cd2773877a8996916f",
+      #       transactionIndex: "4",
+      #       from: "0xd24400ae8bfebb18ca49be86258a3c749cf46853",
+      #       to: "0x911f9d574d1ca099cae5ab606aa9207fe238579f",
+      #       value: "10000000000000000",
+      #       gas: "90000",
+      #       gasPrice: "28000000000",
+      #       isError: "0",
+      #       txreceipt_status: "1",
+      #       input: "0x",
+      #       contractAddress: "",
+      #       cumulativeGasUsed: "156270",
+      #       gasUsed: "21000",
+      #       confirmations: "154"
+      #     }
+      #   ]
+      # }
+      def convert_transactions(transaction, _address)
+        {
+          tx_hash: transaction['hash'],
+          block_hash: transaction['block_hash'],
+          block_time: nil, # Not supported
+          estimated_tx_time: Time.at(transaction['timeStamp'].to_i).iso8601,
+          estimated_tx_value: transaction['value'].to_i, # Units here are 'Wei'
+          confirmations: transaction['confirmations'].to_i
+        }
+      end
+    end
+  end
+end

data/lib/cryptocoin_payable/adapters.rb

@@ -0,0 +1,27 @@
+module CryptocoinPayable
+  module Adapters
+    def self.for(coin_type)
+      case coin_type.to_sym
+      when :eth
+        ethereum_adapter
+      when :btc
+        bitcoin_adapter
+      else
+        raise "Invalid coin type #{coin_type}"
+      end
+    end
+
+    def self.ethereum_adapter
+      @ethereum_adapter ||= Ethereum.new
+    end
+
+    def self.bitcoin_adapter
+      @bitcoin_adapter ||= Bitcoin.new
+    end
+  end
+end
+
+require 'cryptocoin_payable/adapters/base'
+require 'cryptocoin_payable/adapters/bitcoin'
+require 'cryptocoin_payable/adapters/bitcoin_cash'
+require 'cryptocoin_payable/adapters/ethereum'

data/lib/cryptocoin_payable/coin_payment.rb

@@ -0,0 +1,141 @@
+require 'money-tree'
+require 'state_machine'
+
+module CryptocoinPayable
+  class CoinPayment < ActiveRecord::Base
+    belongs_to :payable, polymorphic: true
+
+    has_many :transactions, class_name: 'CryptocoinPayable::CoinPaymentTransaction' do
+      def create_from_tx_data!(tx_data, coin_conversion)
+        create!(
+          estimated_value: tx_data[:estimated_tx_value],
+          transaction_hash: tx_data[:tx_hash],
+          block_hash: tx_data[:block_hash],
+          block_time: tx_data[:block_time],
+          estimated_time: tx_data[:estimated_tx_time],
+          coin_conversion: coin_conversion,
+          confirmations: tx_data[:confirmations]
+        )
+      end
+    end
+
+    validates :reason, presence: true
+    validates :price, presence: true
+    validates :coin_type, presence: true
+
+    before_create :populate_currency_and_amount_due
+    after_create :populate_address
+
+    scope :unconfirmed, -> { where(state: %i[pending partial_payment paid_in_full]) }
+    scope :unpaid, -> { where(state: %i[pending partial_payment]) }
+    scope :stale, -> { where('updated_at < ? OR coin_amount_due = 0', 30.minutes.ago) }
+
+    # TODO: Duplicated in `CurrencyConversion`.
+    enum coin_type: %i[
+      btc
+      eth
+    ]
+
+    state_machine :state do
+      state :pending
+      state :partial_payment
+      state :paid_in_full
+      state :confirmed
+      state :comped
+      state :expired
+
+      after_transition on: :pay, do: :notify_payable_paid
+      after_transition on: :comp, do: :notify_payable_paid
+      after_transition on: :confirm, do: :notify_payable_confirmed
+      after_transition on: :expire, do: :notify_payable_expired
+
+      event :pay do
+        transition %i[pending partial_payment] => :paid_in_full
+      end
+
+      event :partially_pay do
+        transition pending: :partial_payment
+      end
+
+      event :comp do
+        transition %i[pending partial_payment] => :comped
+      end
+
+      event :confirm do
+        transition paid_in_full: :confirmed
+      end
+
+      event :expire do
+        transition [:pending] => :expired
+      end
+    end
+
+    def coin_amount_paid
+      transactions.sum { |tx| adapter.convert_subunit_to_main(tx.estimated_value) }
+    end
+
+    def coin_amount_paid_subunit
+      transactions.sum(&:estimated_value)
+    end
+
+    # @returns cents in fiat currency.
+    def currency_amount_paid
+      cents = transactions.inject(0) do |sum, tx|
+        sum + (adapter.convert_subunit_to_main(tx.estimated_value) * tx.coin_conversion)
+      end
+
+      # Round to 0 decimal places so there aren't any partial cents.
+      cents.round(0)
+    end
+
+    def currency_amount_due
+      price - currency_amount_paid
+    end
+
+    def calculate_coin_amount_due
+      rate = CurrencyConversion.where(coin_type: coin_type).last.price
+      adapter.convert_main_to_subunit(currency_amount_due / rate.to_f).ceil
+    end
+
+    def transactions_confirmed?
+      transactions.all? do |t|
+        t.confirmations >= CryptocoinPayable.configuration.send(coin_type).confirmations
+      end
+    end
+
+    def adapter
+      @adapter ||= Adapters.for(coin_type)
+    end
+
+    private
+
+    def populate_currency_and_amount_due
+      self.currency ||= CryptocoinPayable.configuration.currency
+      self.coin_amount_due = calculate_coin_amount_due
+      self.coin_conversion = CurrencyConversion.where(coin_type: coin_type).last.price
+    end
+
+    def populate_address
+      update(address: adapter.create_address(id))
+    end
+
+    def notify_payable_event(event_name)
+      method_name = :"coin_payment_#{event_name}"
+      payable.send(method_name, self) if payable.respond_to?(method_name)
+
+      payable.coin_payment_event(self, event_name) if payable.respond_to?(:coin_payment_event)
+    end
+
+    def notify_payable_paid
+      notify_payable_event(:paid)
+    end
+
+    def notify_payable_confirmed
+      notify_payable_event(:confirmed)
+    end
+
+    def notify_payable_expired
+      notify_payable_event(:expired)
+    end
+  end
+end

data/lib/cryptocoin_payable/coin_payment_transaction.rb

@@ -0,0 +1,5 @@
+module CryptocoinPayable
+  class CoinPaymentTransaction < ActiveRecord::Base
+    belongs_to :coin_payment
+  end
+end

data/lib/cryptocoin_payable/commands/payment_processor.rb

@@ -0,0 +1,67 @@
+module CryptocoinPayable
+  class PaymentProcessor
+    def self.perform
+      new.perform
+    end
+
+    def self.update_transactions_for(payment)
+      transactions = Adapters.for(payment.coin_type).fetch_transactions(payment.address)
+
+      transactions.each do |tx|
+        tx.symbolize_keys!
+
+        transaction = payment.transactions.find_by_transaction_hash(tx[:txHash])
+        if transaction
+          transaction.update(confirmations: tx[:confirmations])
+        else
+          payment.transactions.create_from_tx_data!(tx, payment.coin_conversion)
+          payment.update(
+            coin_amount_due: payment.calculate_coin_amount_due,
+            coin_conversion: CurrencyConversion.where(coin_type: payment.coin_type).last.price
+          )
+        end
+      end
+    end
+
+    def perform
+      CoinPayment.unconfirmed.find_each do |payment|
+        # Check for completed payment first, in case it's 0 and we don't need to
+        # make an API call.
+        update_payment_state(payment)
+
+        next if payment.confirmed?
+
+        begin
+          self.class.update_transactions_for(payment)
+        rescue StandardError => error
+          STDERR.puts 'PaymentProcessor: Unknown error encountered, skipping transaction'
+          STDERR.puts error
+          next
+        end
+
+        # Check for payments after the response comes back.
+        update_payment_state(payment)
+
+        # If the payment has not moved out of the pending state after loading
+        # new transactions, we expire it.
+        update_payment_expired_state(payment) if payment.pending?
+      end
+    end
+
+    protected
+
+    def update_payment_state(payment)
+      if payment.currency_amount_paid >= payment.price
+        payment.pay
+        payment.confirm if payment.transactions_confirmed?
+      elsif payment.currency_amount_paid > 0
+        payment.partially_pay
+      end
+    end
+
+    def update_payment_expired_state(payment)
+      expire_after = CryptocoinPayable.configuration.expire_payments_after
+      payment.expire if expire_after.present? && (Time.now - payment.created_at) >= expire_after
+    end
+  end
+end

data/lib/cryptocoin_payable/commands/pricing_processor.rb

@@ -0,0 +1,43 @@
+module CryptocoinPayable
+  class PricingProcessor
+    def self.perform
+      new.perform
+    end
+
+    def self.delete_currency_conversions(time_ago)
+      new.delete_currency_conversions(time_ago)
+    end
+
+    def perform
+      rates = CurrencyConversion.coin_types.map do |coin_pair|
+        coin_type = coin_pair[0].to_sym
+        [
+          coin_type,
+          CurrencyConversion.create!(
+            # TODO: Store three previous price ranges, defaulting to 100 for now.
+            currency: 100,
+            price: Adapters.for(coin_type).fetch_rate,
+            coin_type: coin_type
+          )
+        ]
+      end.to_h
+
+      # Loop through all unpaid payments and update them with the new price if
+      # it has been 30 mins since they have been updated.
+      CoinPayment.unpaid.stale.find_each do |payment|
+        payment.update!(
+          coin_amount_due: payment.calculate_coin_amount_due,
+          coin_conversion: rates[payment.coin_type.to_sym].price
+        )
+      end
+    end
+
+    def delete_currency_conversions(time_ago)
+      # Makes sure to keep at least one record in the db since other areas of
+      # the gem assume the existence of at least one record.
+      last_id = CurrencyConversion.last.id
+      time = time_ago || 1.month.ago
+      CurrencyConversion.where('created_at < ? AND id != ?', time, last_id).delete_all
+    end
+  end
+end

data/lib/cryptocoin_payable/config.rb

@@ -0,0 +1,65 @@
+module CryptocoinPayable
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    @configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :testnet, :expire_payments_after, :request_delay, :btc, :bch, :eth
+    attr_writer :currency
+
+    def currency
+      @currency ||= :usd
+    end
+
+    def configure_btc
+      @btc ||= BtcConfiguration.new
+      yield(@btc)
+    end
+
+    def configure_bch
+      @bch ||= BchConfiguration.new
+      yield(@bch)
+    end
+
+    def configure_eth
+      @eth ||= EthConfiguration.new
+      yield(@eth)
+
+      Eth.configure do |config|
+        config.chain_id = CryptocoinPayable.configuration.testnet ? 4 : 1
+      end
+    end
+
+    class CoinConfiguration
+      attr_accessor :master_public_key, :confirmations, :adapter_api_key
+      attr_writer :node_path
+
+      def node_path
+        @node_path ||= ''
+      end
+    end
+
+    class BtcConfiguration < CoinConfiguration
+      def confirmations
+        @confirmations ||= 3
+      end
+    end
+
+    class BchConfiguration < CoinConfiguration
+      def confirmations
+        @confirmations ||= 3
+      end
+    end
+
+    class EthConfiguration < CoinConfiguration
+      def confirmations
+        @confirmations ||= 12
+      end
+    end
+  end
+end

data/lib/cryptocoin_payable/currency_conversion.rb

@@ -0,0 +1,11 @@
+module CryptocoinPayable
+  class CurrencyConversion < ActiveRecord::Base
+    validates :price, presence: true
+
+    # TODO: Duplicated in `CoinPayment`.
+    enum coin_type: %i[
+      btc
+      eth
+    ]
+  end
+end

data/lib/cryptocoin_payable/errors.rb

@@ -0,0 +1,7 @@
+module CryptocoinPayable
+  class ApiError < StandardError; end
+  class ApiLimitReached < ApiError; end
+  class ConfigError < StandardError; end
+  class MissingMasterPublicKey < ConfigError; end
+  class NetworkNotSupported < ConfigError; end
+end

data/lib/cryptocoin_payable/has_coin_payments.rb

@@ -0,0 +1,15 @@
+module CryptocoinPayable
+  module Model
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      def has_coin_payments(_options = {}) # rubocop:disable Naming/PredicateName
+        has_many :coin_payments, -> { order(:id) },
+          class_name: 'CryptocoinPayable::CoinPayment',
+          as: 'payable'
+      end
+    end
+  end
+end

data/lib/cryptocoin_payable/tasks.rb

@@ -0,0 +1,20 @@
+require 'rake'
+require 'cryptocoin_payable/commands/pricing_processor'
+require 'cryptocoin_payable/commands/payment_processor'
+
+namespace :cryptocoin_payable do
+  desc 'Process the prices and update the payments'
+  task process_prices: :environment do
+    CryptocoinPayable::PricingProcessor.perform
+  end
+
+  desc 'Delete old CurrencyConversion data (will delete last month by default)'
+  task delete_currency_conversions: :environment do
+    CryptocoinPayable::PricingProcessor.delete_currency_conversions(ENV['DELETE_BEFORE'])
+  end
+
+  desc 'Get transactions from external API and process payments'
+  task process_payments: :environment do
+    CryptocoinPayable::PaymentProcessor.perform
+  end
+end

data/lib/cryptocoin_payable/version.rb

@@ -0,0 +1,3 @@
+module CryptocoinPayable
+  VERSION = '1.0.0'.freeze
+end

data/lib/cryptocoin_payable.rb

@@ -0,0 +1,18 @@
+require 'net/http'
+
+require 'cryptocoin_payable/config'
+require 'cryptocoin_payable/errors'
+require 'cryptocoin_payable/version'
+require 'cryptocoin_payable/has_coin_payments'
+require 'cryptocoin_payable/tasks'
+require 'cryptocoin_payable/adapters'
+require 'cryptocoin_payable/coin_payment_transaction'
+require 'cryptocoin_payable/coin_payment'
+require 'cryptocoin_payable/currency_conversion'
+
+module CryptocoinPayable
+end
+
+ActiveSupport.on_load(:active_record) do
+  include CryptocoinPayable::Model
+end

data/lib/generators/cryptocoin_payable/install_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module CryptocoinPayable
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.expand_path('templates', __dir__)
+
+    desc 'Generates (but does not run) a migration to add a coin payment tables.'
+
+    def create_migration_file
+      migration_template 'create_coin_payments.rb',
+        'db/migrate/create_coin_payments.rb'
+
+      migration_template 'create_coin_payment_transactions.rb',
+        'db/migrate/create_coin_payment_transactions.rb'
+
+      migration_template 'create_currency_conversions.rb',
+        'db/migrate/create_currency_conversions.rb'
+    end
+
+    def self.next_migration_number(dirname)
+      ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+  end
+end

data/lib/generators/cryptocoin_payable/templates/create_coin_payment_transactions.rb

@@ -0,0 +1,16 @@
+class CreateCoinPaymentTransactions < ActiveRecord::Migration[5.1]
+  def change
+    create_table :coin_payment_transactions do |t|
+      t.decimal :estimated_value, precision: 24, scale: 0
+      t.string :transaction_hash
+      t.string :block_hash
+      t.datetime :block_time
+      t.datetime :estimated_time
+      t.integer :coin_payment_id
+      t.decimal :coin_conversion, precision: 24, scale: 0
+      t.integer :confirmations, default: 0
+    end
+
+    add_index :coin_payment_transactions, :coin_payment_id
+  end
+end