bitstamper 0.1.0

data/lib/bitstamper/models/order.rb

@@ -0,0 +1,48 @@
+module Bitstamper
+  module Models
+    class Order < Base
+      attr_accessor :id, :currency_pair, :type, :order_type, :price, :amount, :datetime
+      attr_accessor :event, :error, :message
+      
+      BUY   =   0
+      SELL  =   1
+      
+      MAPPING             =   {
+        "id"              =>   :string,
+        "currency_pair"   =>   :string,
+        "type"            =>   :integer,
+        "price"           =>   :float,
+        "amount"          =>   :float,
+        "event"           =>   :string
+      }
+      
+      def initialize(hash)
+        hash["type"]      =     hash["order_type"] if hash.fetch("type", nil).to_s.empty? && hash.has_key?("order_type")
+        
+        hash.each do |key, value|
+          type            =     ::Bitstamper::Models::Order::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Bitstamper::Utilities::convert_value(value, type) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+        
+        datetime          =     hash.fetch("datetime", nil)&.to_s
+        
+        if !datetime.to_s.empty? && datetime.include?("-")
+          self.datetime   =     ::Bitstamper::Utilities::convert_value(datetime, :datetime)
+        elsif !datetime.to_s.empty? && ::Bitstamper::Utilities.numeric?(datetime)
+          self.datetime   =     ::Bitstamper::Utilities::convert_value(datetime, :time)
+        end
+        
+        self.order_type   =     case self.type
+          when ::Bitstamper::Models::Order::BUY  then :buy
+          when ::Bitstamper::Models::Order::SELL then :sell
+        end
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| ::Bitstamper::Models::Order.new(item) }
+      end
+      
+    end
+  end
+end

data/lib/bitstamper/models/order_book.rb

@@ -0,0 +1,28 @@
+module Bitstamper
+  module Models
+    class OrderBook
+      attr_accessor :timestamp, :bids, :asks
+      
+      def initialize(hash)
+        self.bids   =   []
+        self.asks   =   []
+        
+        self.timestamp  =  ::Bitstamper::Utilities.epoch_to_time(hash.fetch("timestamp", nil)) if hash.has_key?("timestamp") && !hash.fetch("timestamp", nil).to_s.empty?
+        
+        process(hash)
+      end
+      
+      def process(hash)
+        [:bids, :asks].each do |type|
+          hash.fetch(type.to_s, []).each do |item|
+            price     =   item&.first&.to_f
+            quantity  =   item&.last&.to_f
+            value     =   !price.nil? && !quantity.nil? ? price * quantity : nil
+            self.send(type).send(:<<, {price: price, quantity: quantity, value: value})
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/bitstamper/models/ticker.rb

@@ -0,0 +1,33 @@
+module Bitstamper
+  module Models
+    class Ticker < Base
+      attr_accessor :last, :high, :low, :volume, :bid, :ask, :timestamp, :vwap, :open, :currency_pair
+      
+      MAPPING             =   {
+        "high"          =>    :float,
+        "last"          =>    :float,
+        "timestamp"     =>    :time,
+        "bid"           =>    :float,
+        "vwap"          =>    :float,
+        "volume"        =>    :float,
+        "low"           =>    :float,
+        "ask"           =>    :float,
+        "open"          =>    :float,
+        "currency_pair" =>    :string,
+      }
+    
+      def initialize(hash)
+        hash.each do |key, value|
+          type            =     ::Bitstamper::Models::Ticker::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Bitstamper::Utilities::convert_value(value, type) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| ::Bitstamper::Models::Ticker.new(item) }
+      end
+
+    end
+  end
+end

data/lib/bitstamper/models/trading_pair.rb

@@ -0,0 +1,35 @@
+module Bitstamper
+  module Models
+    class TradingPair < Base
+      attr_accessor :name, :url_symbol, :description
+      attr_accessor :base_decimals, :counter_decimals, :minimum_order, :trading
+      
+      MAPPING             =   {
+        "name"              =>   :string,
+        "url_symbol"        =>   :string,
+        "description"       =>   :string,
+        "base_decimals"     =>   :integer,
+        "counter_decimals"  =>   :integer,
+        "minimum_order"     =>   :string,
+        "trading"           =>   :string,
+      }
+      
+      def initialize(hash)
+        hash.each do |key, value|
+          type            =     ::Bitstamper::Models::TradingPair::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Bitstamper::Utilities::convert_value(value, type) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+      end
+      
+      def enabled?
+        self.trading.downcase.strip.eql?("enabled")
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| ::Bitstamper::Models::TradingPair.new(item) }
+      end
+      
+    end
+  end
+end

data/lib/bitstamper/models/transaction.rb

@@ -0,0 +1,37 @@
+module Bitstamper
+  module Models
+    class Transaction < Base
+      attr_accessor :id, :type, :transaction_type, :date, :price, :amount
+      
+      TYPES               =   {
+        0 => :buy,
+        1 => :sell
+      }
+      
+      MAPPING             =   {
+        "id"              =>   :string,
+        "type"            =>   :integer,
+        "date"            =>   :time,
+        "price"           =>   :float,
+        "amount"          =>   :float,
+      }
+      
+      def initialize(hash)
+        hash.each do |key, value|
+          type            =     ::Bitstamper::Models::Transaction::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Bitstamper::Utilities::convert_value(value, type) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+        
+        self.id           =     hash.fetch("id", hash.fetch("tid", nil))&.to_s
+        
+        self.transaction_type = TYPES[self.type]
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| ::Bitstamper::Models::Transaction.new(item) }
+      end
+      
+    end
+  end
+end

data/lib/bitstamper/models/user_transaction.rb

@@ -0,0 +1,55 @@
+module Bitstamper
+  module Models
+    class UserTransaction < Base
+      attr_accessor :id, :order_id, :type, :transaction_type, :datetime, :fee
+      attr_accessor :usd, :eur
+      attr_accessor :btc, :btc_usd, :btc_eur
+      attr_accessor :eth, :eth_btc, :eth_usd, :eth_eur
+      attr_accessor :ltc, :xrp, :bch
+      
+      TYPES = {
+        0   =>  :deposit,
+        1   =>  :withdrawal,
+        2   =>  :market_trade,
+        14  =>  :sub_account_transfer 
+      }
+      
+      MAPPING             =   {
+        "id"              =>   :string,
+        "order_id"        =>   :string,
+        "type"            =>   :integer,
+        "datetime"        =>   :datetime,
+        "fee"             =>   :float,
+        "usd"             =>   :float,
+        "eur"             =>   :float,
+        "btc"             =>   :float,
+        "btc_usd"         =>   :float,
+        "btc_eur"         =>   :float,
+        "eth"             =>   :float,
+        "eth_btc"         =>   :float,
+        "eth_usd"         =>   :float,
+        "eth_eur"         =>   :float,
+        "ltc"             =>   :float,
+        "xrp"             =>   :float,
+        "bch"             =>   :float,
+      }
+      
+      def initialize(hash)
+        hash.each do |key, value|
+          type            =     ::Bitstamper::Models::UserTransaction::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Bitstamper::Utilities::convert_value(value, type) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+        
+        self.id           =     hash.fetch("id", hash.fetch("tid", nil))&.to_s
+        
+        self.transaction_type = TYPES[self.type]
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| ::Bitstamper::Models::UserTransaction.new(item) }
+      end
+      
+    end
+  end
+end

data/lib/bitstamper/models/withdrawal.rb

@@ -0,0 +1,53 @@
+module Bitstamper
+  module Models
+    class Withdrawal < Base
+      attr_accessor :id, :currency, :amount, :datetime
+      attr_accessor :type, :status
+      attr_accessor :address, :transaction_id
+      
+      TYPES               =   {
+        0   =>  :sepa,
+        1   =>  :bitcoin,
+        2   =>  :wire,
+        14  =>  :xrp,
+        15  =>  :ltc,
+        16  =>  :eth
+      }
+      
+      STATUS              =   {
+        0   =>  :open,
+        1   =>  :in_process,
+        2   =>  :finished,
+        3   =>  :cancelled,
+        4   =>  :failed
+      }
+      
+      MAPPING             =   {
+        "id"              =>  :string,
+        "currency"        =>  :string,
+        "amount"          =>  :float,
+        "datetime"        =>  :datetime,
+        "type"            =>  :integer,
+        "status"          =>  :integer,
+        "address"         =>  :string,
+        "transaction_id"  =>  :string
+      }
+      
+      def initialize(hash)
+        hash.each do |key, value|
+          type            =     ::Bitstamper::Models::Withdrawal::MAPPING.fetch(key, nil)
+          value           =     value && type ? ::Bitstamper::Utilities::convert_value(value, type) : value
+          self.send("#{key}=", value) if self.respond_to?(key)
+        end
+        
+        self.type         =   TYPES[self.type]
+        self.status       =   STATUS[self.status]
+      end
+      
+      def self.parse(data)
+        data&.collect { |item| ::Bitstamper::Models::Withdrawal.new(item) }
+      end
+      
+    end
+  end
+end

data/lib/bitstamper/rest/client.rb

@@ -0,0 +1,102 @@
+module Bitstamper
+  module Rest
+    class Client
+      attr_accessor :url, :configuration
+      
+      def initialize(configuration: ::Bitstamper.configuration)
+        self.url              =   "https://www.bitstamp.net/api"
+        self.configuration    =   configuration
+      end
+      
+      include ::Bitstamper::Rest::Errors
+      
+      include ::Bitstamper::Rest::Public::Ticker
+      include ::Bitstamper::Rest::Public::OrderBook
+      include ::Bitstamper::Rest::Public::Transactions
+      include ::Bitstamper::Rest::Public::TradingPairs
+      include ::Bitstamper::Rest::Public::Currencies
+      
+      include ::Bitstamper::Rest::Private::Balances
+      include ::Bitstamper::Rest::Private::Deposits
+      include ::Bitstamper::Rest::Private::Withdrawals
+      include ::Bitstamper::Rest::Private::Orders
+      include ::Bitstamper::Rest::Private::Transactions
+
+      def configured?
+        !self.configuration.key.to_s.empty? && !self.configuration.secret.to_s.empty? && !self.configuration.client_id.to_s.empty?
+      end
+
+      def check_credentials!
+        unless configured?
+          raise ::Bitstamper::Errors::MissingConfigError.new("Bitstamp Gem not properly configured")
+        end
+      end
+      
+      def path_with_currency_pair(path, currency_pair)
+        path += "/#{::Bitstamper::Utilities.fix_currency_pair(currency_pair)}" if !currency_pair.to_s.empty?
+        return path
+      end
+      
+      def to_uri(path)
+        "#{self.url}#{path}/"
+      end
+      
+      def parse(response)
+        error?(response)
+        response
+      end
+
+      def get(path, params: {}, options: {})
+        request path, method: :get, options: options
+      end
+
+      def post(path, params: {}, data: {}, options: {})
+        request path, method: :post, params: params, data: data.merge(auth), options: options
+      end
+
+      def auth(data = {})
+        if configured?
+          data[:key]          =   self.configuration.key
+          data[:nonce]        =   (Time.now.to_f * 1_000_000_000).to_i.to_s
+          message             =   data[:nonce] + self.configuration.client_id.to_s + data[:key]
+          data[:signature]    =   HMAC::SHA256.hexdigest(self.configuration.secret, message).upcase
+        end
+
+        return data
+      end
+
+      def request(path, method: :get, params: {}, data: {}, options: {})
+        user_agent    =   options.fetch(:user_agent, self.configuration.faraday.fetch(:user_agent, nil))
+        proxy         =   options.fetch(:proxy, nil)
+    
+        connection    =   Faraday.new(url: to_uri(path)) do |builder|
+          builder.headers[:user_agent] = user_agent if !user_agent.to_s.empty?
+          builder.request  :url_encoded if method.eql?(:post)
+          builder.response :logger      if self.configuration.verbose_faraday?
+          builder.response :json
+      
+          if proxy
+            puts "[Bitstamper::Rest::Client] - Will connect to Bitstamp using proxy: #{proxy.inspect}" if self.configuration.verbose_faraday?
+            builder.proxy = proxy
+          end
+      
+          builder.adapter self.configuration.faraday.fetch(:adapter, :net_http)
+        end
+    
+        case method
+          when :get
+            connection.get do |request|
+              request.params  =   params if params && !params.empty?
+            end&.body
+          when :post
+            connection.post do |request|
+              request.body    =   data
+              request.params  =   params if params && !params.empty?
+            end&.body
+        end
+      end
+            
+    end
+  end  
+end
+

data/lib/bitstamper/rest/errors.rb

@@ -0,0 +1,39 @@
+module Bitstamper
+  module Rest
+    module Errors
+      
+      def error?(response)
+        if response.is_a?(Hash)
+          if response.has_key?("error")
+            process_error(response.fetch("error", nil))
+          elsif response.fetch("status", nil) == "error"
+            process_error(response.fetch("reason", nil))
+          end
+        end
+      end
+      
+      def process_error(error)
+        if error.is_a?(String)
+          if error == ::Bitstamper::Constants::ERRORS[:matches][:invalid_permissions]
+            raise ::Bitstamper::Errors::InvalidPermissionsError.new(::Bitstamper::Constants::ERRORS[:responses][:invalid_permissions])
+          elsif error == ::Bitstamper::Constants::ERRORS[:matches][:invalid_order]
+            raise ::Bitstamper::Errors::InvalidOrderError.new(::Bitstamper::Constants::ERRORS[:matches][:invalid_order])
+          end
+        elsif error.is_a?(Hash)
+          process_hash_error(error)
+        end
+      end
+      
+      def process_hash_error(error)
+        if error.has_key?("amount")
+          raise ::Bitstamper::Errors::InvalidAmountError.new(error.fetch("amount", [])&.first)
+        elsif error.has_key?("address")
+          raise ::Bitstamper::Errors::InvalidAddressError.new(error.fetch("address", [])&.first)
+        elsif error.has_key?("__all__")
+          raise ::Bitstamper::Errors::InvalidOrderError.new(error.fetch("__all__", [])&.first)
+        end
+      end
+            
+    end
+  end  
+end

data/lib/bitstamper/rest/private/balances.rb

@@ -0,0 +1,18 @@
+module Bitstamper
+  module Rest
+    module Private
+      module Balances
+      
+        def balance(currency_pair: nil)
+          check_credentials!
+        
+          path        =   path_with_currency_pair("/v2/balance", currency_pair)
+          response    =   post(path)
+      
+          ::Bitstamper::Models::Balance.parse(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bitstamper/rest/private/deposits.rb

@@ -0,0 +1,51 @@
+module Bitstamper
+  module Rest
+    module Private
+      module Deposits
+      
+        def btc_deposit_address
+          deposit_address("btc")
+        end
+        
+        def eth_deposit_address
+          deposit_address("eth")
+        end
+        
+        def xrp_deposit_address
+          deposit_address("xrp")
+        end
+        
+        def bch_deposit_address
+          deposit_address("bch")
+        end
+        
+        def ltc_deposit_address
+          deposit_address("ltc")
+        end
+
+        def deposit_address(currency)
+          check_credentials!
+  
+          currency    =   currency.to_s.downcase
+          
+          if !::Bitstamper::Constants::AVAILABLE_CRYPTOS.include?(currency)
+            raise ::Bitstamper::Errors::InvalidCurrencyError.new("#{currency} is not a tradeable crypto currency on Bitstamp.")
+          end
+          
+          path        =   currency.eql?("btc") ? "/bitcoin_deposit_address" : "/v2/#{currency}_address"
+          response    =   post(path)
+          response    =   response.is_a?(String) ? {"address" => response} : response
+  
+          return response
+        end
+
+        def unconfirmed_bitcoins
+          check_credentials!
+          response    =   post("/unconfirmed_btc")
+          Bitstamper::Models::Deposit.parse(response) if response
+        end
+      
+      end
+    end
+  end
+end

data/lib/bitstamper/rest/private/orders.rb

@@ -0,0 +1,103 @@
+module Bitstamper
+  module Rest
+    module Private
+      module Orders
+            
+        def open_orders(currency_pair = nil)
+          path      =   !currency_pair.to_s.empty? ? "/v2/open_orders/#{::Bitstamper::Utilities.fix_currency_pair(currency_pair)}" : "/v2/open_orders/all"
+          response  =   post(path)
+          Bitstamper::Models::Order.parse(response) if response
+        end
+      
+        def find_open_order(order_id)
+          open_orders.select { |order| order.id == order_id }&.first
+        end
+    
+        # https://www.bitstamp.net/api/#buy-order
+        def buy(currency_pair: "btcusd", amount:, price:, limit_price: nil, daily_order: nil)
+          create_order(
+            currency_pair: currency_pair,
+            direction:     Bitstamper::Constants::BUY_ORDER,
+            amount:        amount,
+            price:         price,
+            limit_price:   limit_price,
+            daily_order:   daily_order
+          )
+        end
+    
+        # https://www.bitstamp.net/api/#sell-order
+        def sell(currency_pair: "btcusd", amount:, price:, limit_price: nil, daily_order: nil)
+          create_order(
+            currency_pair: currency_pair,
+            direction:     Bitstamper::Constants::SELL_ORDER,
+            amount:        amount,
+            price:         price,
+            limit_price:   limit_price,
+            daily_order:   daily_order
+          )
+        end
+        
+        # Request parameters
+        # [AUTH]
+        # amount - Amount.
+        # price - Price.
+        # limit_price - If the order gets executed, a new sell order will be placed, with "limit_price" as its price.
+        # daily_order - (Optional): Opens buy limit order which will be canceled at 0:00 UTC unless it already has been executed. Possible value: True
+        def create_order(currency_pair: "btcusd", direction: Bitstamper::Constants::BUY_ORDER, amount:, price:, limit_price: nil, daily_order: nil)
+          currency_pair         =   ::Bitstamper::Utilities.fix_currency_pair(currency_pair)
+          direction             =   fix_order_direction(direction)
+          
+          path                  =   case direction
+            when Bitstamper::Constants::BUY_ORDER
+              "/v2/buy/#{currency_pair}"
+            when Bitstamper::Constants::SELL_ORDER
+              "/v2/sell/#{currency_pair}"
+          end
+          
+          data                  =   {
+            amount: amount,
+            price:  price
+          }
+          
+          data[:limit_price]    =   limit_price if !limit_price.nil?
+          data[:daily_order]    =   true if daily_order == true
+          
+          response              =   parse(post(path, data: data))
+          
+          Bitstamper::Models::Order.new(response.merge("currency_pair" => currency_pair)) if response
+        end
+        
+        def fix_order_direction(direction)
+          if direction.is_a?(Symbol)
+            direction           =   case direction
+              when :buy
+                Bitstamper::Constants::BUY_ORDER
+              when :sell
+                Bitstamper::Constants::SELL_ORDER
+            end
+          end
+          
+          return direction
+        end
+      
+        def order_status(order_id)
+          response        =   post("/order_status", data: {id: order_id})
+          status          =   response&.fetch("status", nil)
+          transactions    =   Bitstamper::Models::UserTransaction.parse(response&.fetch("transactions", []))
+          
+          return {status: status, transactions: transactions}
+        end
+
+        def cancel_all_orders!
+          parse(post('/cancel_all_orders'))
+        end
+  
+        def cancel_order!(order_id)
+          response        =   parse(post('/v2/cancel_order', data: {id: order_id}))
+          Bitstamper::Models::Order.new(response) if response
+        end
+    
+      end
+    end
+  end
+end

data/lib/bitstamper/rest/private/transactions.rb

@@ -0,0 +1,19 @@
+module Bitstamper
+  module Rest
+    module Private
+      module Transactions
+            
+        def user_transactions(currency_pair: nil, offset: 0, limit: 100, sort: "desc")
+          path      =   path_with_currency_pair("/v2/user_transactions", currency_pair)
+          response  =   post(path, data: {offset: offset, limit: limit, sort: sort})
+          Bitstamper::Models::UserTransaction.parse(response) if response
+        end
+
+        def find_user_transaction(transaction_id)
+          user_transactions.select { |transaction| transaction.id == transaction_id }&.first
+        end
+
+      end
+    end
+  end
+end

data/lib/bitstamper/rest/private/withdrawals.rb

@@ -0,0 +1,53 @@
+module Bitstamper
+  module Rest
+    module Private
+      module Withdrawals
+        
+        def withdraw(currency, address:, amount:, instant: nil)
+          check_credentials!
+  
+          currency    =   currency.to_s.downcase
+          
+          if !::Bitstamper::Constants::AVAILABLE_CRYPTOS.include?(currency)
+            raise ::Bitstamper::Errors::InvalidCurrencyError.new("#{currency} is not a tradeable crypto currency on Bitstamp.")
+          end
+          
+          path        =   currency.eql?("btc") ? "/bitcoin_withdrawal" : "/v2/#{currency}_withdrawal"
+          
+          data        =   {
+            address:  address,
+            amount:   amount,
+          }
+          
+          data[:instant] = 1 if (currency.eql?("btc") && (instant.eql?(true) || instant.eql?(1)))
+          
+          response    =   parse(post(path, data: data))
+          response    =   response.is_a?(String) ? {"id" => response} : response
+  
+          return response
+        end
+        
+        def withdrawal_requests(interval: ::Bitstamper::Constants::TIME_IN_SECONDS[:day])
+          check_credentials!
+          
+          response    =   post("/v2/withdrawal-requests", data: {timedelta: interval})
+          
+          Bitstamper::Models::Withdrawal.parse(response) if response
+        end
+        
+        def bank_withdrawal_status(id)
+          check_credentials!
+          
+          response    =   post("/v2/withdrawal/status", data: {id: id})
+        end
+        
+        def cancel_bank_withdrawal(id)
+          check_credentials!
+          
+          response    =   post("/v2/withdrawal/cancel", data: {id: id})
+        end
+      
+      end
+    end
+  end
+end