mirror of
https://github.com/d0zingcat/gocryptotrader.git
synced 2026-05-13 23:16:45 +00:00
440 lines
12 KiB
Go
440 lines
12 KiB
Go
package alphapoint
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
"github.com/thrasher-/gocryptotrader/common"
|
|
"github.com/thrasher-/gocryptotrader/exchanges"
|
|
)
|
|
|
|
const (
|
|
ALPHAPOINT_DEFAULT_API_URL = "https://sim3.alphapoint.com:8400"
|
|
ALPHAPOINT_API_VERSION = "1"
|
|
ALPHAPOINT_TICKER = "GetTicker"
|
|
ALPHAPOINT_TRADES = "GetTrades"
|
|
ALPHAPOINT_TRADESBYDATE = "GetTradesByDate"
|
|
ALPHAPOINT_ORDERBOOK = "GetOrderBook"
|
|
ALPHAPOINT_PRODUCT_PAIRS = "GetProductPairs"
|
|
ALPHAPOINT_PRODUCTS = "GetProducts"
|
|
ALPHAPOINT_CREATE_ACCOUNT = "CreateAccount"
|
|
ALPHAPOINT_USERINFO = "GetUserInfo"
|
|
ALPHAPOINT_ACCOUNT_INFO = "GetAccountInfo"
|
|
ALPHAPOINT_ACCOUNT_TRADES = "GetAccountTrades"
|
|
ALPHAPOINT_DEPOSIT_ADDRESSES = "GetDepositAddresses"
|
|
ALPHAPOINT_WITHDRAW = "Withdraw"
|
|
ALPHAPOINT_CREATE_ORDER = "CreateOrder"
|
|
ALPHAPOINT_MODIFY_ORDER = "ModifyOrder"
|
|
ALPHAPOINT_CANCEL_ORDER = "CancelOrder"
|
|
ALPHAPOINT_CANCEALLORDERS = "CancelAllOrders"
|
|
ALPHAPOINT_OPEN_ORDERS = "GetAccountOpenOrders"
|
|
ALPHAPOINT_ORDER_FEE = "GetOrderFee"
|
|
)
|
|
|
|
type Alphapoint struct {
|
|
exchange.Base
|
|
WebsocketConn *websocket.Conn
|
|
}
|
|
|
|
func (a *Alphapoint) SetDefaults() {
|
|
a.APIUrl = ALPHAPOINT_DEFAULT_API_URL
|
|
a.WebsocketURL = ALPHAPOINT_DEFAULT_WEBSOCKET_URL
|
|
}
|
|
|
|
func (a *Alphapoint) GetTicker(symbol string) (AlphapointTicker, error) {
|
|
request := make(map[string]interface{})
|
|
request["productPair"] = symbol
|
|
response := AlphapointTicker{}
|
|
err := a.SendRequest("POST", ALPHAPOINT_TICKER, request, &response)
|
|
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetTrades(symbol string, startIndex, count int) (AlphapointTrades, error) {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["startIndex"] = startIndex
|
|
request["Count"] = count
|
|
response := AlphapointTrades{}
|
|
err := a.SendRequest("POST", ALPHAPOINT_TRADES, request, &response)
|
|
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetTradesByDate(symbol string, startDate, endDate int64) (AlphapointTradesByDate, error) {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["startDate"] = startDate
|
|
request["endDate"] = endDate
|
|
response := AlphapointTradesByDate{}
|
|
err := a.SendRequest("POST", ALPHAPOINT_TRADESBYDATE, request, &response)
|
|
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetOrderbook(symbol string) (AlphapointOrderbook, error) {
|
|
request := make(map[string]interface{})
|
|
request["productPair"] = symbol
|
|
response := AlphapointOrderbook{}
|
|
err := a.SendRequest("POST", ALPHAPOINT_ORDERBOOK, request, &response)
|
|
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetProductPairs() (AlphapointProductPairs, error) {
|
|
response := AlphapointProductPairs{}
|
|
err := a.SendRequest("POST", ALPHAPOINT_PRODUCT_PAIRS, nil, &response)
|
|
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetProducts() (AlphapointProducts, error) {
|
|
response := AlphapointProducts{}
|
|
err := a.SendRequest("POST", ALPHAPOINT_PRODUCTS, nil, &response)
|
|
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) CreateAccount(firstName, lastName, email, phone, password string) error {
|
|
if len(password) < 8 {
|
|
return errors.New("Alphapoint Error - Create account - Password must be 8 characters or more.")
|
|
}
|
|
|
|
request := make(map[string]interface{})
|
|
request["firstname"] = firstName
|
|
request["lastname"] = lastName
|
|
request["email"] = email
|
|
request["phone"] = phone
|
|
request["password"] = password
|
|
|
|
type Response struct {
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
}
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_CREATE_ACCOUNT, request, &response)
|
|
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return errors.New(response.RejectReason)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetUserInfo() (AlphapointUserInfo, error) {
|
|
response := AlphapointUserInfo{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_USERINFO, map[string]interface{}{}, &response)
|
|
if err != nil {
|
|
return AlphapointUserInfo{}, err
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetAccountInfo() (AlphapointAccountInfo, error) {
|
|
response := AlphapointAccountInfo{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_ACCOUNT_INFO, map[string]interface{}{}, &response)
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetAccountTrades(symbol string, startIndex, count int) (AlphapointTrades, error) {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["startIndex"] = startIndex
|
|
request["count"] = count
|
|
|
|
response := AlphapointTrades{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_ACCOUNT_TRADES, request, &response)
|
|
if err != nil {
|
|
return response, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return response, errors.New(response.RejectReason)
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetDepositAddresses() ([]AlphapointDepositAddresses, error) {
|
|
type Response struct {
|
|
Addresses []AlphapointDepositAddresses
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
}
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_DEPOSIT_ADDRESSES, map[string]interface{}{}, &response)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !response.IsAccepted {
|
|
return nil, errors.New(response.RejectReason)
|
|
}
|
|
return response.Addresses, nil
|
|
}
|
|
|
|
func (a *Alphapoint) WithdrawCoins(symbol, product string, amount float64, address string) error {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["product"] = product
|
|
request["amount"] = strconv.FormatFloat(amount, 'f', -1, 64)
|
|
request["sendToAddress"] = address
|
|
|
|
type Response struct {
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
}
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_WITHDRAW, request, &response)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return errors.New(response.RejectReason)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (a *Alphapoint) CreateOrder(symbol, side string, orderType int, quantity, price float64) (int64, error) {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["side"] = side
|
|
request["orderType"] = orderType
|
|
request["qty"] = strconv.FormatFloat(quantity, 'f', -1, 64)
|
|
request["px"] = strconv.FormatFloat(price, 'f', -1, 64)
|
|
|
|
type Response struct {
|
|
ServerOrderID int64 `json:"serverOrderId"`
|
|
DateTimeUTC float64 `json:"dateTimeUtc"`
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
}
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_CREATE_ORDER, request, &response)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return 0, errors.New(response.RejectReason)
|
|
}
|
|
return response.ServerOrderID, nil
|
|
}
|
|
|
|
func (a *Alphapoint) ModifyOrder(symbol string, OrderID, action int64) (int64, error) {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["serverOrderId"] = OrderID
|
|
request["modifyAction"] = action
|
|
|
|
type Response struct {
|
|
ModifyOrderID int64 `json:"modifyOrderId"`
|
|
ServerOrderID int64 `json:"serverOrderId"`
|
|
DateTimeUTC float64 `json:"dateTimeUtc"`
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
}
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_MODIFY_ORDER, request, &response)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return 0, errors.New(response.RejectReason)
|
|
}
|
|
return response.ModifyOrderID, nil
|
|
}
|
|
|
|
func (a *Alphapoint) CancelOrder(symbol string, OrderID int64) (int64, error) {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["serverOrderId"] = OrderID
|
|
|
|
type Response struct {
|
|
CancelOrderID int64 `json:"cancelOrderId"`
|
|
ServerOrderID int64 `json:"serverOrderId"`
|
|
DateTimeUTC float64 `json:"dateTimeUtc"`
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
}
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_CANCEL_ORDER, request, &response)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return 0, errors.New(response.RejectReason)
|
|
}
|
|
return response.CancelOrderID, nil
|
|
}
|
|
|
|
func (a *Alphapoint) CancelAllOrders(symbol string) error {
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
|
|
type Response struct {
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
}
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_CANCEALLORDERS, request, &response)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return errors.New(response.RejectReason)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetOrders() ([]AlphapointOpenOrders, error) {
|
|
response := AlphapointOrderInfo{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_OPEN_ORDERS, map[string]interface{}{}, &response)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return nil, errors.New(response.RejectReason)
|
|
}
|
|
return response.OpenOrders, nil
|
|
}
|
|
|
|
func (a *Alphapoint) GetOrderFee(symbol, side string, quantity, price float64) (float64, error) {
|
|
type Response struct {
|
|
IsAccepted bool `json:"isAccepted"`
|
|
RejectReason string `json:"rejectReason"`
|
|
Fee float64 `json:"fee"`
|
|
FeeProduct string `json:"feeProduct"`
|
|
}
|
|
|
|
request := make(map[string]interface{})
|
|
request["ins"] = symbol
|
|
request["side"] = side
|
|
request["qty"] = strconv.FormatFloat(quantity, 'f', -1, 64)
|
|
request["px"] = strconv.FormatFloat(price, 'f', -1, 64)
|
|
|
|
response := Response{}
|
|
err := a.SendAuthenticatedHTTPRequest("POST", ALPHAPOINT_ORDER_FEE, request, &response)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if !response.IsAccepted {
|
|
return 0, errors.New(response.RejectReason)
|
|
}
|
|
return response.Fee, nil
|
|
}
|
|
|
|
func (a *Alphapoint) SendRequest(method, path string, data map[string]interface{}, result interface{}) error {
|
|
headers := make(map[string]string)
|
|
headers["Content-Type"] = "application/json"
|
|
path = fmt.Sprintf("%s/ajax/v%s/%s", a.APIUrl, ALPHAPOINT_API_VERSION, path)
|
|
PayloadJSON, err := common.JSONEncode(data)
|
|
|
|
if err != nil {
|
|
return errors.New("SendAuthenticatedHTTPRequest: Unable to JSON request")
|
|
}
|
|
resp, err := common.SendHTTPRequest(method, path, headers, bytes.NewBuffer(PayloadJSON))
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = common.JSONDecode([]byte(resp), &result)
|
|
|
|
if err != nil {
|
|
return errors.New("Unable to JSON Unmarshal response.")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (a *Alphapoint) SendAuthenticatedHTTPRequest(method, path string, data map[string]interface{}, result interface{}) error {
|
|
headers := make(map[string]string)
|
|
headers["Content-Type"] = "application/json"
|
|
data["apiKey"] = a.APIKey
|
|
nonce := time.Now().UnixNano()
|
|
nonceStr := strconv.FormatInt(nonce, 10)
|
|
data["apiNonce"] = nonce
|
|
hmac := common.GetHMAC(common.HashSHA256, []byte(nonceStr+a.ClientID+a.APIKey), []byte(a.APISecret))
|
|
data["apiSig"] = common.StringToUpper(common.HexEncodeToString(hmac))
|
|
path = fmt.Sprintf("%s/ajax/v%s/%s", a.APIUrl, ALPHAPOINT_API_VERSION, path)
|
|
PayloadJSON, err := common.JSONEncode(data)
|
|
|
|
if err != nil {
|
|
return errors.New("SendAuthenticatedHTTPRequest: Unable to JSON request")
|
|
}
|
|
|
|
resp, err := common.SendHTTPRequest(method, path, headers, bytes.NewBuffer(PayloadJSON))
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = common.JSONDecode([]byte(resp), &result)
|
|
|
|
if err != nil {
|
|
return errors.New("Unable to JSON Unmarshal response.")
|
|
}
|
|
return nil
|
|
}
|