buttercoin 0.0.1

data/lib/buttercoin/client.rb

@@ -0,0 +1,135 @@
+require 'httparty'
+require 'hashie'
+require 'buttercoin/version'
+require 'buttercoin/client/unauth_methods'
+require 'buttercoin/client/account_query_methods'
+require 'buttercoin/client/order_methods'
+require 'buttercoin/client/transaction_methods'
+#require 'openssl'
+require 'base64'
+
+module Buttercoin
+  class Client
+    include HTTParty
+    include Buttercoin::Client::UnauthMethods
+    include Buttercoin::Client::AccountQueryMethods
+    include Buttercoin::Client::OrderMethods
+    include Buttercoin::Client::TransactionMethods
+
+    attr_accessor :public_key, :secret_key, :mode
+
+    CONFIG = {
+      :mode => "production"
+    }
+
+    PRODUCTION_URI = 'https://api.buttercoin.com/v1'
+    SANDBOX_URI = 'https://api.qa.dcxft.com/v1'
+
+    CA_CERT = 'cert/ca-cert.crt'
+
+    def initialize(*args)
+      options = args[0]
+      unless options.is_a?(Hash)
+        # deprecated, pass a hash of options instead
+        options = {
+          :public_key => args[0],
+          :secret_key => args[1],
+          :mode => args[2]
+        }
+      end
+
+      self.public_key, self.secret_key = options.values_at(:public_key, :secret_key)
+      self.mode = options[:mode] || CONFIG[:mode]
+      self.class.base_uri (options[:mode] == 'production') ? PRODUCTION_URI : SANDBOX_URI
+    end
+
+    # Wrappers for the main HTTP verbs
+
+    def get(path, timestamp=nil, options={}, authenticate=true)
+      http_request :get, path, timestamp, options, authenticate
+    end
+
+    def post(path, timestamp=nil, options={}, authenticate=true)
+      http_request :post, path, timestamp, options, authenticate
+    end
+
+    def delete(path, timestamp=nil, options={}, authenticate=true)
+      http_request :delete, path, timestamp, options, authenticate
+    end
+
+    def http_request(verb, path, timestamp=nil, options={}, authenticate=true)
+      request_options = {}
+      if (authenticate)
+        timestamp ||= ((Time.now.to_f * 1e3).round).to_i
+        message = build_message(verb, path, timestamp, options)
+        signature = get_signature(message)
+        request_options = {body: options.to_json} if [:post].include? verb
+        request_options[:headers] = get_headers(signature, timestamp)
+      end
+      set_cert()
+      r = self.class.send(verb, path, request_options)
+      process_response(r.code, r.body, r.headers)
+    end
+
+    private
+
+    def set_cert
+      path = File.expand_path( CA_CERT, __FILE__)
+      self.class.ssl_ca_file path
+    end
+
+    def build_message(verb, path, timestamp, options)
+      if [:get, :delete].include? verb
+        path = "#{path}?#{URI.encode_www_form(options)}" if !options.empty?
+        message = timestamp.to_s + self.class.base_uri + path
+      else
+        message = timestamp.to_s + self.class.base_uri + path + options.to_json
+      end
+      return message
+    end
+
+    def get_signature(message)
+      message = Base64.encode64(message).gsub(/\n/, "")
+      return Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), self.secret_key, message))
+    end
+
+    def get_headers(signature, timestamp)
+      return {
+        'X-Buttercoin-Access-Key' => self.public_key,
+        'X-Buttercoin-Signature' => signature,
+        'X-Buttercoin-Date' => timestamp.to_s,
+        "Content-Type" => "application/json"
+      }
+    end
+
+    def process_response(status_code, response_body, response_headers)
+      case status_code.to_i
+      when 200
+        return Hashie::Mash.new(JSON.parse(response_body))
+      when 201
+        return Hashie::Mash.new({ "status" => status_code, "message" => 'This operation requires email confirmation' })
+      when 202
+        return response_headers["location"]
+      when 204
+        return Hashie::Mash.new({ "status" => status_code, "message" => 'This operation has completed successfully' })
+      when 400
+        mash = Hashie::Mash.new(JSON.parse(response_body))
+        raise BadRequestError.new(mash.errors.first.message)
+      when 401
+        mash = Hashie::Mash.new(JSON.parse(response_body))
+        raise AuthenticationError.new(mash.errors.first.message)
+      when 404
+        mash = Hashie::Mash.new(JSON.parse(response_body))
+        raise NotFoundError.new(mash.errors.first.message)
+      else
+        begin
+          mash = Hashie::Mash.new(JSON.parse(response_body))
+          raise HttpError.new(mash.errors.first.message)
+        rescue
+          raise HttpError.new(response_body)
+        end
+      end
+    end
+
+  end
+end

data/lib/buttercoin/client/account_query_methods.rb

@@ -0,0 +1,32 @@
+module Buttercoin
+  class Client
+    module AccountQueryMethods
+
+      # Retrieve the ticker
+      #
+      # @param timestamp integer (optional)
+
+      def get_key(timestamp=nil)
+        get '/key', timestamp
+      end
+
+      # Retrieve the account balanaces for all currencies
+      #
+      # @param timestamp integer (optional)
+
+      def get_balances(timestamp=nil)
+        get '/account/balances', timestamp
+      end
+
+      # Retrieve the bitcoin deposit address
+      #
+      # @param timestamp integer (optional)
+
+      def get_deposit_address(timestamp=nil)
+        mash = get '/account/depositAddress', timestamp
+        mash.address
+      end
+
+    end
+  end
+end

data/lib/buttercoin/client/order_methods.rb

@@ -0,0 +1,66 @@
+module Buttercoin
+  class Client
+    module OrderMethods
+
+      # Retrieve the order by id
+      #
+      # @orderId string
+      # @param timestamp integer (optional)
+      #
+      # @return Hashie object containing order info
+
+      def get_order_by_id(orderId, timestamp=nil)
+        get '/orders/'+orderId, timestamp
+      end
+
+      # Retrieve the order by url
+      #
+      # @param url full url of the order request
+      # @param timestamp integer (optional)
+      #
+      # @return Hashie object containing order info
+
+      def get_order_by_url(url, timestamp=nil)
+        index = url.rindex('/orders')
+        raise Error.new('Url not correctly formatted for orders') if index.nil?
+        path = url[index..-1]
+        get path, timestamp
+      end
+
+      # Get list of orders by search criteria
+      # 
+      # @param timestamp integer (optional)
+      # @param options Hash (optional) criteria to filter list
+      #
+      # @return Hashie object containing list of orders
+
+      def get_orders(options={}, timestamp=nil)
+        mash = get '/orders', timestamp, options
+        mash.results
+      end
+
+      # Create new order with the given params
+      # 
+      # @param timestamp integer (optional)
+      # @param options Hash (required) order params
+      #
+      # @return string containing response location header url
+
+      def create_order(options, timestamp=nil)
+        post '/orders', timestamp, options
+      end
+
+      # Cancel order by id
+      #
+      # @orderId string
+      # @param timestamp integer (optional)
+      #
+      # @return Hashie object containing status and success message
+
+      def cancel_order(orderId, timestamp=nil)
+        delete '/orders/'+orderId, timestamp
+      end
+
+    end
+  end
+end

data/lib/buttercoin/client/transaction_methods.rb

@@ -0,0 +1,89 @@
+module Buttercoin
+  class Client
+    module TransactionMethods
+
+      # Retrieve the transaction by id
+      #
+      # @transactionId string
+      # @param timestamp integer (optional)
+      #
+      # @return Hashie object containing transaction info
+
+      def get_transaction_by_id(transactionId, timestamp=nil)
+        get '/transactions/'+transactionId, timestamp
+      end
+
+      # Retrieve the transaction by url
+      #
+      # @param url full url of the transaction request
+      # @param timestamp integer (optional)
+      #
+      # @return Hashie object containing transaction info
+
+      def get_transaction_by_url(url, timestamp=nil)
+        index = url.rindex('/transactions')
+        raise Error.new('Url not correctly formatted for transactions') if index.nil?
+        path = url[index..-1]
+        get path, timestamp
+      end
+
+      # Get list of transactions by search criteria
+      # 
+      # @param timestamp integer (optional)
+      # @param options Hash (optional) criteria to filter list
+      #
+      # @return Hashie object containing list of transactions
+
+      def get_transactions(options={}, timestamp=nil)
+        mash = get '/transactions', timestamp, options
+        mash.results
+      end
+
+      # Create new deposit with the given params
+      # 
+      # @param timestamp integer (optional)
+      # @param options Hash (required) transaction params
+      #
+      # @return string containing response location header url
+
+      def create_deposit(options, timestamp=nil)
+        post '/transactions/deposit', timestamp, options
+      end
+
+      # Create new withdrawal with the given params
+      # 
+      # @param timestamp integer (optional)
+      # @param options Hash (required) transaction params
+      #
+      # @return string containing response location header url
+
+      def create_withdrawal(options, timestamp=nil)
+        post '/transactions/withdraw', timestamp, options
+      end
+
+      # Create new bitcoin withdrawal with the given params
+      # 
+      # @param timestamp integer (optional)
+      # @param options Hash (required) transaction params
+      #
+      # @return string containing response location header url
+
+      def send_bitcoin(options, timestamp=nil)
+        post '/transactions/send', timestamp, options
+      end
+
+      # Cancel transaction by id
+      #
+      # @transactionId string
+      # @param timestamp integer (optional)
+      #
+      # @return Hashie object containing status and success message
+
+      def cancel_transaction(transactionId, timestamp=nil)
+        delete '/transactions/'+transactionId, timestamp
+      end
+
+    end
+  end
+end
+

data/lib/buttercoin/client/unauth_methods.rb

@@ -0,0 +1,23 @@
+module Buttercoin
+  class Client
+    module UnauthMethods
+
+      # Retrieve the ticker
+      #
+      # @return Hashie object containing market price info
+
+      def get_ticker
+        get '/ticker', nil, {}, false
+      end
+
+      # Retrieve the orderbook
+      #
+      # @return Hashie object containing order book info
+
+      def get_order_book
+        get '/orderbook', nil, {}, false
+      end
+
+    end
+  end
+end

data/lib/buttercoin/version.rb

@@ -0,0 +1,3 @@
+module Buttercoin
+  VERSION = "0.0.1"
+end

data/spec/buttercoin/client_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'fakeweb'
+require 'buttercoin'
+
+describe Buttercoin::Client do
+
+  let(:public_key) { 'public key' }
+  let(:secret_key) { 'secret key' }
+  let(:mode) { 'sandbox' }
+  let(:client) { Buttercoin::Client.new(:public_key => public_key, :secret_key => secret_key) }
+  
+
+  before :all do
+    FakeWeb.allow_net_connect = false
+  end
+
+  describe "Initialize client" do
+    it "should initialize with the given options" do
+      client = Buttercoin::Client.new(
+        :public_key => public_key,
+        :secret_key => secret_key,
+        :mode => mode
+      )
+      expect(client.public_key).to eq('public key')
+      expect(client.secret_key).to eq('secret key')
+      expect(client.mode).to eq('sandbox')
+    end
+
+    it "should set the base_uri to the sandbox" do
+      expect(Buttercoin::Client.new.class.base_uri).to eq(Buttercoin::Client::SANDBOX_URI)
+    end
+  end
+
+  describe "Sign the request" do
+    let(:build_message) { client.method(:build_message) }
+    let(:get_signature) { client.method(:get_signature) }
+    let(:get_headers) { client.method(:get_headers) }
+    let(:timestamp) { 1444444444444 }
+    let(:path) { '/orders' }
+    let(:options) do { :status => "opened" } end
+    let(:message) { "1444444444444https://api.qa.dcxft.com/v1/orders?status=opened" }
+    let(:signature) { "0OBOwbOX3npNPyI6TLq+PN2jpW1NhLn+St0FOpcKvMc=\n" }
+
+    it "should build proper get request message for signing" do
+      expect(build_message.call(:get, path, timestamp, options)).to eq("1444444444444https://api.qa.dcxft.com/v1/orders?status=opened")
+    end
+
+    it "should build proper get request message for signing" do
+      expect(build_message.call(:post, path, timestamp, options)).to eq("1444444444444https://api.qa.dcxft.com/v1/orders{\"status\":\"opened\"}")
+    end
+
+    it "should properly sign a message with the given key" do
+      expect(get_signature.call(message)).to eq (signature)
+    end
+
+    it "should properly build the request headers" do
+      headers = {
+        'X-Buttercoin-Access-Key' => public_key,
+        'X-Buttercoin-Signature' => signature,
+        'X-Buttercoin-Date' => timestamp.to_s,
+        "Content-Type" => "application/json"
+      }
+      expect(get_headers.call(signature, timestamp)).to eq (headers)
+    end
+  end
+
+  describe "process_response" do
+    let(:body) { "{ \"text\": \"stuff\" }" }
+    let(:error_body) { "{ \"errors\": [ {\"message\": \"stuff\"} ] }" }
+    let(:headers) { JSON.parse("{ \"location\": \"http://fake.api.buttercoin.com\" }") }
+    let (:process_response) { client.method(:process_response) }
+
+    it "should return a Hashie::Mash object for a 200" do
+      expect(process_response.call(200, body, headers).text).to eq "stuff"
+    end
+
+    it "should return a success message in a Hashie::Mash object for a 201" do
+      expect(process_response.call(201, body, headers).message).to eq "This operation requires email confirmation"
+    end
+
+    it "should return a location header string for a 202" do
+      expect(process_response.call(202, body, headers)).to eq "http://fake.api.buttercoin.com"
+    end
+
+    it "should return a Hashie::Mash object for a 204" do
+      expect(process_response.call(204, body, headers).message).to eq "This operation has completed successfully"
+    end
+
+    it "should raise a BadRequestError for a 400" do
+      expect{process_response.call(400, error_body, headers)}.to raise_error(Buttercoin::BadRequestError, "Buttercoin Exception: stuff") 
+    end
+
+    it "should raise a BadRequestError for a 401" do
+      expect{process_response.call(401, error_body, headers)}.to raise_error(Buttercoin::AuthenticationError, "Buttercoin Exception: stuff") 
+    end
+
+    it "should raise a BadRequestError for a 404" do
+      expect{process_response.call(404, error_body, headers)}.to raise_error(Buttercoin::NotFoundError, "Buttercoin Exception: stuff") 
+    end
+
+    it "should raise a BadRequestError for a 429" do
+      expect{process_response.call(429, error_body, headers)}.to raise_error(Buttercoin::HttpError, "Buttercoin Exception: stuff") 
+    end
+  end
+end