bitpay-client 2.4.0 → 2.5.1905

data/lib/bitpay/client.rb

@@ -0,0 +1,175 @@
+# license Copyright 2011-2019 BitPay, Inc., MIT License
+# see http://opensource.org/licenses/MIT
+# or https://github.com/bitpay/php-bitpay-client/blob/master/LICENSE
+
+require 'uri'
+require 'net/https'
+require 'json'
+
+require 'bitpay_key_utils'
+require_relative 'rest_connector'
+
+module BitPay
+  # This class is used to instantiate a BitPay Client object. It is expected to be thread safe.
+  #
+  module SDK
+    class Client
+      include BitPay::RestConnector 
+      # @return [Client]
+      # @example
+      #  # Create a client with a pem file created by the bitpay client:
+      #  client = BitPay::SDK::Client.new
+      def initialize(opts={})
+        @pem                = opts[:pem] || ENV['BITPAY_PEM'] || KeyUtils.generate_pem 
+        @key                = KeyUtils.create_key @pem
+        @priv_key           = KeyUtils.get_private_key @key
+        @pub_key            = KeyUtils.get_public_key @key
+        @client_id          = KeyUtils.generate_sin_from_pem @pem
+        @uri                = URI.parse opts[:api_uri] || API_URI
+        @user_agent         = opts[:user_agent] || USER_AGENT
+        @https              = Net::HTTP.new @uri.host, @uri.port
+        @https.use_ssl      = true
+        @https.open_timeout = 10
+        @https.read_timeout = 10
+
+        @https.ca_file      = CA_FILE
+        @tokens             = opts[:tokens] || {}
+
+        # Option to disable certificate validation in extraordinary circumstance.  NOT recommended for production use
+        @https.verify_mode = opts[:insecure] == true ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+        
+        # Option to enable http request debugging
+        @https.set_debug_output($stdout) if opts[:debug] == true
+      end
+
+      ## Pair client with BitPay service
+      # => Pass empty hash {} to retreive client-initiated pairing code
+      # => Pass {pairingCode: 'WfD01d2'} to claim a server-initiated pairing code
+      #
+      def pair_client(params={})
+        tokens = post(path: 'tokens', params: params)
+        return tokens["data"]
+      end
+
+      ## Compatibility method for pos pairing
+      #
+      def pair_pos_client(claimCode)
+        raise BitPay::ArgumentError, "pairing code is not legal" unless verify_claim_code(claimCode)
+        pair_client({pairingCode: claimCode})
+      end
+
+      ## Create bitcoin invoice
+      #
+      #   Defaults to pos facade, also works with merchant facade
+      # 
+      def create_invoice(price:, currency:, facade: 'pos', params:{})
+        raise BitPay::ArgumentError, "Illegal Argument: Price must be formatted as a float" unless 
+          price.is_a?(Numeric) ||
+          /^[[:digit:]]+(\.[[:digit:]]{2})?$/.match(price) ||
+          currency == 'BTC' && /^[[:digit:]]+(\.[[:digit:]]{1,6})?$/.match(price)
+        raise BitPay::ArgumentError, "Illegal Argument: Currency is invalid." unless /^[[:upper:]]{3}$/.match(currency)
+        params.merge!({price: price, currency: currency})
+        token = get_token(facade)
+        invoice = post(path: "invoices", token: token, params: params)
+        invoice["data"]
+      end
+
+      ## Gets the privileged merchant-version of the invoice		
+      #   Requires merchant facade token		
+      #		
+      def get_invoice(id:)
+        token = get_token('merchant')
+        invoice = get(path: "invoices/#{id}", token: token)
+        invoice["data"]
+      end
+
+      ## Gets the public version of the invoice
+      #
+      def get_public_invoice(id:)
+        invoice = get(path: "invoices/#{id}", public: true)
+        invoice["data"]
+      end
+      
+      
+      ## Refund paid BitPay invoice
+      #
+      #   If invoice["data"]["flags"]["refundable"] == true the a refund address was 
+      #   provided with the payment and the refund_address parameter is an optional override
+      #  
+      #   Amount and Currency are required fields for fully paid invoices but optional
+      #   for under or overpaid invoices which will otherwise be completely refunded
+      #
+      #   Requires merchant facade token
+      #
+      #  @example
+      #    client.refund_invoice(id: 'JB49z2MsDH7FunczeyDS8j', params: {amount: 10, currency: 'USD', bitcoinAddress: '1Jtcygf8W3cEmtGgepggtjCxtmFFjrZwRV'})
+      #
+      def refund_invoice(id:, params:{})
+        invoice = get_invoice(id: id)
+        refund = post(path: "invoices/#{id}/refunds", token: invoice["token"], params: params)
+        refund["data"]
+      end
+      
+      ## Get All Refunds for Invoice
+      #   Returns an array of all refund requests for a specific invoice, 
+      # 
+      #   Requires merchant facade token
+      #
+      #  @example:
+      #    client.get_all_refunds_for_invoice(id: 'JB49z2MsDH7FunczeyDS8j')
+      #
+      def get_all_refunds_for_invoice(id:)
+        urlpath = "invoices/#{id}/refunds"
+        invoice = get_invoice(id: id)
+        refunds = get(path: urlpath, token: invoice["token"])
+        refunds["data"]
+      end
+
+      ## Get Refund
+      #   Requires merchant facade token
+      #
+      #  @example:
+      #    client.get_refund(id: 'JB49z2MsDH7FunczeyDS8j', request_id: '4evCrXq4EDXk4oqDXdWQhX')
+      #
+      def get_refund(invoice_id:, request_id:)
+        urlpath = "invoices/#{invoice_id}/refunds/#{request_id}"
+        invoice = get_invoice(id: invoice_id)
+        refund = get(path: urlpath, token: invoice["token"])
+        refund["data"]
+      end
+      
+      ## Cancel Refund
+      #   Requires merchant facade token
+      #
+      #  @example:
+      #    client.cancel_refund(id: 'JB49z2MsDH7FunczeyDS8j', request_id: '4evCrXq4EDXk4oqDXdWQhX')
+      #
+      def cancel_refund(invoice_id:, request_id:)
+        urlpath = "invoices/#{invoice_id}/refunds/#{request_id}"
+        refund = get_refund(invoice_id: invoice_id, request_id: request_id)
+        deletion = delete(path: urlpath, token: refund["token"])
+        deletion["data"]
+      end      
+
+      ## Checks that the passed tokens are valid by
+      #  comparing them to those that are authorized by the server
+      #
+      #  Uses local @tokens variable if no tokens are passed
+      #  in order to validate the connector is properly paired
+      #
+      def verify_tokens(tokens: @tokens)
+        server_tokens = refresh_tokens
+        tokens.each{|key, value| return false if server_tokens[key] != value}
+        return true
+      end
+
+      private
+
+      def verify_claim_code(claim_code)
+        regex = /^[[:alnum:]]{7}$/
+          matches = regex.match(claim_code)
+        !(matches.nil?)
+      end
+    end
+  end
+end

data/lib/bitpay/rest_connector.rb

@@ -0,0 +1,106 @@
+# license Copyright 2011-2019 BitPay, Inc., MIT License
+# see http://opensource.org/licenses/MIT
+# or https://github.com/bitpay/php-bitpay-client/blob/master/LICENSE
+
+module BitPay
+  module RestConnector
+    def send_request(verb, path, facade: 'merchant', params: {}, token: nil)
+      token ||= get_token(facade)
+      case verb.upcase
+      when "GET"
+        return get(path: path, token: token)
+      when "POST"
+        return post(path: path, token: token, params: params)
+      else
+        raise(BitPayError, "Invalid HTTP verb: #{verb.upcase}")
+      end
+    end
+
+    def get(path:, token: nil, public: false)
+      urlpath = '/' + path
+      token_prefix = if urlpath.include? '?' then '&token=' else '?token=' end
+      urlpath = urlpath + token_prefix + token if token
+      request = Net::HTTP::Get.new urlpath
+      unless public
+        request['X-Signature'] = KeyUtils.sign(@uri.to_s + urlpath, @priv_key) 
+        request['X-Identity'] = @pub_key
+      end
+      process_request(request)
+    end
+
+    def post(path:, token: nil, params:)
+      urlpath = '/' + path
+      request = Net::HTTP::Post.new urlpath
+      params[:token] = token if token
+      params[:guid]  = SecureRandom.uuid
+      params[:id] = @client_id
+      request.body = params.to_json
+      if token
+        request['X-Signature'] = KeyUtils.sign(@uri.to_s + urlpath + request.body, @priv_key)
+        request['X-Identity'] = @pub_key
+      end
+      process_request(request)
+    end
+
+    def delete(path:, token: nil)
+      urlpath = '/' + path
+      urlpath = urlpath + '?token=' + token if token
+      request = Net::HTTP::Delete.new urlpath
+      request['X-Signature'] = KeyUtils.sign(@uri.to_s + urlpath, @priv_key) 
+      request['X-Identity'] = @pub_key
+      process_request(request)
+    end
+
+    private
+
+    ## Processes HTTP Request and returns parsed response
+    # Otherwise throws error
+    #
+    def process_request(request)
+      request['User-Agent'] = @user_agent
+      request['Content-Type'] = 'application/json'
+      request['X-BitPay-Plugin-Info'] = 'Rubylib' + VERSION
+
+      begin
+        response = @https.request request
+      rescue => error
+        raise BitPay::ConnectionError, "#{error.message}"
+      end
+
+      if response.kind_of? Net::HTTPSuccess
+        return JSON.parse(response.body)
+      elsif JSON.parse(response.body)["error"]
+        raise(BitPayError, "#{response.code}: #{JSON.parse(response.body)['error']}")
+      else
+        raise BitPayError, "#{response.code}: #{JSON.parse(response.body)}"
+      end
+
+    end
+
+    ## Fetches the tokens hash from the server and
+    #  updates @tokens
+    #
+    def refresh_tokens
+      response = get(path: 'tokens')["data"]
+      token_array = response || {}
+      tokens = {}
+      token_array.each do |t|
+        tokens[t.keys.first] = t.values.first
+      end
+      @tokens = tokens
+      return tokens
+    end
+
+    ## Makes a request to /tokens for pairing
+    #     Adds passed params as post parameters
+    #     If empty params, retrieves server-generated pairing code
+    #     If pairingCode key/value is passed, will pair client ID to this account
+    #   Returns response hash
+    #
+
+    def get_token(facade)
+      token = @tokens[facade] || refresh_tokens[facade] || raise(BitPayError, "Not authorized for facade: #{facade}")
+    end
+
+  end
+end

data/lib/bitpay/version.rb

@@ -1,7 +1,7 @@
-# license Copyright 2011-2014 BitPay, Inc., MIT License
+# license Copyright 2011-2019 BitPay, Inc., MIT License
 # see http://opensource.org/licenses/MIT
 # or https://github.com/bitpay/php-bitpay-client/blob/master/LICENSE
 
 module BitPay
-  VERSION = '2.4.0'
+  VERSION = '2.5.1905'
 end

data/lib/bitpay_sdk.rb

@@ -0,0 +1,28 @@
+# license Copyright 2011-2014 BitPay, Inc., MIT License
+# see http://opensource.org/licenses/MIT
+# or https://github.com/bitpay/php-bitpay-client/blob/master/LICENSE
+
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+require 'bitpay/client'
+require 'bitpay/version'
+
+module BitPay
+
+  # Location of SSL Certificate Authority File
+  # As sourced from http://curl.haxx.se/ca/cacert.pem
+  CA_FILE = File.join File.dirname(__FILE__), 'bitpay','cacert.pem'
+
+  # Location of API
+  API_URI = 'https://bitpay.com'
+  TEST_API_URI = 'https://test.bitpay.com'
+  CLIENT_REGISTRATION_PATH = '/api-access-request'
+  
+
+  # User agent reported to API
+  USER_AGENT = 'BitPay_Ruby_Client_v'+VERSION
+  
+  class BitPayError < StandardError; end
+  class ConnectionError < Errno::ECONNREFUSED; end
+  
+end

data/spec/client_spec.rb

@@ -2,19 +2,82 @@ require 'spec_helper'
 
 def tokens
     {"data" => 
-      [{"merchant" => "MERCHANTTOKEN"},
-      {"pos" =>"POSTOKEN"},
+      [{"merchant" => "MERCHANT_TOKEN"},
+      {"pos" =>"POS_TOKEN"},
       {"merchant/invoice" => "9kv7gGqZLoQ2fxbKEgfgndLoxwjp5na6VtGSH3sN7buX"}
       ]
     }
 end
 
-describe BitPay::Client do
-  let(:bitpay_client) { BitPay::Client.new({api_uri: BitPay::TEST_API_URI}) }
+describe BitPay::SDK::Client do
+  let(:bitpay_client) { BitPay::SDK::Client.new({api_uri: BitPay::TEST_API_URI}) }
   let(:claim_code) { "a12bc3d" }
 
   before do
-      stub_request(:get, /#{BitPay::TEST_API_URI}\/tokens.*/).to_return(:status => 200, :body => tokens.to_json, :headers => {})
+      # Stub JSON responses from fixtures
+      stub_request(:get, /#{BitPay::TEST_API_URI}\/tokens.*/)
+        .to_return(:status => 200, :body => tokens.to_json, :headers => {})
+      stub_request(:get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID?token=MERCHANT_TOKEN").
+        to_return(:body => get_fixture('invoices_{id}-GET.json'))
+      stub_request(:get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID/refunds?token=MERCHANT_INVOICE_TOKEN").
+        to_return(:body => get_fixture('invoices_{id}_refunds-GET.json'))
+      stub_request(:get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID/refunds/TEST_REQUEST_ID?token=MERCHANT_INVOICE_TOKEN").
+        to_return(:body => get_fixture('invoices_{id}_refunds-GET.json'))
+      stub_request(:post, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID/refunds").
+        to_return(:body => get_fixture('invoices_{id}_refunds-POST.json'))
+      stub_request(:post, "#{BitPay::TEST_API_URI}/nuttin").
+        to_return(:body => get_fixture('response-nodata.json'))
+      stub_request(:get, "#{BitPay::TEST_API_URI}/nuttin").
+        to_return(:body => get_fixture('response-nodata.json'))
+      stub_request(:delete, "#{BitPay::TEST_API_URI}/nuttin").
+        to_return(:body => get_fixture('response-nodata.json'))
+  end
+
+  describe "#initialize" do
+
+    it 'should be able to get pem file from the env' do
+      stub_const('ENV', {'BITPAY_PEM' => PEM})
+      expect {bitpay_client}.to_not raise_error
+    end
+    
+  end
+
+  describe "requests to endpoint without data field" do
+    it "should return the json body" do
+      expect(bitpay_client.post(path: "nuttin", params: {})["facile"]).to eq("is easy")
+      expect(bitpay_client.get(path: "nuttin")["facile"]).to eq("is easy")
+      expect(bitpay_client.delete(path: "nuttin")["facile"]).to eq( "is easy")
+    end
+  end
+
+  describe "#send_request" do
+    before do
+      stub_const('ENV', {'BITPAY_PEM' => PEM})
+    end
+
+    context "GET" do    
+      it 'should generate a get request' do
+        stub_request(:get, /#{BitPay::TEST_API_URI}\/whatever.*/).to_return(:body => '{"awesome": "json"}')
+        bitpay_client.send_request("GET", "whatever", facade: "merchant")
+        expect(WebMock).to have_requested(:get, "#{BitPay::TEST_API_URI}/whatever?token=MERCHANT_TOKEN") 
+      end
+      
+      it 'should handle query parameters gracefully' do
+        stub_request(:get, /#{BitPay::TEST_API_URI}\/ledgers.*/).to_return(:body => '{"awesome": "json"}')
+        bitpay_client.send_request("GET", "ledgers/BTC?startDate=2015-01-01&endDate=2015-02-01", facade: "merchant")
+        expect(WebMock).to have_requested(:get, "#{BitPay::TEST_API_URI}/ledgers/BTC?startDate=2015-01-01&endDate=2015-02-01&token=MERCHANT_TOKEN")
+      end
+      
+    end
+
+    context "POST" do
+        it 'should generate a post request' do
+          stub_request(:post, /#{BitPay::TEST_API_URI}.*/).to_return(:body => '{"awesome": "json"}')
+          bitpay_client.send_request("POST", "whatever", facade: "merchant")
+          expect(WebMock).to have_requested(:post, "#{BitPay::TEST_API_URI}/whatever")
+        end
+    end
+
   end
 
   describe "#pair_pos_client" do
@@ -35,9 +98,93 @@ describe BitPay::Client do
     it 'short circuits on invalid pairing codes' do
       100.times do
         claim_code = an_illegal_claim_code
-        expect{bitpay_client.pair_pos_client(claim_code)}.to raise_error BitPay::ArgumentError, "pairing code is not legal"
+        expect { bitpay_client.pair_pos_client(claim_code) }.to raise_error BitPay::ArgumentError, "pairing code is not legal"
       end
     end
   end
 
+  describe "#create_invoice" do
+    subject { bitpay_client }
+    before {stub_const('ENV', {'BITPAY_PEM' => PEM})}
+    it { is_expected.to respond_to(:create_invoice) }
+
+    describe "should make the call to the server to create an invoice" do
+      it 'allows numeric input for the price' do
+        stub_request(:post, /#{BitPay::TEST_API_URI}\/invoices.*/).to_return(:body => '{"data": "awesome"}')
+        bitpay_client.create_invoice(price: 20.00, currency: "USD")
+        assert_requested :post, "#{BitPay::TEST_API_URI}/invoices"
+      end
+
+      it 'allows string input for the price' do
+        stub_request(:post, /#{BitPay::TEST_API_URI}\/invoices.*/).to_return(:body => '{"data": "awesome"}')
+        bitpay_client.create_invoice(price: "20.00", currency: "USD")
+        assert_requested :post, "#{BitPay::TEST_API_URI}/invoices"
+      end
+    end
+
+    it 'should pass through the API error message from load_tokens' do
+      stub_request(:get, /#{BitPay::TEST_API_URI}\/tokens.*/).to_return(status: 500, body: '{"error": "load_tokens_error"}')
+      expect { bitpay_client.create_invoice(price: 20, currency: "USD") }.to raise_error(BitPay::BitPayError, '500: load_tokens_error')         
+    end
+
+    it 'verifies the validity of the price argument' do
+      expect { bitpay_client.create_invoice(price: "3,999", currency: "USD") }.to raise_error(BitPay::ArgumentError, 'Illegal Argument: Price must be formatted as a float')
+    end
+    
+    it 'verifies the validity of the currency argument' do
+      expect { bitpay_client.create_invoice(price: "3999", currency: "UASD") }.to raise_error(BitPay::ArgumentError, 'Illegal Argument: Currency is invalid.')
+    end
+  end
+
+  describe '#refund_invoice' do
+    subject { bitpay_client }
+    before { stub_const('ENV', {'BITPAY_PEM' => PEM}) }
+    it { is_expected.to respond_to(:refund_invoice) }
+    
+    it 'should get the token for the invoice' do
+      bitpay_client.refund_invoice(id: 'TEST_INVOICE_ID')
+      expect(WebMock).to have_requested :get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID?token=MERCHANT_TOKEN"
+    end
+    
+    it 'should generate a POST to the invoices/refund endpoint' do
+      bitpay_client.refund_invoice(id: 'TEST_INVOICE_ID')
+      expect(WebMock).to have_requested :post, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID/refunds"
+    end
+  end
+  
+  describe '#get_all_refunds_for_invoice' do
+    subject { bitpay_client }
+    before {stub_const('ENV', {'BITPAY_PEM' => PEM})}
+    it { is_expected.to respond_to(:get_all_refunds_for_invoice) }  
+    
+    it 'should get the token for the invoice' do
+      bitpay_client.get_all_refunds_for_invoice(id: 'TEST_INVOICE_ID')
+      expect(WebMock).to have_requested :get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID?token=MERCHANT_TOKEN"
+    end
+    it 'should GET all refunds' do
+      bitpay_client.get_all_refunds_for_invoice(id: 'TEST_INVOICE_ID')
+      expect(WebMock).to have_requested :get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID/refunds?token=MERCHANT_INVOICE_TOKEN"
+    end
+  end
+    
+  describe '#get_refund' do
+    subject { bitpay_client }
+    before {stub_const('ENV', {'BITPAY_PEM' => PEM})}
+    it { is_expected.to respond_to(:get_refund) }  
+    it 'should get the token for the invoice' do
+      bitpay_client.get_refund(invoice_id: 'TEST_INVOICE_ID', request_id: 'TEST_REQUEST_ID')
+      expect(WebMock).to have_requested :get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID?token=MERCHANT_TOKEN"
+    end        
+    it 'should GET a single refund' do
+      bitpay_client.get_refund(invoice_id: 'TEST_INVOICE_ID', request_id: 'TEST_REQUEST_ID')
+      expect(WebMock).to have_requested :get, "#{BitPay::TEST_API_URI}/invoices/TEST_INVOICE_ID/refunds/TEST_REQUEST_ID?token=MERCHANT_INVOICE_TOKEN"
+    end
+  end
+
+  describe "#verify_tokens" do
+    subject { bitpay_client }
+    before {stub_const('ENV', {'BITPAY_PEM' => PEM})}
+    it { is_expected.to respond_to(:verify_tokens) }
+  end
 end
+