Calculating each exchange's fees (#188)

* Adds some constants for fee types
Adds some fee calculation in an attempt to be generic
Adds fee stuff to Bittrex
Adds fee stuff to bitstamp

* Fixes bitstamp fee calculation

* Tests
Tests all scenarios for GetFeeByType

* Adds method to wrapper
Adds err to response
Checks for err

* Adds support for Bittrex fees

* Adds maker/taker dynamic to fees
Updates tests
Adds bitmex fee support
Removes unused switch case scenarios to not waste space

* Adds bithumb support for fee calculation

* Adds Bitfinex fee support
Adds list of currencies as const strings
Sets up bitflyer

* Fixes arguments

* Greatly expands symbols
Adds Binance fee calculation support
Cleans up previous exchanges

* Fixes errors for fee calculations

* Adds ANX fee support

* Adds btcc fee support
Adds alphapoint fee wrapper support
Renames method to match "enum"
Uses symbols in tests, not inline strings

* Adds support for BTCMarkets fee calculation
Adds new method to retrieve fee amount from BTCMarkets
Adds new fee type struct: FeeBuilder
Updates ANX and BTCMarkets to use new FeeBuilder type struct
Standardises the tests to run when it comes to fee calculation

* Migrates all existing exchange fee to use new feebuilder type struct
Uses standard testing model

* Fixes unit tests

* Updates maker taker fees in test config

* Removes parallel from fee testing

* Removes more parallel from tests

* Adds coinbasepro fee support

* Adds Coinut fee support

* Adds Exmo fee support
Adds maker fee support to coinut
Introduces a type for fees and bank transfers to prevent random strings being used

* Adds partial bitflyer support
Moves bitflyer to feeBuilder struct

* Adds gateio fee support

* Adds Gemini fee support

* Adds hitbtc fee support

* Adds huobi fee support

* Adds HuobiHadax fee support

* Adds itbit fee support

* Adds partial kraken fee support with trading fees

* Finishes basic Kraken fee support

* Adds basic LakeBTC fee support

* Adds basic liqui fee support

* Adds localbitcoins fee support.......

* Adds basic okcoin fee support

* Adds simple OKEX fee support
Adds many new currency symbols
Fixes liqui's fees

* Adds poloniex fee support

* Adds fee support for Yobit

* Adds WEX fee support

* Adds ZB fee support

* Removes bad reference

* Improves accuracy of variable name

* trading fee method names are now consistent

(cherry picked from commit 21c82e8b90cae590cfd73d365d7be39e1a00e973)

* Fixes rebasing issues

* Fixes issues from rebase
Removes "IsTaker" as IsMaker bool can imply taker
Updates tests to actually work.

* Adds a zero to the test

* Fixes bitfinex api endpoints and fixes fee calculations

* Updates btcmarkets trading fee calculation

* Verifies tests with apis for all exchanges except coinbasepro, itbit and bitflyer
Removes taker fee test as taker is default

* Removes redundant all exchange wrapper error checks due to the error checks being redundant

* Addresses review comments:
- Renames variables
- Changes how functions return data
- Fixes typo

exchanges/gemini/gemini.go

@@ -40,6 +40,7 @@ const (
 	geminiNewAddress         = "newAddress"
 	geminiWithdraw           = "withdraw/"
 	geminiHeartbeat          = "heartbeat"
+	geminiVolume             = "notionalvolume"
 
 	// gemini limit rates
 	geminiAuthRate   = 600
@@ -389,6 +390,14 @@ func (g *Gemini) GetTradeHistory(currencyPair string, timestamp int64) ([]TradeH
 		g.SendAuthenticatedHTTPRequest("POST", geminiMyTrades, request, &response)
 }
 
+// GetNotionalVolume returns  the volume in price currency that has been traded across all pairs over a period of 30 days
+func (g *Gemini) GetNotionalVolume() (NotionalVolume, error) {
+	response := NotionalVolume{}
+
+	return response,
+		g.SendAuthenticatedHTTPRequest("POST", geminiVolume, nil, &response)
+}
+
 // GetTradeVolume returns a multi-arrayed volume response
 func (g *Gemini) GetTradeVolume() ([][]TradeVolume, error) {
 	response := [][]TradeVolume{}
@@ -496,3 +505,35 @@ func (g *Gemini) SendAuthenticatedHTTPRequest(method, path string, params map[st
 
 	return g.SendPayload(method, g.APIUrl+"/v1/"+path, headers, strings.NewReader(""), result, true, g.Verbose)
 }
+
+// GetFee returns an estimate of fee based on type of transaction
+func (g *Gemini) GetFee(feeBuilder exchange.FeeBuilder) (float64, error) {
+	var fee float64
+	switch feeBuilder.FeeType {
+	case exchange.CryptocurrencyTradeFee:
+		notionVolume, err := g.GetNotionalVolume()
+		if err != nil {
+			return 0, err
+		}
+		fee = calculateTradingFee(notionVolume, feeBuilder.PurchasePrice, feeBuilder.Amount, feeBuilder.IsMaker)
+	case exchange.CryptocurrencyWithdrawalFee:
+		// TODO: no free transactions after 10; Need database to know how many trades have been done
+		// Could do via trade history, but would require analysis of response and dates to determine level of fee
+	}
+	if fee < 0 {
+		fee = 0
+	}
+
+	return fee, nil
+}
+
+func calculateTradingFee(notionVolume NotionalVolume, purchasePrice, amount float64, isMaker bool) float64 {
+	var volumeFee float64
+	if isMaker {
+		volumeFee = (float64(notionVolume.MakerFee) / 100)
+	} else {
+		volumeFee = (float64(notionVolume.TakerFee) / 100)
+	}
+
+	return volumeFee * amount * purchasePrice
+}

exchanges/gemini/gemini_test.go

@@ -5,6 +5,8 @@ import (
 	"testing"
 
 	"github.com/thrasher-/gocryptotrader/config"
+	"github.com/thrasher-/gocryptotrader/currency/symbol"
+	exchange "github.com/thrasher-/gocryptotrader/exchanges"
 )
 
 // Please enter sandbox API keys & assigned roles for better testing procedures
@@ -58,14 +60,6 @@ func TestSetup(t *testing.T) {
 	Session[2].Setup(geminiConfig)
 }
 
-// func TestSandbox(t *testing.T) {
-// 	t.Parallel()
-// 	g.Sandbox(1)
-// 	if Management[1].URL != geminiSandboxAPIURL {
-// 		t.Error("Test Failed - Sandbox() error")
-// 	}
-// }
-
 func TestGetSymbols(t *testing.T) {
 	t.Parallel()
 	_, err := Session[1].GetSymbols()
@@ -102,6 +96,16 @@ func TestGetTrades(t *testing.T) {
 	}
 }
 
+func TestGetNotionalVolume(t *testing.T) {
+	if apiKey2 != "" && apiSecret2 != "" {
+		t.Parallel()
+		_, err := Session[2].GetNotionalVolume()
+		if err != nil {
+			t.Error("Test Failed - GetNotionalVolume() error", err)
+		}
+	}
+}
+
 func TestGetAuction(t *testing.T) {
 	t.Parallel()
 	_, err := Session[1].GetAuction("btcusd")
@@ -213,3 +217,95 @@ func TestPostHeartbeat(t *testing.T) {
 		t.Error("Test Failed - PostHeartbeat() error", err)
 	}
 }
+
+func setFeeBuilder() exchange.FeeBuilder {
+	return exchange.FeeBuilder{
+		Amount:              1,
+		Delimiter:           "_",
+		FeeType:             exchange.CryptocurrencyTradeFee,
+		FirstCurrency:       symbol.BTC,
+		SecondCurrency:      symbol.LTC,
+		IsMaker:             false,
+		PurchasePrice:       1,
+		CurrencyItem:        symbol.USD,
+		BankTransactionType: exchange.WireTransfer,
+	}
+}
+
+func TestGetFee(t *testing.T) {
+
+	var feeBuilder = setFeeBuilder()
+	if apiKey1 != "" && apiSecret1 != "" {
+		// CryptocurrencyTradeFee Basic
+		if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0.01) || err != nil {
+			t.Error(err)
+			t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.01), resp)
+		}
+
+		// CryptocurrencyTradeFee High quantity
+		feeBuilder = setFeeBuilder()
+		feeBuilder.Amount = 1000
+		feeBuilder.PurchasePrice = 1000
+		if resp, err := Session[1].GetFee(feeBuilder); resp != float64(100) || err != nil {
+			t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(100), resp)
+			t.Error(err)
+		}
+
+		// CryptocurrencyTradeFee IsMaker
+		feeBuilder = setFeeBuilder()
+		feeBuilder.IsMaker = true
+		if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0.01) || err != nil {
+			t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.01), resp)
+			t.Error(err)
+		}
+
+		// CryptocurrencyTradeFee Negative purchase price
+		feeBuilder = setFeeBuilder()
+		feeBuilder.PurchasePrice = -1000
+		if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0) || err != nil {
+			t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+			t.Error(err)
+		}
+	}
+	// CryptocurrencyWithdrawalFee Basic
+	feeBuilder = setFeeBuilder()
+	feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
+	if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0) || err != nil {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+		t.Error(err)
+	}
+
+	// CryptocurrencyWithdrawalFee Invalid currency
+	feeBuilder = setFeeBuilder()
+	feeBuilder.FirstCurrency = "hello"
+	feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
+	if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0) || err != nil {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+		t.Error(err)
+	}
+
+	// CyptocurrencyDepositFee Basic
+	feeBuilder = setFeeBuilder()
+	feeBuilder.FeeType = exchange.CyptocurrencyDepositFee
+	if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0) || err != nil {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+		t.Error(err)
+	}
+
+	// InternationalBankDepositFee Basic
+	feeBuilder = setFeeBuilder()
+	feeBuilder.FeeType = exchange.InternationalBankDepositFee
+	if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0) || err != nil {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+		t.Error(err)
+	}
+
+	// InternationalBankWithdrawalFee Basic
+	feeBuilder = setFeeBuilder()
+	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
+	feeBuilder.CurrencyItem = symbol.USD
+	if resp, err := Session[1].GetFee(feeBuilder); resp != float64(0) || err != nil {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+		t.Error(err)
+	}
+}

exchanges/gemini/gemini_types.go

@@ -140,6 +140,24 @@ type TradeVolume struct {
 	SellTakerCount    float64 `json:"sell_taker_count"`
 }
 
+// NotionalVolume api call for fees
+type NotionalVolume struct {
+	MakerFee              int64                  `json:"maker_fee_bps"`
+	TakerFee              int64                  `json:"taker_fee_bps"`
+	AuctionFee            int64                  `json:"auction_fee_bps"`
+	ThirtyDayVolume       float64                `json:"notional_30d_volume"`
+	LastedUpdated         int64                  `json:"last_updated_ms"`
+	AccountID             int64                  `json:"account_id"`
+	Date                  string                 `json:"date"`
+	OneDayNotionalVolumes []OneDayNotionalVolume `json:"notional_1d_volume"`
+}
+
+// OneDayNotionalVolume Contains the notioanl volume for a single day
+type OneDayNotionalVolume struct {
+	Date             string  `json:"date"`
+	NotationalVolume float64 `json:"notional_volume"`
+}
+
 // Balance is a simple balance type
 type Balance struct {
 	Currency  string  `json:"currency"`

exchanges/gemini/gemini_wrapper.go

@@ -180,3 +180,8 @@ func (g *Gemini) WithdrawFiatExchangeFundsToInternationalBank(currency pair.Curr
 func (g *Gemini) GetWebsocket() (*exchange.Websocket, error) {
 	return nil, errors.New("not yet implemented")
 }
+
+// GetFeeByType returns an estimate of fee based on type of transaction
+func (g *Gemini) GetFeeByType(feeBuilder exchange.FeeBuilder) (float64, error) {
+	return g.GetFee(feeBuilder)
+}