cryptocoin_payable 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '082e02924175a9102d410d319122b35c86e15704'
+  data.tar.gz: '0936ed5dac497c1edd445782753dbfb47c03701c'
+SHA512:
+  metadata.gz: c5f7175563f7b3a5a9b9a5d9daf7f76c9515bec1abcc000b7bd0bf26a80cde297ff5a50c89dd5b56017319d407820c2405ff26d782dab40f15921bd678770a18
+  data.tar.gz: de2df907054a5e3c1f1f35077c83cf52a432041a32c5e4cf5bbd57ae4e3924689051df78f6eb8a63f9895d5a2ddb6d47ed28c3e3eac83f06406e5654c8e1e3d9

data/.gitignore

@@ -0,0 +1,5 @@
+spec/dummy/log/*
+*.gem
+/Gemfile.lock
+/spec/dummy/log/development.log
+/spec/dummy/db/test.sqlite3

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,36 @@
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Layout/MultilineAssignmentLayout:
+  EnforcedStyle: same_line
+
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: variable
+
+Layout/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/AbcSize:
+  Max: 21
+
+Metrics/ClassLength:
+  Max: 200
+
+Metrics/BlockLength:
+  Exclude:
+    - 'Rakefile'
+    - '**/*.rake'
+    - 'test/**/*.rb'
+    - 'spec/**/*.rb'

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cryptocoin_payable.gemspec
+gemspec
+
+group :test do
+  gem 'cucumber-rails', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jonathan Salis
+
+MIT License
+
+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,237 @@
+# Cryptocoin Payable
+
+Forked from [Bitcoin Payable](https://github.com/Sailias/bitcoin_payable)
+
+A rails gem that enables any model to have crypto coin payments.
+The polymorphic table coin_payments creates payments with unique addresses based on a BIP32 deterministic seed using https://github.com/GemHQ/money-tree and uses external APIs to check for payments:
+
+- https://etherscan.io
+- https://blockexplorer.com
+
+Supported coins are:
+
+- Bitcoin
+- Bitcoin Cash
+- Ethereum
+
+Payments have the following states:
+
+- `pending`
+- `partial_payment`
+- `paid_in_full`
+- `comped` (useful for refunding payments)
+- `confirmed` (enters state after n blockchain confirmations, see `confirmations` config option)
+- `expired` (useful for auto-expiring incomplete payments, see `expire_payments_after` config option)
+
+No private keys needed, No bitcoind blockchain indexing on new servers, just address and payments.
+
+**Donations appreciated**
+
+`142WJW4Zzc9iV7uFdbei8Unpe8WcLhUgmE`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cryptocoin_payable', git: 'https://github.com/Sailias/cryptocoin_payable', branch: 'master'
+
+And then execute:
+
+    $ bundle
+
+    $ rails g cryptocoin_payable:install
+
+    $ bundle exec rake db:migrate
+
+    $ populate coin_payable.rb (see below)
+
+    $ bundle exec rake cryptocoin_payable:process_prices (see below)
+
+## Uninstall
+
+    $ rails d cryptocoin_payable:install
+
+## Run Tests
+
+    cucumber features
+    rspec
+
+## Usage
+
+### Configuration
+
+config/initializers/coin_payable.rb
+
+    CryptocoinPayable.configure do |config|
+      # config.currency = :usd
+      # config.testnet = true
+
+      config.request_delay = 0.5
+      config.expire_payments_after = 15.minutes
+
+      config.configure_btc do |btc_config|
+        # btc_config.confirmations = 3
+        # btc_config.node_path = ''
+
+        btc_config.master_public_key = 'tpub...'
+      end
+
+      config.configure_bch do |bch_config|
+        # bch_config.confirmations = 3
+        # btc_config.node_path = ''
+
+        bch_config.master_public_key = 'tpub...'
+      end
+
+      config.configure_eth do |eth_config|
+        # eth_config.confirmations = 12
+        # eth_config.node_path = ''
+
+        eth_config.master_public_key = 'tpub...'
+      end
+    end
+
+In order to use the bitcoin network and issue real addresses, CryptocoinPayable.config.testnet must be set to false:
+
+    CryptocoinPayable.config.testnet = false
+
+Consider adding a request delay (in seconds) to prevent API rate limit errors:
+
+    CryptocoinPayable.config.request_delay = 0.5
+
+#### Node Path
+
+The derivation path for the node that will be creating your addresses.
+
+#### Master Public Key
+
+A BIP32 MPK in "Extended Key" format used when configuring bitcoin payments (see `btc_config.master_public_key` above).
+
+Public net starts with: xpub
+Testnet starts with: tpub
+
+* Obtain your BIP32 MPK from http://bip32.org/
+
+### Adding it to your model
+
+    class Product < ActiveRecord::Base
+      has_coin_payments
+    end
+
+### Creating a payment from your application
+
+    def create_payment(amount_in_cents)
+      self.coin_payments.create!(reason: 'sale', price: amount_in_cents, coin_type: :btc)
+    end
+
+### Update payments with the current price of BTC based on your currency
+
+CryptocoinPayable also supports local currency conversions and BTC exchange rates.
+
+The `process_prices` rake task connects to api.bitcoinaverage.com to get the 24 hour weighted average of BTC for your specified currency.
+It then updates all payments that havent received an update in the last 30 minutes with the new value owing in BTC.
+This *honors* the price of a payment for 30 minutes at a time.
+
+`rake cryptocoin_payable:process_prices`
+
+### Processing payments
+
+All payments are calculated against the dollar amount of the payment.  So a `bitcoin_payment` for $49.99 will have it's value calculated in BTC.
+It will stay at that price for 30 minutes.  When a payment is made, a transaction is created that stores the BTC in satoshis paid and the exchange rate is was paid at.
+This is very valuable for accounting later.  (capital gains of all payments received)
+
+If a partial payment is made, the BTC value is recalculated for the remaining *dollar* amount with the latest exchange rate.
+This means that if someone pays 0.01 for a 0.5 payment, that 0.01 is converted into dollars at the time of processing and the
+remaining amount is calculated in dollars and the remaining amount in BTC is issued.  (If BTC bombs, that value could be greater than 0.5 now)
+
+This prevents people from gaming the payments by paying very little BTC in hopes the price will rise.
+Payments are not recalculated based on the current value of BTC, but in dollars.
+
+To run the payment processor:
+
+`rake cryptocoin_payable:process_payments`
+
+### Notify your application when a payment is made
+
+Use the `coin_payment_paid` and `coin_payment_confirmed` methods
+
+    def Product < ActiveRecord::Base
+      has_coin_payments
+
+      def create_payment(amount_in_cents)
+        self.coin_payments.create!(reason: 'sale', price: amount_in_cents, type: :btc)
+      end
+
+      # Runs when the payment is first detected on the network.
+      def coin_payment_paid(payment)
+        self.notify!
+      end
+
+      # Runs when enough confirmations have occurred.
+      def coin_payment_confirmed(payment)
+        self.ship!
+      end
+    end
+
+### Delete old CurrencyConversion data
+
+Every time the payment processor is run, several rows are inserted into the
+database to record the value of the coin at a given instance in time. Over time,
+your application will accumulate historical currency conversion data and you may
+want to clear it out:
+
+```
+rake cryptocoin_payable:delete_currency_conversions
+```
+
+By default, it will delete any data older than 1 month. You can configure this
+using an env variable:
+
+```
+DELETE_BEFORE=2017-12-15 rake cryptocoin_payable:delete_currency_conversions
+```
+
+### Comp a payment
+
+This will bypass the payment, set the state to comped and call back to your app that the payment has been processed.
+
+`@coin_payment.comp`
+
+### Expire a payment
+
+`@coin_payment.expire`
+
+Payments will auto-expire if you set the `expire_payments_after` option. The
+exact timing is not precise because payment expiry is evaluated whenever
+payment_processor runs.
+
+### View all the transactions in the payment
+
+    coin_payment = @product.coin_payments.first
+    coin_payment.transactions.find_each do |transaction|
+      puts transaction.block_hash
+      puts transaction.block_time
+
+      puts transaction.transaction_hash
+
+      puts transaction.estimated_value
+      puts transaction.estimated_time
+
+      puts transaction.coin_conversion
+
+      puts transaction.confirmations
+    end
+
+## Contributing
+
+1. Fork it
+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 new Pull Request
+
+## Contributors
+
+* andersonlewin
+* krtschmr
+* mhluska

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler/gem_tasks'
+require 'rake'
+require 'cryptocoin_payable/tasks'

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'active_record'
+require 'cryptocoin_payable'
+
+# 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(__FILE__)

data/bin/setup

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

data/cryptocoin_payable.gemspec

@@ -0,0 +1,39 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cryptocoin_payable/version'
+
+# rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |spec|
+  spec.name          = 'cryptocoin_payable'
+  spec.version       = CryptocoinPayable::VERSION
+  spec.authors       = ['Jonathan Salis']
+  spec.email         = ['jsalis@bitcoinsultants.ca']
+  spec.description   = 'Cryptocurrency payment processor'
+  spec.summary       = 'Cryptocurrency payment processor'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.required_rubygems_version = '>= 1.3.6'
+
+  spec.add_development_dependency 'activerecord', '~> 5.1'
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'cucumber', '~> 3.1'
+  spec.add_development_dependency 'database_cleaner', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 12.3'
+  spec.add_development_dependency 'rspec-rails', '~> 3.7'
+  spec.add_development_dependency 'rubocop', '~> 0.59'
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'vcr', '~> 4.0'
+  spec.add_development_dependency 'webmock', '~> 3.4'
+
+  spec.add_dependency 'cash-addr', '~> 0.2'
+  spec.add_dependency 'eth', '0.4.8'
+  spec.add_dependency 'money-tree', '0.10.0'
+  spec.add_dependency 'rails'
+  spec.add_dependency 'state_machine', '~> 1.2'
+end
+# rubocop:enable Metrics/BlockLength

data/features/coin_payments.feature

@@ -0,0 +1,51 @@
+Feature: CoinPayment creation, validation and state
+
+Background:
+  Given a saved widget
+  And a new coin_payment
+  Then the coin_payment field coin_type is set to btc
+  Then the coin_payment field price is set to 10000
+    And the coin_payment field reason is set to New
+  When the coin_payment is saved
+
+Scenario: A saved widget can create a payment
+Then the coin_payment should have an address
+  And the coin_payment should have the state pending
+
+Scenario: When the payment processor is run the payment status should be pending
+When the payment_processor is run
+Then the coin_payment should have the state pending
+
+Scenario: When a payment is made for 1/2 the amount, the status should be partial payment
+When the coin_amount_due is set
+  And a payment is made for 50 percent
+When the payment_processor is run
+Then the coin_payment should have the state partial_payment
+  And the amount paid percentage should be 50%
+
+Scenario: When a payment is made for 1/2 the amount, the status should be partial payment
+When the coin_amount_due is set
+  And a payment is made for 100 percent
+When the payment_processor is run
+Then the coin_payment should have the state paid_in_full
+  And the amount paid percentage should be 100%
+
+Scenario: When the price bombs the payment is still honoured at the conversion rate
+When the coin_amount_due is set
+  And the currency_conversion is 1
+  And a payment is made for 50 percent
+When the payment_processor is run
+Then the coin_payment should have the state partial_payment
+  And the amount paid percentage should be 50%
+
+Scenario: When a partial payment is made and another payment made it should complete
+Scenario: When a payment is made for 1/2 the amount, the status should be partial payment
+When the coin_amount_due is set
+  And a payment is made for 50 percent
+When the payment_processor is run
+Then the coin_payment should have the state partial_payment
+  And the amount paid percentage should be 50%
+Then a payment is made for 50 percent
+When the payment_processor is run
+Then the coin_payment should have the state paid_in_full
+  And the amount paid percentage should be 100%

data/features/default.feature

@@ -0,0 +1,5 @@
+Feature: Testing an empty widget
+
+Scenario: An unsaved widget should respond to coin_payments
+Given an unsaved widget
+Then the widget should have 0 coin_payments

data/features/pricing_processor.feature

@@ -0,0 +1,4 @@
+Feature: Pricing Processor tests
+
+Scenario: The test framework should set up 3 currency conversions
+Given there should be 3 currency_conversions

data/features/step_definitions/coin_payment_steps.rb

@@ -0,0 +1,45 @@
+Given(/^the coin_payment field (\S*) is set to (.*)/) do |field, value|
+  @coin_payment.send("#{field}=", value)
+end
+
+Given(/^the coin_payment is saved$/) do
+  @coin_payment.save
+  expect(@coin_payment.reload.new_record?).to be(false)
+end
+
+Given(/^the coin_payment should have an address$/) do
+  expect(@coin_payment.address).to_not be(nil)
+end
+
+Given(/^the coin_payment should have the state (\S+)$/) do |state|
+  expect(@coin_payment.reload.state).to eq(state)
+end
+
+Given(/^the coin_amount_due is set$/) do
+  @coin_amount_due = @coin_payment.calculate_coin_amount_due
+end
+
+Given(/^a payment is made for (\d+) percent$/) do |percentage|
+  CryptocoinPayable::Adapters::Bitcoin.any_instance.stub(:fetch_transactions).and_return(
+    [{
+      tx_hash: SecureRandom.uuid,
+      block_hash: '00000000000000606aa74093ed91d657192a3772732ee4d99a7b7be8075eafa2',
+      block_time: DateTime.iso8601('2017-12-26T21:38:44.000+00:00'),
+      estimated_tx_time: DateTime.iso8601('2017-12-26T21:30:19.858+00:00'),
+      estimated_tx_value: @coin_amount_due * (percentage.to_f / 100.0),
+      confirmations: 1
+    }]
+  )
+end
+
+Given(/^the amount paid percentage should be greater than (\d+)%$/) do |percentage|
+  expect(@coin_payment.currency_amount_paid / @coin_payment.price.to_f).to be >= (percentage.to_f / 100)
+end
+
+Given(/^the amount paid percentage should be less than (\d+)%$/) do |percentage|
+  expect(@coin_payment.currency_amount_paid / @coin_payment.price).to be < (percentage.to_f / 100)
+end
+
+Given(/^the amount paid percentage should be (\d+)%$/) do |percentage|
+  expect(@coin_payment.currency_amount_paid / @coin_payment.price.to_f).to eq(percentage.to_f / 100)
+end

data/features/step_definitions/currency_conversion_steps.rb

@@ -0,0 +1,12 @@
+Given(/^there should be (\d+) currency_conversions?$/) do |n|
+  expect(@currency_conversions).to_not be_nil
+  expect(@currency_conversions.count).to eq(n.to_i)
+end
+
+Given(/^the currency_conversion is (\d+)$/) do |conversion_rate|
+  CryptocoinPayable::CurrencyConversion.create!(
+    currency: 1,
+    price: conversion_rate.to_i
+  )
+  @currency_conversions = CryptocoinPayable::CurrencyConversion.all
+end

data/features/step_definitions/model_step.rb

@@ -0,0 +1,11 @@
+Given(/^an unsaved widget$/) do
+  @widget = Widget.new
+end
+
+Given(/^a saved widget$/) do
+  @widget = Widget.create
+end
+
+Given(/^a new coin_payment$/) do
+  @coin_payment = @widget.coin_payments.new
+end

data/features/step_definitions/processor_steps.rb

@@ -0,0 +1,7 @@
+When(/^the payment_processor is run$/) do
+  CryptocoinPayable::PaymentProcessor.perform
+end
+
+When(/^the pricing processor is run$/) do
+  CryptocoinPayable::PricingProcessor.perform
+end

data/features/step_definitions/widget_steps.rb

@@ -0,0 +1,3 @@
+Given(/^the widget should have (\d+) coin_payments$/) do |n|
+  expect(@widget.coin_payments.count).to eq(n.to_i)
+end

data/features/support/env.rb

@@ -0,0 +1,26 @@
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../../spec/dummy/config/environment.rb', __dir__)
+
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '../../../spec/dummy'
+
+require 'cucumber/rails'
+require 'cucumber/rspec/doubles'
+
+# Remove/comment out the lines below if your app doesn't have a database.
+# For some databases (like MongoDB and CouchDB) you may need to use :truncation instead.
+begin
+  DatabaseCleaner.strategy = :transaction
+rescue NameError
+  raise 'You need to add database_cleaner to your Gemfile (in the :test group) if you wish to use it.'
+end
+
+Before do
+  3.times do
+    CryptocoinPayable::CurrencyConversion.create!(
+      coin_type: :btc,
+      currency: rand(85...99),
+      price: rand(10_000...15_000) * 100, # cents in fiat
+    )
+  end
+  @currency_conversions = CryptocoinPayable::CurrencyConversion.all
+end

data/lib/cryptocoin_payable/adapters/base.rb

@@ -0,0 +1,99 @@
+module CryptocoinPayable
+  module Adapters
+    class Base
+      # Implement these in a subclass:
+
+      # Returns the amount of cents in the main unit. E.g. 10^18 Wei in Ether.
+      # def self.subunit_in_main
+      #   1_000_000_000_000_000_000
+      # end
+
+      # Returns the currency symbol (used for querying for ticker data).
+      # def self.coin_symbol
+      #   'ETH'
+      # end
+
+      # Queries an API like etherscan.io and returns a list of transactions
+      # which conform to the following shape:
+      # {
+      #   tx_hash: string,
+      #   block_hash: string,
+      #   block_time: nil | string,
+      #   estimated_tx_time: nil | string,
+      #   estimated_tx_value: integer,
+      #   confirmations: integer,
+      # }
+      # `block_time` and `estimated_tx_time` are optional strings conforming to
+      # date format ISO 8601.
+      #
+      # Can optionally raise ApiLimitedReached if needed.
+      #
+      # def self.fetch_transactions(address)
+      # end
+
+      # Uses a predefined seed to generate HD addresses based on an index/id
+      # passed into the method.
+      # def self.create_address(id)
+      # end
+
+      def convert_subunit_to_main(subunit)
+        subunit / self.class.subunit_in_main.to_f
+      end
+
+      def convert_main_to_subunit(main)
+        (main * self.class.subunit_in_main).to_i
+      end
+
+      def fetch_rate
+        currency = CryptocoinPayable.configuration.currency.to_s.upcase
+        symbol = self.class.coin_symbol
+        amount =
+          begin
+            response = get_request("https://api.coinbase.com/v2/prices/#{symbol}-#{currency}/spot")
+            JSON.parse(response.body)['data']['amount'].to_f
+          rescue StandardError
+            response = get_request("https://api.gemini.com/v1/pubticker/#{symbol}#{currency}")
+            JSON.parse(response.body)['last'].to_f
+          end
+
+        (amount * 100).to_i
+      end
+
+      def create_address(id)
+        raise MissingMasterPublicKey, 'master_public_key is required' unless coin_config.master_public_key
+
+        master = MoneyTree::Node.from_bip32(coin_config.master_public_key)
+        master.node_for_path(coin_config.node_path + id.to_s)
+      end
+
+      protected
+
+      def coin_config
+        @coin_config ||= CryptocoinPayable.configuration.send(self.class.coin_symbol.downcase)
+      end
+
+      def parse_timestamp(timestamp)
+        timestamp.nil? ? nil : DateTime.strptime(timestamp.to_s, '%s')
+      end
+
+      def parse_time(time)
+        time.nil? ? nil : DateTime.iso8601(time)
+      end
+
+      private
+
+      def get_request(url)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        request = Net::HTTP::Get.new(uri.request_uri)
+        result = http.request(request)
+
+        request_delay = CryptocoinPayable.configuration.request_delay
+        sleep request_delay if request_delay
+
+        result
+      end
+    end
+  end
+end