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/coinbasepro/coinbasepro.go

@@ -7,11 +7,13 @@ import (
 	"log"
 	"net/url"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/gorilla/websocket"
 	"github.com/thrasher-/gocryptotrader/common"
 	"github.com/thrasher-/gocryptotrader/config"
+	"github.com/thrasher-/gocryptotrader/currency/symbol"
 	"github.com/thrasher-/gocryptotrader/exchanges"
 	"github.com/thrasher-/gocryptotrader/exchanges/request"
 	"github.com/thrasher-/gocryptotrader/exchanges/ticker"
@@ -134,14 +136,6 @@ func (c *CoinbasePro) Setup(exch config.ExchangeConfig) {
 	}
 }
 
-// GetFee returns the current fee for the exchange
-func (c *CoinbasePro) GetFee(maker bool) float64 {
-	if maker {
-		return c.MakerFee
-	}
-	return c.TakerFee
-}
-
 // GetProducts returns supported currency pairs on the exchange with specific
 // information about the pair
 func (c *CoinbasePro) GetProducts() ([]Product, error) {
@@ -828,3 +822,70 @@ func (c *CoinbasePro) SendAuthenticatedHTTPRequest(method, path string, params m
 
 	return c.SendPayload(method, c.APIUrl+path, headers, bytes.NewBuffer(payload), result, true, c.Verbose)
 }
+
+// GetFee returns an estimate of fee based on type of transaction
+func (c *CoinbasePro) GetFee(feeBuilder exchange.FeeBuilder) (float64, error) {
+	var fee float64
+	switch feeBuilder.FeeType {
+	case exchange.CryptocurrencyTradeFee:
+		trailingVolume, err := c.GetTrailingVolume()
+		if err != nil {
+			return 0, err
+		}
+		fee = c.calculateTradingFee(trailingVolume, feeBuilder.FirstCurrency, feeBuilder.Delimiter, feeBuilder.SecondCurrency, feeBuilder.PurchasePrice, feeBuilder.Amount, feeBuilder.IsMaker)
+	case exchange.InternationalBankWithdrawalFee:
+		fee = getInternationalBankWithdrawalFee(feeBuilder.CurrencyItem, feeBuilder.Amount)
+	case exchange.InternationalBankDepositFee:
+		fee = getInternationalBankDepositFee(feeBuilder.CurrencyItem, feeBuilder.Amount)
+	}
+
+	if fee < 0 {
+		fee = 0
+	}
+
+	return fee, nil
+}
+
+func (c *CoinbasePro) calculateTradingFee(trailingVolume []Volume, firstCurrency, delimiter, secondCurrency string, purchasePrice, amount float64, isMaker bool) float64 {
+	var fee float64
+	for _, i := range trailingVolume {
+		if strings.EqualFold(i.ProductID, firstCurrency+delimiter+secondCurrency) {
+			if isMaker {
+				fee = 0
+			} else if i.Volume <= 10000000 {
+				fee = 0.003
+			} else if i.Volume > 10000000 && i.Volume <= 100000000 {
+				fee = 0.002
+			} else if i.Volume > 100000000 {
+				fee = 0.001
+			}
+			break
+		}
+	}
+
+	return fee * amount * purchasePrice
+}
+
+func getInternationalBankWithdrawalFee(currency string, amount float64) float64 {
+	var fee float64
+
+	if currency == symbol.USD {
+		fee = 25
+	} else if currency == symbol.EUR {
+		fee = 0.15
+	}
+
+	return fee
+}
+
+func getInternationalBankDepositFee(currency string, amount float64) float64 {
+	var fee float64
+
+	if currency == symbol.USD {
+		fee = 10
+	} else if currency == symbol.EUR {
+		fee = 0.15
+	}
+
+	return fee
+}

exchanges/coinbasepro/coinbasepro_test.go

@@ -5,6 +5,8 @@ import (
 	"time"
 
 	"github.com/thrasher-/gocryptotrader/config"
+	"github.com/thrasher-/gocryptotrader/currency/symbol"
+	exchange "github.com/thrasher-/gocryptotrader/exchanges"
 )
 
 var c CoinbasePro
@@ -32,15 +34,6 @@ func TestSetup(t *testing.T) {
 	c.Setup(gdxConfig)
 }
 
-func TestGetFee(t *testing.T) {
-	if c.GetFee(false) == 0 {
-		t.Error("Test failed - GetFee() error")
-	}
-	if c.GetFee(true) != 0 {
-		t.Error("Test failed - GetFee() error")
-	}
-}
-
 func TestGetProducts(t *testing.T) {
 	_, err := c.GetProducts()
 	if err != nil {
@@ -224,3 +217,176 @@ func TestAuthRequests(t *testing.T) {
 		}
 	}
 }
+
+func setFeeBuilder() exchange.FeeBuilder {
+	return exchange.FeeBuilder{
+		Amount:         1,
+		Delimiter:      "",
+		FeeType:        exchange.CryptocurrencyTradeFee,
+		FirstCurrency:  symbol.BTC,
+		SecondCurrency: symbol.LTC,
+		IsMaker:        false,
+		PurchasePrice:  1,
+	}
+}
+
+func TestGetFee(t *testing.T) {
+	c.SetDefaults()
+	TestSetup(t)
+
+	var feeBuilder = setFeeBuilder()
+
+	if apiKey != "" || apiSecret != "" {
+		// CryptocurrencyTradeFee Basic
+		if resp, err := c.GetFee(feeBuilder); resp != float64(0.003) || err != nil {
+			t.Error(err)
+			t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.003), resp)
+		}
+
+		// CryptocurrencyTradeFee High quantity
+		feeBuilder = setFeeBuilder()
+		feeBuilder.Amount = 1000
+		feeBuilder.PurchasePrice = 1000
+		if resp, err := c.GetFee(feeBuilder); resp != float64(3000) || err != nil {
+			t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(3000), resp)
+			t.Error(err)
+		}
+
+		// CryptocurrencyTradeFee IsMaker
+		feeBuilder = setFeeBuilder()
+		feeBuilder.IsMaker = true
+		if resp, err := c.GetFee(feeBuilder); resp != float64(0) || 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 := c.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 := c.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 := c.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
+	feeBuilder.CurrencyItem = symbol.EUR
+	if resp, err := c.GetFee(feeBuilder); resp != float64(0.15) || 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 := c.GetFee(feeBuilder); resp != float64(25) || err != nil {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+		t.Error(err)
+	}
+}
+
+func TestCalculateTradingFee(t *testing.T) {
+	t.Parallel()
+	// uppercase
+	var volume = []Volume{
+		Volume{
+			ProductID: "BTC_USD",
+			Volume:    100,
+		},
+	}
+
+	if resp := c.calculateTradingFee(volume, "btc", "_", "usd", 1, 1, false); resp != float64(0.003) {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.003), resp)
+	}
+
+	// lowercase
+	volume = []Volume{
+		Volume{
+			ProductID: "btc_usd",
+			Volume:    100,
+		},
+	}
+
+	if resp := c.calculateTradingFee(volume, "btc", "_", "usd", 1, 1, false); resp != float64(0.003) {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.003), resp)
+	}
+
+	// mixedCase
+	volume = []Volume{
+		Volume{
+			ProductID: "btc_USD",
+			Volume:    100,
+		},
+	}
+
+	if resp := c.calculateTradingFee(volume, "btc", "_", "usd", 1, 1, false); resp != float64(0.003) {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.003), resp)
+	}
+
+	// medium volume
+	volume = []Volume{
+		Volume{
+			ProductID: "btc_USD",
+			Volume:    10000001,
+		},
+	}
+
+	if resp := c.calculateTradingFee(volume, "btc", "_", "usd", 1, 1, false); resp != float64(0.002) {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.002), resp)
+	}
+
+	// high volume
+	volume = []Volume{
+		Volume{
+			ProductID: "btc_USD",
+			Volume:    100000010000,
+		},
+	}
+
+	if resp := c.calculateTradingFee(volume, "btc", "_", "usd", 1, 1, false); resp != float64(0.001) {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0.001), resp)
+	}
+
+	// no match
+	volume = []Volume{
+		Volume{
+			ProductID: "btc_beeteesee",
+			Volume:    100000010000,
+		},
+	}
+
+	if resp := c.calculateTradingFee(volume, "btc", "_", "usd", 1, 1, false); resp != float64(0) {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+	}
+
+	// taker
+	volume = []Volume{
+		Volume{
+			ProductID: "btc_USD",
+			Volume:    100000010000,
+		},
+	}
+
+	if resp := c.calculateTradingFee(volume, "btc", "_", "usd", 1, 1, true); resp != float64(0) {
+		t.Errorf("Test Failed - GetFee() error. Expected: %f, Recieved: %f", float64(0), resp)
+	}
+}

exchanges/coinbasepro/coinbasepro_wrapper.go

@@ -191,3 +191,8 @@ func (c *CoinbasePro) WithdrawFiatExchangeFunds(cryptocurrency pair.CurrencyItem
 func (c *CoinbasePro) GetWebsocket() (*exchange.Websocket, error) {
 	return c.Websocket, nil
 }
+
+// GetFeeByType returns an estimate of fee based on type of transaction
+func (c *CoinbasePro) GetFeeByType(feeBuilder exchange.FeeBuilder) (float64, error) {
+	return c.GetFee(feeBuilder)
+}