bitpay-sdk 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f62c21b534bf518ba18041a4ef0035c1b0813da
-  data.tar.gz: 1464d4971a9dc7d3d83bf52db905f3fe88a389bb
+  metadata.gz: 05ceac9c5a451d327ccaca3d7d5df7b4b791612e
+  data.tar.gz: 8bd0c8fd5d09f22b9a90dfcb8dd80ea841b70b4f
 SHA512:
-  metadata.gz: 8f6fcbd6e1b24b51d11eef2c951de9d06106aa39d14136ede7e6829de8b8afa2c6865968de62de0f37b60e151a2e5dd9712a0be628c50fe4073a505179339629
-  data.tar.gz: 9d7d03a789872bea2474f12eb96472e64fd7ed69f25c1a05390fd645363e9c62041860fe7c835ffcc506989f5238714076a166abcab977ae2257f9ed21a891ef
+  metadata.gz: 35f0005e156651cf165e3ae64bd42feecca410d7a9ac01dc0dcf3fd4c1e9596cbfe3d45de8c7a98214f95d0fe9ac8fca1a5e96707dbfd2064db9f5abd477353d
+  data.tar.gz: 431badf6d99383c1670af5f60599186a6c830e62953de356c93e913dedcc6d5738d588de75aadb1cdcc10e45a4edb31ea215845fc6d584d037012842a28f86bd

data/README.md

@@ -3,15 +3,15 @@ Powerful, flexible, lightweight interface to the BitPay Bitcoin Payment Gateway
 
 ## Installation
 
-    gem install bitpay
+    gem install bitpay-sdk
     
 In your Gemfile:
 
-    gem 'bitpay', :require => 'bitpay'
+    gem 'bitpay-sdk', :require => 'bitpay_sdk'
 
 Or directly:
 
-    require 'bitpay'
+    require 'bitpay_sdk'
 
 ## Configuration
 

data/features/step_definitions/invoice_steps.rb

@@ -20,7 +20,7 @@ Given(/^that a user knows an invoice id$/) do
 end
 
 Then(/^they can retrieve that invoice$/) do
-  invoice = BitPay::Client.new(api_uri: ROOT_ADDRESS, insecure: true).get_public_invoice(id: @id)
+  invoice = BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, insecure: true).get_public_invoice(id: @id)
   raise "That's the wrong invoice" unless invoice['id'] == @id
 end
 

data/features/step_definitions/keygen_steps.rb

@@ -4,14 +4,14 @@
 When(/^the user pairs with BitPay(?: with a valid pairing code|)$/) do
   claim_code = get_claim_code_from_server
   pem = BitPay::KeyUtils.generate_pem
-  @client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
+  @client = BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
   @token = @client.pair_pos_client(claim_code)
 end
 
 When(/^the fails to pair with BitPay because of an incorrect port$/) do
   pem = BitPay::KeyUtils.generate_pem
   address = ROOT_ADDRESS.split(':').slice(0,2).join(':') + ":999"
-  client = BitPay::Client.new(api_uri: address, pem: pem, insecure: true)
+  client = BitPay::SDK::Client.new(api_uri: address, pem: pem, insecure: true)
   begin
     client.pair_pos_client("1ab2c34")
     raise "pairing unexpectedly worked"
@@ -35,7 +35,7 @@ end
 
 Then(/^the user fails to pair with a semantically (?:in|)valid code "(.*?)"$/) do |code|
   pem = BitPay::KeyUtils.generate_pem
-  client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
+  client = BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
   begin
     client.pair_pos_client(code)
     raise "pairing unexpectedly worked"

data/features/step_definitions/step_helpers.rb

@@ -1,9 +1,7 @@
 require 'capybara/poltergeist'
 require 'pry'
 
-require File.join File.dirname(__FILE__), '..', '..', 'lib', 'bitpay', 'client.rb'
-require File.join File.dirname(__FILE__), '..', '..', 'lib', 'bitpay', 'key_utils.rb'
-require File.join File.dirname(__FILE__), '..', '..', 'lib', 'bitpay.rb'
+require File.join File.dirname(__FILE__), '..', '..', 'lib', 'bitpay_sdk.rb'
 require_relative '../../config/constants.rb'
 require_relative '../../config/capybara.rb'
 
@@ -48,7 +46,7 @@ end
 def new_paired_client
   claim_code = get_claim_code_from_server
   pem = BitPay::KeyUtils.generate_pem
-  client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
+  client = BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
   client.pair_pos_client(claim_code)
   client
 end
@@ -57,11 +55,11 @@ def new_client_from_stored_values
   if File.file?(BitPay::PRIVATE_KEY_PATH) && File.file?(BitPay::TOKEN_FILE_PATH)
     token = get_token_from_file
     pem = File.read(BitPay::PRIVATE_KEY_PATH)
-    BitPay::Client.new(pem: pem, tokens: token, insecure: true, api_uri: ROOT_ADDRESS )
+    BitPay::SDK::Client.new(pem: pem, tokens: token, insecure: true, api_uri: ROOT_ADDRESS )
   else
     claim_code = get_claim_code_from_server
     pem = BitPay::KeyUtils.generate_pem
-    client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
+    client = BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true)
     token = client.pair_pos_client(claim_code)
     File.write(BitPay::PRIVATE_KEY_PATH, pem)
     File.write(BitPay::TOKEN_FILE_PATH, JSON.generate(token))

data/lib/bitpay/client.rb

@@ -11,171 +11,173 @@ require_relative 'key_utils'
 module BitPay
   # This class is used to instantiate a BitPay Client object. It is expected to be thread safe.
   #
-  class Client
-    
-
-    # @return [Client]
-    # @example
-    #  # Create a client with a pem file created by the bitpay client:
-    #  client = BitPay::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.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
+  module SDK
+    class Client
       
-      # Option to enable http request debugging
-      @https.set_debug_output($stdout) if opts[:debug] == true
 
-    end
-
-    def pair_pos_client(claimCode)
-      raise BitPay::ArgumentError, "pairing code is not legal" unless verify_claim_code(claimCode)
-      response = set_pos_token(claimCode)
-      get_token 'pos'
-      response
-    end
-
-    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) )
-      raise BitPay::ArgumentError, "Illegal Argument: Currency is invalid." unless /^[[:upper:]]{3}$/.match(currency)
-      params.merge!({price: price, currency: currency})
-      response = send_request("POST", "invoices", facade: facade, params: params)
-      response["data"]
-    end
-
-    def get_public_invoice(id:)
-      request = Net::HTTP::Get.new("/invoices/#{id}")
-      response = process_request(request)
-      response["data"]
-    end
-    
-    def set_token
-    end
+      # @return [Client]
+      # @example
+      #  # Create a client with a pem file created by the bitpay client:
+      #  client = BitPay::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.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
 
-    def verify_token
-      server_tokens = load_tokens
-      @tokens.each{|key, value| return false if server_tokens[key] != value}
-      return true
-    end
-    ## Generates REST request to api endpoint
-
-    def send_request(verb, path, facade: 'merchant', params: {}, token: nil)
-      token ||= get_token(facade)
-
-      # Verb-specific logic
-      case verb.upcase
-        when "GET"
-          urlpath = '/' + path + '?nonce=' + KeyUtils.nonce + '&token=' + token
-          request = Net::HTTP::Get.new urlpath
-          request['X-Signature'] = KeyUtils.sign(@uri.to_s + urlpath, @priv_key)
-
-        when "PUT"
-
-        when "POST"  # Requires a GUID
-
-          urlpath = '/' + path
-          request = Net::HTTP::Post.new urlpath
-          params[:token] = token
-          params[:nonce] = KeyUtils.nonce
-          params[:guid]  = SecureRandom.uuid
-          params[:id] = @client_id
-          request.body = params.to_json
-          request['X-Signature'] = KeyUtils.sign(@uri.to_s + urlpath + request.body, @priv_key)
-
-        when "DELETE"
-       
-          raise(BitPayError, "Invalid HTTP verb: #{verb.upcase}")
       end
 
-      # Build request headers and submit
-      request['X-Identity'] = @pub_key
- 
-      response = process_request(request)
-    end
-
-##### PRIVATE METHODS #####
-    private
+      def pair_pos_client(claimCode)
+        raise BitPay::ArgumentError, "pairing code is not legal" unless verify_claim_code(claimCode)
+        response = set_pos_token(claimCode)
+        get_token 'pos'
+        response
+      end
 
-    ## Processes HTTP Request and returns parsed response
-    # Otherwise throws error
-    #
-    def process_request(request)
+      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) )
+        raise BitPay::ArgumentError, "Illegal Argument: Currency is invalid." unless /^[[:upper:]]{3}$/.match(currency)
+        params.merge!({price: price, currency: currency})
+        response = send_request("POST", "invoices", facade: facade, params: params)
+        response["data"]
+      end
 
-      request['User-Agent'] = @user_agent
-      request['Content-Type'] = 'application/json'
-      request['X-BitPay-Plugin-Info'] = 'Rubylib' + VERSION
+      def get_public_invoice(id:)
+        request = Net::HTTP::Get.new("/invoices/#{id}")
+        response = process_request(request)
+        response["data"]
+      end
+      
+      def set_token
+      end
 
-      begin
-        response = @https.request request
-      rescue => error
-        raise BitPay::ConnectionError, "#{error.message}"
+      def verify_token
+        server_tokens = load_tokens
+        @tokens.each{|key, value| return false if server_tokens[key] != value}
+        return true
+      end
+      ## Generates REST request to api endpoint
+
+      def send_request(verb, path, facade: 'merchant', params: {}, token: nil)
+        token ||= get_token(facade)
+
+        # Verb-specific logic
+        case verb.upcase
+          when "GET"
+            urlpath = '/' + path + '?nonce=' + KeyUtils.nonce + '&token=' + token
+            request = Net::HTTP::Get.new urlpath
+            request['X-Signature'] = KeyUtils.sign(@uri.to_s + urlpath, @priv_key)
+
+          when "PUT"
+
+          when "POST"  # Requires a GUID
+
+            urlpath = '/' + path
+            request = Net::HTTP::Post.new urlpath
+            params[:token] = token
+            params[:nonce] = KeyUtils.nonce
+            params[:guid]  = SecureRandom.uuid
+            params[:id] = @client_id
+            request.body = params.to_json
+            request['X-Signature'] = KeyUtils.sign(@uri.to_s + urlpath + request.body, @priv_key)
+
+          when "DELETE"
+         
+            raise(BitPayError, "Invalid HTTP verb: #{verb.upcase}")
+        end
+
+        # Build request headers and submit
+        request['X-Identity'] = @pub_key
+   
+        response = process_request(request)
       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)}"
+  ##### PRIVATE METHODS #####
+      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
-        
-    end
 
-    ## Requests token by appending nonce and signing URL
-    #  Returns a hash of available tokens
-    #
-    def load_tokens
+      ## Requests token by appending nonce and signing URL
+      #  Returns a hash of available tokens
+      #
+      def load_tokens
 
-      urlpath = '/tokens?nonce=' + KeyUtils.nonce
+        urlpath = '/tokens?nonce=' + KeyUtils.nonce
 
-      request = Net::HTTP::Get.new(urlpath)
-      request['x-identity'] = @pub_key
-      request['x-signature'] = KeyUtils.sign(@uri.to_s + urlpath, @priv_key)
+        request = Net::HTTP::Get.new(urlpath)
+        request['x-identity'] = @pub_key
+        request['x-signature'] = KeyUtils.sign(@uri.to_s + urlpath, @priv_key)
 
-      response = process_request(request)
+        response = process_request(request)
 
-      token_array = response["data"] || {}
+        token_array = response["data"] || {}
 
-      tokens = {}
-      token_array.each do |t|
-        tokens[t.keys.first] = t.values.first
-      end
+        tokens = {}
+        token_array.each do |t|
+          tokens[t.keys.first] = t.values.first
+        end
 
-      @tokens = tokens
-      return tokens
+        @tokens = tokens
+        return tokens
 
-    end
+      end
 
-    ## Retrieves specified token from hash, otherwise tries to refresh @tokens and retry
-    def set_pos_token(claim_code)
-      params = {pairingCode: claim_code}
-      urlpath = '/tokens'
-      request = Net::HTTP::Post.new urlpath
-      params[:guid] = SecureRandom.uuid
-      params[:id] = @client_id
-      request.body = params.to_json
-      process_request(request)
-    end
+      ## Retrieves specified token from hash, otherwise tries to refresh @tokens and retry
+      def set_pos_token(claim_code)
+        params = {pairingCode: claim_code}
+        urlpath = '/tokens'
+        request = Net::HTTP::Post.new urlpath
+        params[:guid] = SecureRandom.uuid
+        params[:id] = @client_id
+        request.body = params.to_json
+        process_request(request)
+      end
 
-    def get_token(facade)
-      token = @tokens[facade] || load_tokens[facade] || raise(BitPayError, "Not authorized for facade: #{facade}")
-    end
+      def get_token(facade)
+        token = @tokens[facade] || load_tokens[facade] || raise(BitPayError, "Not authorized for facade: #{facade}")
+      end
 
-    def verify_claim_code(claim_code)
-      regex = /^[[:alnum:]]{7}$/
-      matches = regex.match(claim_code)
-      !(matches.nil?)
+      def verify_claim_code(claim_code)
+        regex = /^[[:alnum:]]{7}$/
+        matches = regex.match(claim_code)
+        !(matches.nil?)
+      end
     end
   end
 end

data/lib/bitpay/key_utils.rb

@@ -47,7 +47,7 @@ module BitPay
       end
 
       def get_private_key_from_pem pem
-        raise BitPayError, MISSING_PEM
+        raise BitPayError, MISSING_PEM unless pem
         key = OpenSSL::PKey::EC.new(pem)
         get_private_key key
       end

data/lib/bitpay/version.rb

@@ -3,5 +3,5 @@
 # or https://github.com/bitpay/php-bitpay-client/blob/master/LICENSE
 
 module BitPay
-  VERSION = '2.1.1'
+  VERSION = '2.2.0'
 end

data/lib/{bitpay.rb → bitpay_sdk.rb}

@@ -20,7 +20,7 @@ module BitPay
   
 
   # User agent reported to API
-  USER_AGENT = 'ruby-bitpay-client '+VERSION
+  USER_AGENT = 'ruby-bitpay-sdk '+VERSION
   
   MISSING_PEM = 'No pem file specified. Pass pem string'
   

data/spec/client_spec.rb

@@ -9,8 +9,8 @@ def tokens
     }
 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

data/spec/features/pair_spec.rb

@@ -14,7 +14,7 @@ describe "pairing a token", javascript: true, type: :feature do
     find(".token-claimcode", match: :first).text
   end
   let(:pem) { BitPay::KeyUtils.generate_pem }
-  let(:client) { BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true) }
+  let(:client) { BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, pem: pem, insecure: true) }
 
   context "pairing an unpaired client" do
     it "should have no tokens before pairing" do

data/spec/features/pos_spec.rb

@@ -16,7 +16,7 @@ describe "create an invoice", javascript: true, type: :feature do
       find(".token-claimcode", match: :first).text
     }
     set_client = -> {
-      client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: PEM, insecure: true)
+      client = BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, pem: PEM, insecure: true)
       client.pair_pos_client(get_claim_code.call)
       client
     }

data/spec/features/verify_tokens_spec.rb

@@ -21,7 +21,7 @@ describe "create an invoice", javascript: true, type: :feature do
       find(".token-claimcode", match: :first).text
     }
     set_client = -> {
-      client = BitPay::Client.new(api_uri: ROOT_ADDRESS, pem: PEM, insecure: true)
+      client = BitPay::SDK::Client.new(api_uri: ROOT_ADDRESS, pem: PEM, insecure: true)
       client.pair_pos_client(get_claim_code.call)
       client
     }

data/spec/spec_helper.rb

@@ -3,9 +3,7 @@ require 'pry'
 require 'capybara/rspec'
 require 'capybara/poltergeist'
 
-require File.join File.dirname(__FILE__), '..', 'lib', 'bitpay', 'client.rb'
-require File.join File.dirname(__FILE__), '..', 'lib', 'bitpay', 'key_utils.rb'
-require File.join File.dirname(__FILE__), '..', 'lib', 'bitpay.rb'
+require File.join File.dirname(__FILE__), '..', 'lib', 'bitpay_sdk.rb'
 require_relative '../config/constants.rb'
 require_relative '../config/capybara.rb'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitpay-sdk
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Bitpay, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-06 00:00:00.000000000 Z
+date: 2015-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -228,12 +228,11 @@ files:
 - features/step_definitions/invoice_steps.rb
 - features/step_definitions/keygen_steps.rb
 - features/step_definitions/step_helpers.rb
-- lib/bitpay.rb
 - lib/bitpay/cacert.pem
 - lib/bitpay/client.rb
 - lib/bitpay/key_utils.rb
 - lib/bitpay/version.rb
-- lib/harness.rb
+- lib/bitpay_sdk.rb
 - spec/client_spec.rb
 - spec/features/pair_spec.rb
 - spec/features/pos_spec.rb

data/lib/harness.rb

@@ -1,40 +0,0 @@
-# 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
-
-require_relative 'bitpay.rb'
-require_relative 'bitpay/key_utils.rb'
-
-# Test SIN Generation class methods
-
-# Generate SIN
-ENV["PRIV_KEY"] = "16d7c3508ec59773e71ae728d29f41fcf5d1f380c379b99d68fa9f552ce3ebc3"
-puts "privkey: #{ENV['PRIV_KEY']}"
-puts "target SIN: TfFVQhy2hQvchv4VVG4c7j4XPa2viJ9HrR8"
-puts "Derived SIN: #{BitPay::KeyUtils.get_client_id}"
-
-puts "\n\n------------------\n\n"
-
-uri = "https://localhost:8088"
-#name = "Ridonculous.label That shouldn't work really"
-name = "somethinginnocuous"
-facade = "pos"
-client_id = BitPay::KeyUtils.get_client_id
-
-BitPay::KeyUtils.generate_registration_url(uri,name,facade,client_id)
-
-puts "\n\n------------------\n\n"
-
-#### Test Invoice Creation using directly assigned keys 
-## (Ultimately pubkey and SIN should be derived)
-
-ENV["PRIV_KEY"] = "16d7c3508ec59773e71ae728d29f41fcf5d1f380c379b99d68fa9f552ce3ebc3"
-#ENV["pub_key"] = "0353a036fb495c5846f26a3727a28198da8336ae4f5aaa09e24c14a4126b5d969d"
-#ENV['SIN'] = "TfFVQhy2hQvchv4VVG4c7j4XPa2viJ9HrR8"
-
-client = BitPay::Client.new({insecure: true, debug: false})
-
-invoice = client.post 'invoices', {:price => 10.00, :currency => 'USD'}
-
-puts "Here's the invoice: \n" + JSON.pretty_generate(invoice)
-