Withdraw Crypto wrapper mapping (#226)

* Initial commit

* Updates signature for all withdrawal methods to use new withdrawRequest struct type

* Implements crypto withdraw features & tests for Alphapoint, ANX, Binance, Bitfinex, Bitflyer, Bithumb, Bitmex, Bitstamp, Bittrex, BTCC, BTCmarkets, CoinbasePro, Coinut. Updates WithdrawRequest type with more members. Breaking change to update real order testing for increased code coverage

* Updates all realOrder tests to run when no API key is present. Updates exchange functions to handle errors better

* Implements crypto withdrawals for Exmo, GateIO, Gemini, HitBTC, Huobi, HuobiHadax, Kraken, LakeBTC, Liqui, Localbitcoins, OKCoin, OKEX, Poloniex, Wex, Yobit and ZB. Updates real order test formatting for all real order tests

* Update alphapoint. Fixes anx typos. Adds function WithdrawFiatFundsToInternationalBank to exchange wrapper interface. Adds WithdrawFiatFundsToInternationalBank to alphapoint, bitmex, coinbasepro. Updates Kraken to use TradePassword property

* Reverts alphapoint to use ErrNotYetImplemented

* Fixes line spacing and removes unnecessary line

exchanges/bitfinex/bitfinex.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gorilla/websocket"
 	"github.com/thrasher-/gocryptotrader/common"
 	"github.com/thrasher-/gocryptotrader/config"
+	"github.com/thrasher-/gocryptotrader/currency/symbol"
 	exchange "github.com/thrasher-/gocryptotrader/exchanges"
 	"github.com/thrasher-/gocryptotrader/exchanges/request"
 	"github.com/thrasher-/gocryptotrader/exchanges/ticker"
@@ -582,15 +583,18 @@ func (b *Bitfinex) WalletTransfer(amount float64, currency, walletFrom, walletTo
 		b.SendAuthenticatedHTTPRequest("POST", bitfinexTransfer, request, &response)
 }
 
-// Withdrawal requests a withdrawal from one of your wallets.
-// Major Upgrade needed on this function to include all query params
-func (b *Bitfinex) Withdrawal(withdrawType, wallet, address string, amount float64) ([]Withdrawal, error) {
+// WithdrawCryptocurrency requests a withdrawal from one of your wallets.
+// For FIAT, use WithdrawFIAT
+func (b *Bitfinex) WithdrawCryptocurrency(withdrawType, wallet, address, currency, paymentID string, amount float64) ([]Withdrawal, error) {
 	response := []Withdrawal{}
 	request := make(map[string]interface{})
-	request["withdrawal_type"] = withdrawType
+	request["withdraw_type"] = withdrawType
 	request["walletselected"] = wallet
 	request["amount"] = strconv.FormatFloat(amount, 'f', -1, 64)
 	request["address"] = address
+	if currency == symbol.XMR {
+		request["paymend_id"] = paymentID
+	}
 
 	return response,
 		b.SendAuthenticatedHTTPRequest("POST", bitfinexWithdrawal, request, &response)
@@ -999,3 +1003,51 @@ func (b *Bitfinex) CalculateTradingFee(accountInfos []AccountInfo, purchasePrice
 	}
 	return (fee / 100) * purchasePrice * amount, err
 }
+
+// ConvertSymbolToWithdrawalType You need to have specific withdrawal types to withdraw from Bitfinex
+func (b *Bitfinex) ConvertSymbolToWithdrawalType(currency string) string {
+	switch currency {
+	case symbol.BTC:
+		return "bitcoin"
+	case symbol.LTC:
+		return "litecoin"
+	case symbol.ETH:
+		return "ethereum"
+	case symbol.ETC:
+		return "ethereumc"
+	case symbol.USDT:
+		return "tetheruso"
+	case "Wire":
+		return "wire"
+	case symbol.ZEC:
+		return "zcash"
+	case symbol.XMR:
+		return "monero"
+	case symbol.DSH:
+		return "dash"
+	case symbol.XRP:
+		return "ripple"
+	case symbol.SAN:
+		return "santiment"
+	case symbol.OMG:
+		return "omisego"
+	case symbol.BCH:
+		return "bcash"
+	case symbol.ETP:
+		return "metaverse"
+	case symbol.AVT:
+		return "aventus"
+	case symbol.EDO:
+		return "eidoo"
+	case symbol.BTG:
+		return "bgold"
+	case symbol.DATA:
+		return "datacoin"
+	case symbol.GNT:
+		return "golem"
+	case symbol.SNT:
+		return "status"
+	default:
+		return common.StringToLower(currency)
+	}
+}

exchanges/bitfinex/bitfinex_test.go

@@ -336,18 +336,6 @@ func TestWalletTransfer(t *testing.T) {
 	}
 }
 
-func TestWithdrawal(t *testing.T) {
-	if b.APIKey == "" || b.APISecret == "" {
-		t.SkipNow()
-	}
-	t.Parallel()
-
-	_, err := b.Withdrawal("LITECOIN", "deposit", "1000", 0.01)
-	if err == nil {
-		t.Error("Test Failed - Withdrawal() error")
-	}
-}
-
 func TestNewOrder(t *testing.T) {
 	if b.APIKey == "" || b.APISecret == "" {
 		t.SkipNow()
@@ -722,21 +710,20 @@ func TestFormatWithdrawPermissions(t *testing.T) {
 
 // Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
 // ----------------------------------------------------------------------------------------------------------------------------
-func isRealOrderTestEnabled() bool {
-	if b.APIKey == "" || b.APISecret == "" ||
-		b.APIKey == "Key" || b.APISecret == "Secret" ||
-		!canManipulateRealOrders {
-		return false
+func areTestAPIKeysSet() bool {
+	if b.APIKey != "" && b.APIKey != "Key" &&
+		b.APISecret != "" && b.APISecret != "Secret" {
+		return true
 	}
-	return true
+	return false
 }
 
 func TestSubmitOrder(t *testing.T) {
 	b.SetDefaults()
 	TestSetup(t)
 
-	if !isRealOrderTestEnabled() {
-		t.Skip()
+	if areTestAPIKeysSet() && !canManipulateRealOrders {
+		t.Skip("API keys set, canManipulateRealOrders false, skipping test")
 	}
 	var p = pair.CurrencyPair{
 		Delimiter:      "",
@@ -744,8 +731,10 @@ func TestSubmitOrder(t *testing.T) {
 		SecondCurrency: symbol.BTC,
 	}
 	response, err := b.SubmitOrder(p, exchange.Buy, exchange.Market, 1, 1, "clientId")
-	if err != nil || !response.IsOrderPlaced {
+	if areTestAPIKeysSet() && (err != nil || !response.IsOrderPlaced) {
 		t.Errorf("Order failed to be placed: %v", err)
+	} else if !areTestAPIKeysSet() && err == nil {
+		t.Error("Expecting an error when no keys are set")
 	}
 }
 
@@ -754,8 +743,8 @@ func TestCancelExchangeOrder(t *testing.T) {
 	b.SetDefaults()
 	TestSetup(t)
 
-	if !isRealOrderTestEnabled() {
-		t.Skip()
+	if areTestAPIKeysSet() && !canManipulateRealOrders {
+		t.Skip("API keys set, canManipulateRealOrders false, skipping test")
 	}
 
 	currencyPair := pair.NewCurrencyPair(symbol.LTC, symbol.BTC)
@@ -771,8 +760,11 @@ func TestCancelExchangeOrder(t *testing.T) {
 	err := b.CancelOrder(orderCancellation)
 
 	// Assert
-	if err != nil {
-		t.Errorf("Could not cancel order: %s", err)
+	if !areTestAPIKeysSet() && err == nil {
+		t.Errorf("Expecting an error when no keys are set: %v", err)
+	}
+	if areTestAPIKeysSet() && err != nil {
+		t.Errorf("Could not cancel orders: %v", err)
 	}
 }
 
@@ -781,8 +773,8 @@ func TestCancelAllExchangeOrdera(t *testing.T) {
 	b.SetDefaults()
 	TestSetup(t)
 
-	if !isRealOrderTestEnabled() {
-		t.Skip()
+	if areTestAPIKeysSet() && !canManipulateRealOrders {
+		t.Skip("API keys set, canManipulateRealOrders false, skipping test")
 	}
 
 	currencyPair := pair.NewCurrencyPair(symbol.LTC, symbol.BTC)
@@ -798,8 +790,11 @@ func TestCancelAllExchangeOrdera(t *testing.T) {
 	resp, err := b.CancelAllOrders(orderCancellation)
 
 	// Assert
-	if err != nil {
-		t.Errorf("Could not cancel order: %s", err)
+	if !areTestAPIKeysSet() && err == nil {
+		t.Errorf("Expecting an error when no keys are set: %v", err)
+	}
+	if areTestAPIKeysSet() && err != nil {
+		t.Errorf("Could not cancel orders: %v", err)
 	}
 
 	if len(resp.OrderStatus) > 0 {
@@ -813,3 +808,26 @@ func TestModifyOrder(t *testing.T) {
 		t.Error("Test failed - ModifyOrder() error")
 	}
 }
+
+func TestWithdraw(t *testing.T) {
+	b.SetDefaults()
+	TestSetup(t)
+	if areTestAPIKeysSet() && !canManipulateRealOrders {
+		t.Skip("API keys set, canManipulateRealOrders false, skipping test")
+	}
+
+	var withdrawCryptoRequest = exchange.WithdrawRequest{
+		Amount:      100,
+		Currency:    symbol.BTC,
+		Address:     "1F5zVDgNjorJ51oGebSvNCrSAHpwGkUdDB",
+		Description: "WITHDRAW IT ALL",
+	}
+
+	_, err := b.WithdrawCryptocurrencyFunds(withdrawCryptoRequest)
+	if !areTestAPIKeysSet() && err == nil {
+		t.Errorf("Expecting an error when no keys are set: %v", err)
+	}
+	if areTestAPIKeysSet() && err != nil {
+		t.Errorf("Withdraw failed to be placed: %v", err)
+	}
+}

exchanges/bitfinex/bitfinex_wrapper.go

@@ -1,6 +1,7 @@
 package bitfinex
 
 import (
+	"errors"
 	"fmt"
 	"log"
 	"net/url"
@@ -233,19 +234,32 @@ func (b *Bitfinex) GetDepositAddress(cryptocurrency pair.CurrencyItem) (string,
 }
 
 // WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is submitted
-func (b *Bitfinex) WithdrawCryptocurrencyFunds(address string, cryptocurrency pair.CurrencyItem, amount float64) (string, error) {
-	return "", common.ErrNotYetImplemented
+func (b *Bitfinex) WithdrawCryptocurrencyFunds(withdrawRequest exchange.WithdrawRequest) (string, error) {
+	withdrawalType := b.ConvertSymbolToWithdrawalType(withdrawRequest.Currency.String())
+	// Bitfinex has support for three types, exchange, margin and deposit
+	// As this is for trading, I've made the wrapper default 'exchange'
+	// TODO: Discover an automated way to make the decision for wallet type to withdraw from
+	walletType := "exchange"
+	resp, err := b.WithdrawCryptocurrency(withdrawalType, walletType, withdrawRequest.Address, withdrawRequest.Currency.String(), withdrawRequest.Description, withdrawRequest.Amount)
+	if err != nil {
+		return "", err
+	}
+	if len(resp) == 0 {
+		return "", errors.New("No withdrawID returned. Check order status")
+	}
+
+	return fmt.Sprintf("%v", resp[0].WithdrawalID), err
 }
 
 // WithdrawFiatFunds returns a withdrawal ID when a
 // withdrawal is submitted
-func (b *Bitfinex) WithdrawFiatFunds(currency pair.CurrencyItem, amount float64) (string, error) {
+func (b *Bitfinex) WithdrawFiatFunds(withdrawRequest exchange.WithdrawRequest) (string, error) {
 	return "", common.ErrNotYetImplemented
 }
 
 // WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a
 // withdrawal is submitted
-func (b *Bitfinex) WithdrawFiatFundsToInternationalBank(currency pair.CurrencyItem, amount float64) (string, error) {
+func (b *Bitfinex) WithdrawFiatFundsToInternationalBank(withdrawRequest exchange.WithdrawRequest) (string, error) {
 	return "", common.ErrNotYetImplemented
 }