2939 lines
128 KiB
Go
2939 lines
128 KiB
Go
package ccxt
|
|
|
|
// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
|
|
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
|
|
|
|
type coinlist struct {
|
|
Exchange
|
|
|
|
}
|
|
|
|
func NewCoinlistCore() coinlist {
|
|
p := coinlist{}
|
|
setDefaults(&p)
|
|
return p
|
|
}
|
|
|
|
func (this *coinlist) Describe() interface{} {
|
|
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
|
|
"id": "coinlist",
|
|
"name": "Coinlist",
|
|
"countries": []interface{}{"US"},
|
|
"version": "v1",
|
|
"rateLimit": 300,
|
|
"certified": false,
|
|
"pro": false,
|
|
"has": map[string]interface{} {
|
|
"CORS": nil,
|
|
"spot": true,
|
|
"margin": false,
|
|
"swap": false,
|
|
"future": false,
|
|
"option": false,
|
|
"addMargin": false,
|
|
"cancelAllOrders": true,
|
|
"cancelOrder": true,
|
|
"cancelOrders": true,
|
|
"closeAllPositions": false,
|
|
"closePosition": false,
|
|
"createDepositAddress": false,
|
|
"createOrder": true,
|
|
"createPostOnlyOrder": true,
|
|
"createReduceOnlyOrder": false,
|
|
"createStopLimitOrder": true,
|
|
"createStopMarketOrder": true,
|
|
"createStopOrder": true,
|
|
"deposit": false,
|
|
"editOrder": true,
|
|
"fetchAccounts": true,
|
|
"fetchBalance": true,
|
|
"fetchBidsAsks": false,
|
|
"fetchBorrowInterest": false,
|
|
"fetchBorrowRateHistories": false,
|
|
"fetchBorrowRateHistory": false,
|
|
"fetchCanceledOrders": true,
|
|
"fetchClosedOrder": false,
|
|
"fetchClosedOrders": true,
|
|
"fetchCrossBorrowRate": false,
|
|
"fetchCrossBorrowRates": false,
|
|
"fetchCurrencies": true,
|
|
"fetchDeposit": false,
|
|
"fetchDepositAddress": false,
|
|
"fetchDepositAddresses": false,
|
|
"fetchDepositAddressesByNetwork": false,
|
|
"fetchDeposits": false,
|
|
"fetchDepositsWithdrawals": true,
|
|
"fetchDepositWithdrawFee": false,
|
|
"fetchDepositWithdrawFees": false,
|
|
"fetchFundingHistory": false,
|
|
"fetchFundingRate": false,
|
|
"fetchFundingRateHistory": false,
|
|
"fetchFundingRates": false,
|
|
"fetchIndexOHLCV": false,
|
|
"fetchIsolatedBorrowRate": false,
|
|
"fetchIsolatedBorrowRates": false,
|
|
"fetchL3OrderBook": false,
|
|
"fetchLedger": true,
|
|
"fetchLeverage": false,
|
|
"fetchLeverageTiers": false,
|
|
"fetchMarketLeverageTiers": false,
|
|
"fetchMarkets": true,
|
|
"fetchMarkOHLCV": false,
|
|
"fetchMyTrades": true,
|
|
"fetchOHLCV": true,
|
|
"fetchOpenInterestHistory": false,
|
|
"fetchOpenOrder": false,
|
|
"fetchOpenOrders": true,
|
|
"fetchOrder": true,
|
|
"fetchOrderBook": true,
|
|
"fetchOrderBooks": false,
|
|
"fetchOrders": true,
|
|
"fetchOrderTrades": true,
|
|
"fetchPosition": false,
|
|
"fetchPositionHistory": false,
|
|
"fetchPositionMode": false,
|
|
"fetchPositions": false,
|
|
"fetchPositionsForSymbol": false,
|
|
"fetchPositionsHistory": false,
|
|
"fetchPositionsRisk": false,
|
|
"fetchPremiumIndexOHLCV": false,
|
|
"fetchStatus": false,
|
|
"fetchTicker": true,
|
|
"fetchTickers": true,
|
|
"fetchTime": true,
|
|
"fetchTrades": true,
|
|
"fetchTradingFee": false,
|
|
"fetchTradingFees": true,
|
|
"fetchTradingLimits": false,
|
|
"fetchTransactionFee": false,
|
|
"fetchTransactionFees": false,
|
|
"fetchTransactions": true,
|
|
"fetchTransfers": true,
|
|
"fetchWithdrawal": false,
|
|
"fetchWithdrawals": false,
|
|
"fetchWithdrawalWhitelist": false,
|
|
"reduceMargin": false,
|
|
"repayCrossMargin": false,
|
|
"repayIsolatedMargin": false,
|
|
"setLeverage": false,
|
|
"setMargin": false,
|
|
"setMarginMode": false,
|
|
"setPositionMode": false,
|
|
"signIn": false,
|
|
"transfer": true,
|
|
"withdraw": true,
|
|
"ws": false,
|
|
},
|
|
"timeframes": map[string]interface{} {
|
|
"1m": "1m",
|
|
"5m": "5m",
|
|
"30m": "30m",
|
|
},
|
|
"urls": map[string]interface{} {
|
|
"logo": "https://github-production-user-asset-6210df.s3.amazonaws.com/1294454/281108917-eff2ae1d-ce8a-4b2a-950d-8678b12da965.jpg",
|
|
"api": map[string]interface{} {
|
|
"public": "https://trade-api.coinlist.co",
|
|
"private": "https://trade-api.coinlist.co",
|
|
},
|
|
"www": "https://coinlist.co",
|
|
"doc": []interface{}{"https://trade-docs.coinlist.co"},
|
|
"fees": "https://coinlist.co/fees",
|
|
},
|
|
"api": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"v1/symbols": 1,
|
|
"v1/symbols/summary": 1,
|
|
"v1/symbols/{symbol}": 1,
|
|
"v1/symbols/{symbol}/summary": 1,
|
|
"v1/symbols/{symbol}/book": 1,
|
|
"v1/symbols/{symbol}/quote": 1,
|
|
"v1/symbols/{symbol}/candles": 1,
|
|
"v1/symbols/{symbol}/auctions": 1,
|
|
"v1/symbols/{symbol}/auctions/{auction_code}": 1,
|
|
"v1/time": 1,
|
|
"v1/assets": 1,
|
|
"v1/leaderboard": 1,
|
|
"v1/affiliate/{competition_code}": 1,
|
|
"v1/competition/{competition_id}": 1,
|
|
},
|
|
},
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"v1/fees": 1,
|
|
"v1/accounts": 1,
|
|
"v1/accounts/{trader_id}": 1,
|
|
"v1/accounts/{trader_id}/alias": 1,
|
|
"v1/accounts/{trader_id}/ledger": 1,
|
|
"v1/accounts/{trader_id}/wallets": 1,
|
|
"v1/accounts/{trader_id}/wallet-ledger": 1,
|
|
"v1/accounts/{trader_id}/ledger-summary": 1,
|
|
"v1/keys": 1,
|
|
"v1/fills": 1,
|
|
"v1/orders": 1,
|
|
"v1/orders/{order_id}": 1,
|
|
"v1/reports": 1,
|
|
"v1/balances": 1,
|
|
"v1/transfers": 1,
|
|
"v1/user": 1,
|
|
"v1/credits": 1,
|
|
"v1/positions": 1,
|
|
"v1/accounts/{trader_id}/competitions": 1,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"v1/keys": 1,
|
|
"v1/orders": 1,
|
|
"v1/orders/cancel-all-after": 1,
|
|
"v1/reports": 1,
|
|
"v1/transfers/to-wallet": 1,
|
|
"v1/transfers/from-wallet": 1,
|
|
"v1/transfers/internal-transfer": 1,
|
|
"v1/transfers/withdrawal-request": 1,
|
|
"v1/orders/bulk": 1,
|
|
"v1/accounts/{trader_id}/competitions": 1,
|
|
"v1/accounts/{trader_id}/create-competition": 1,
|
|
},
|
|
"patch": map[string]interface{} {
|
|
"v1/orders/{order_id}": 1,
|
|
"v1/orders/bulk": 1,
|
|
},
|
|
"delete": map[string]interface{} {
|
|
"v1/keys/{key}": 1,
|
|
"v1/orders": 1,
|
|
"v1/orders/{order_id}": 1,
|
|
"v1/orders/bulk": 1,
|
|
},
|
|
},
|
|
},
|
|
"features": map[string]interface{} {
|
|
"default": map[string]interface{} {
|
|
"sandbox": false,
|
|
"createOrder": map[string]interface{} {
|
|
"marginMode": false,
|
|
"triggerPrice": true,
|
|
"triggerPriceType": map[string]interface{} {
|
|
"last": true,
|
|
"mark": true,
|
|
"index": true,
|
|
},
|
|
"triggerDirection": false,
|
|
"stopLossPrice": false,
|
|
"takeProfitPrice": false,
|
|
"attachedStopLossTakeProfit": nil,
|
|
"timeInForce": map[string]interface{} {
|
|
"IOC": false,
|
|
"FOK": false,
|
|
"PO": true,
|
|
"GTD": false,
|
|
},
|
|
"hedged": false,
|
|
"trailing": true,
|
|
"leverage": false,
|
|
"marketBuyByCost": false,
|
|
"marketBuyRequiresPrice": false,
|
|
"selfTradePrevention": true,
|
|
"iceberg": false,
|
|
},
|
|
"createOrders": nil,
|
|
"fetchMyTrades": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 500,
|
|
"daysBack": 100000,
|
|
"untilDays": 100000,
|
|
"symbolRequired": false,
|
|
},
|
|
"fetchOrder": map[string]interface{} {
|
|
"marginMode": false,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": false,
|
|
},
|
|
"fetchOpenOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 500,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": false,
|
|
},
|
|
"fetchOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 500,
|
|
"daysBack": 100000,
|
|
"untilDays": 100000,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": false,
|
|
},
|
|
"fetchClosedOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 500,
|
|
"daysBack": 100000,
|
|
"daysBackCanceled": nil,
|
|
"untilDays": 100000,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": false,
|
|
},
|
|
"fetchOHLCV": map[string]interface{} {
|
|
"limit": 300,
|
|
},
|
|
},
|
|
"swap": map[string]interface{} {
|
|
"linear": nil,
|
|
"inverse": nil,
|
|
},
|
|
"future": map[string]interface{} {
|
|
"linear": nil,
|
|
"inverse": nil,
|
|
},
|
|
},
|
|
"fees": map[string]interface{} {
|
|
"trading": map[string]interface{} {
|
|
"feeSide": "get",
|
|
"tierBased": true,
|
|
"percentage": true,
|
|
"taker": this.ParseNumber("0.0045"),
|
|
"maker": this.ParseNumber("0.0025"),
|
|
"tiers": map[string]interface{} {
|
|
"taker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.0045")}, []interface{}{this.ParseNumber("20000"), this.ParseNumber("0.003")}, []interface{}{this.ParseNumber("50000"), this.ParseNumber("0.0025")}, []interface{}{this.ParseNumber("100000"), this.ParseNumber("0.002")}, []interface{}{this.ParseNumber("500000"), this.ParseNumber("0.0018")}, []interface{}{this.ParseNumber("750000"), this.ParseNumber("0.0018")}, []interface{}{this.ParseNumber("1000000"), this.ParseNumber("0.0016")}, []interface{}{this.ParseNumber("2500000"), this.ParseNumber("0.0013")}, []interface{}{this.ParseNumber("5000000"), this.ParseNumber("0.0012")}, []interface{}{this.ParseNumber("10000000"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("50000000"), this.ParseNumber("0.0005")}, []interface{}{this.ParseNumber("100000000"), this.ParseNumber("0.0005")}},
|
|
"maker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.0025")}, []interface{}{this.ParseNumber("20000"), this.ParseNumber("0.0025")}, []interface{}{this.ParseNumber("50000"), this.ParseNumber("0.0025")}, []interface{}{this.ParseNumber("100000"), this.ParseNumber("0.002")}, []interface{}{this.ParseNumber("500000"), this.ParseNumber("0.0015")}, []interface{}{this.ParseNumber("750000"), this.ParseNumber("0.0012")}, []interface{}{this.ParseNumber("1000000"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("2500000"), this.ParseNumber("0.0008")}, []interface{}{this.ParseNumber("5000000"), this.ParseNumber("0.0007")}, []interface{}{this.ParseNumber("10000000"), this.ParseNumber("0.0006")}, []interface{}{this.ParseNumber("50000000"), this.ParseNumber("0.0000")}, []interface{}{this.ParseNumber("100000000"), this.ParseNumber("0.00")}},
|
|
},
|
|
},
|
|
},
|
|
"precisionMode": TICK_SIZE,
|
|
"options": map[string]interface{} {
|
|
"accountsByType": map[string]interface{} {
|
|
"CoinList Pro": "trading",
|
|
"CoinList Pro trading account": "trading",
|
|
"Pro": "trading",
|
|
"pro": "trading",
|
|
"trade": "trading",
|
|
"trading": "trading",
|
|
"CoinList": "funding",
|
|
"CoinList wallet": "funding",
|
|
"Wallet": "funding",
|
|
"wallet": "funding",
|
|
"fund": "funding",
|
|
"funding": "funding",
|
|
},
|
|
},
|
|
"exceptions": map[string]interface{} {
|
|
"exact": map[string]interface{} {
|
|
"AUTH_SIG_INVALID": AuthenticationError,
|
|
"DENIED_MAINTENANCE": OnMaintenance,
|
|
"ORDER_REJECT_BAD_STATUS": InvalidOrder,
|
|
"ORDER_REJECT_INVALID_POST_ONLY": InvalidOrder,
|
|
"ORDER_REJECT_INVALID_CLOSE_ONLY": InvalidOrder,
|
|
"ORDER_REJECT_POST_ONLY_REQUIRED": InvalidOrder,
|
|
"ORDER_REJECT_FROZEN_ORDER": InvalidOrder,
|
|
"ORDER_REJECT_LIMIT_PRICE_PROTECTION_VIOLATION": InvalidOrder,
|
|
"ORDER_REJECT_CLOSED": NotSupported,
|
|
"ORDER_REJECT_MAX_ORDERS": BadRequest,
|
|
"ORDER_REJECT_NOT_FOUND": OrderNotFound,
|
|
"ORDER_REJECT_PARSE_ERROR": BadRequest,
|
|
"ORDER_REJECT_PRICE_INVALID": InvalidOrder,
|
|
"ORDER_REJECT_QUANTITY_ZERO": InvalidOrder,
|
|
"ORDER_REJECT_TOKEN_LIMIT": InsufficientFunds,
|
|
"ORDER_REJECT_TOKEN_LIMIT_OTHER": InvalidOrder,
|
|
"ORDER_REJECT_SELF_TRADE": InvalidOrder,
|
|
"ORDER_VALIDATE_BAD_SIZE_ALIGNMENT": InvalidOrder,
|
|
"ORDER_VALIDATE_BAD_TICK_ALIGNMENT": InvalidOrder,
|
|
"ORDER_VALIDATE_SYMBOL_NOT_FOUND": BadSymbol,
|
|
"TRANSFERS_WITHDRAWAL_REQUEST_TOO_LARGE": InsufficientFunds,
|
|
"WITHDRAWAL_REQUEST_NOT_ALLOWED": PermissionDenied,
|
|
},
|
|
"broad": map[string]interface{} {
|
|
"A destinationAddress is required for non-USD withdrawals": InvalidAddress,
|
|
"fails to match the JsonSchema date-time format pattern": BadRequest,
|
|
"is required": ArgumentsRequired,
|
|
"must be a string": BadRequest,
|
|
"must be a valid GUID": BadRequest,
|
|
"must be greater than or equal to": BadRequest,
|
|
"must be less than or equal to": BadRequest,
|
|
"must be one of": BadRequest,
|
|
"Symbol not found": BadSymbol,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
func (this *coinlist) CalculateRateLimiterCost(api interface{}, method interface{}, path interface{}, params interface{}, optionalArgs ...interface{}) interface{} {
|
|
config := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = config
|
|
if IsTrue(IsArray(params)) {
|
|
var length interface{} = GetArrayLength(params)
|
|
return MathCeil(Divide(length, 2))
|
|
}
|
|
return 1
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchTime
|
|
* @description fetches the current integer timestamp in milliseconds from the exchange server
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-system-time
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {int} the current integer timestamp in milliseconds from the exchange server
|
|
*/
|
|
func (this *coinlist) FetchTime(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
response:= (<-this.PublicGetV1Time(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "epoch": 1698087996.039,
|
|
// "iso": "2023-10-23T19:06:36.039Z"
|
|
// }
|
|
//
|
|
var string interface{} = this.SafeString(response, "iso")
|
|
|
|
ch <- this.Parse8601(string)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchCurrencies
|
|
* @description fetches all available currencies on an exchange
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-supported-assets
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} an associative dictionary of currencies
|
|
*/
|
|
func (this *coinlist) FetchCurrencies(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
response:= (<-this.PublicGetV1Assets(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "assets": [
|
|
// {
|
|
// "asset": "AAVE",
|
|
// "index_code": ".AAVEUSD",
|
|
// "decimal_places": 18,
|
|
// "min_withdrawal": "1.0000",
|
|
// "is_transferable": true,
|
|
// "is_visible": true
|
|
// },
|
|
// {
|
|
// "asset": "ALGO",
|
|
// "index_code": ".ALGOUSD",
|
|
// "decimal_places": 6,
|
|
// "min_withdrawal": "1.0000",
|
|
// "is_transferable": true,
|
|
// "is_visible": true
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var currencies interface{} = this.SafeValue(response, "assets", []interface{}{})
|
|
var result interface{} = map[string]interface{} {}
|
|
for i := 0; IsLessThan(i, GetArrayLength(currencies)); i++ {
|
|
var currency interface{} = GetValue(currencies, i)
|
|
var id interface{} = this.SafeString(currency, "asset")
|
|
var code interface{} = this.SafeCurrencyCode(id)
|
|
var isTransferable interface{} = this.SafeBool(currency, "is_transferable", false)
|
|
var withdrawEnabled interface{} = isTransferable
|
|
var depositEnabled interface{} = isTransferable
|
|
var active interface{} = isTransferable
|
|
var decimalPlaces interface{} = this.SafeString(currency, "decimal_places")
|
|
var precision interface{} = this.ParseNumber(this.ParsePrecision(decimalPlaces))
|
|
var minWithdrawal interface{} = this.SafeString(currency, "min_withdrawal")
|
|
AddElementToObject(result, code, map[string]interface{} {
|
|
"id": id,
|
|
"code": code,
|
|
"name": code,
|
|
"info": currency,
|
|
"active": active,
|
|
"deposit": depositEnabled,
|
|
"withdraw": withdrawEnabled,
|
|
"fee": nil,
|
|
"precision": precision,
|
|
"limits": map[string]interface{} {
|
|
"amount": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
"withdraw": map[string]interface{} {
|
|
"min": minWithdrawal,
|
|
"max": nil,
|
|
},
|
|
},
|
|
"networks": map[string]interface{} {},
|
|
})
|
|
}
|
|
|
|
ch <- result
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchMarkets
|
|
* @description retrieves data on all markets for coinlist
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-symbols
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object[]} an array of objects representing market data
|
|
*/
|
|
func (this *coinlist) FetchMarkets(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
response:= (<-this.PublicGetV1Symbols(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "symbols": [
|
|
// {
|
|
// "symbol": "CQT-USDT",
|
|
// "base_currency": "CQT",
|
|
// "is_trader_geofenced": false,
|
|
// "list_time": "2021-06-15T00:00:00.000Z",
|
|
// "type": "spot",
|
|
// "series_code": "CQT-USDT-SPOT",
|
|
// "long_name": "Covalent",
|
|
// "asset_class": "CRYPTO",
|
|
// "minimum_price_increment": "0.0001",
|
|
// "minimum_size_increment": "0.0001",
|
|
// "quote_currency": "USDT",
|
|
// "index_code": null,
|
|
// "price_band_threshold_market": "0.05",
|
|
// "price_band_threshold_limit": "0.25",
|
|
// "last_price": "0.12160000",
|
|
// "fair_price": "0.12300000",
|
|
// "index_price": null
|
|
// },
|
|
// ]
|
|
// }
|
|
//
|
|
var markets interface{} = this.SafeValue(response, "symbols", []interface{}{})
|
|
|
|
ch <- this.ParseMarkets(markets)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseMarket(market interface{}) interface{} {
|
|
var id interface{} = this.SafeString(market, "symbol")
|
|
var baseId interface{} = this.SafeString(market, "base_currency")
|
|
var quoteId interface{} = this.SafeString(market, "quote_currency")
|
|
var base interface{} = this.SafeCurrencyCode(baseId)
|
|
var quote interface{} = this.SafeCurrencyCode(quoteId)
|
|
var amountPrecision interface{} = this.SafeString(market, "minimum_size_increment")
|
|
var pricePrecision interface{} = this.SafeString(market, "minimum_price_increment")
|
|
var created interface{} = this.SafeString(market, "list_time")
|
|
return map[string]interface{} {
|
|
"id": id,
|
|
"symbol": Add(Add(base, "/"), quote),
|
|
"base": base,
|
|
"quote": quote,
|
|
"settle": nil,
|
|
"baseId": baseId,
|
|
"quoteId": quoteId,
|
|
"settleId": nil,
|
|
"type": "spot",
|
|
"spot": true,
|
|
"margin": false,
|
|
"swap": false,
|
|
"future": false,
|
|
"option": false,
|
|
"active": true,
|
|
"contract": false,
|
|
"linear": nil,
|
|
"inverse": nil,
|
|
"contractSize": nil,
|
|
"expiry": nil,
|
|
"expiryDatetime": nil,
|
|
"strike": nil,
|
|
"optionType": nil,
|
|
"precision": map[string]interface{} {
|
|
"amount": this.ParseNumber(amountPrecision),
|
|
"price": this.ParseNumber(pricePrecision),
|
|
},
|
|
"limits": map[string]interface{} {
|
|
"leverage": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
"amount": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
"price": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
"cost": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
},
|
|
"created": this.Parse8601(created),
|
|
"info": market,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchTickers
|
|
* @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-symbol-summaries
|
|
* @param {string[]} [symbols] unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
|
*/
|
|
func (this *coinlist) FetchTickers(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbols := GetArg(optionalArgs, 0, nil)
|
|
_ = symbols
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes5878 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes5878)
|
|
var request interface{} = map[string]interface{} {}
|
|
|
|
tickers:= (<-this.PublicGetV1SymbolsSummary(this.Extend(request, params)))
|
|
PanicOnError(tickers)
|
|
|
|
//
|
|
// {
|
|
// "MATIC-USD": {
|
|
// "type":"spot",
|
|
// "last_price":"0.60990000",
|
|
// "lowest_ask":"0.61190000",
|
|
// "highest_bid":"0.60790000",
|
|
// "last_trade": {
|
|
// "price":"0.60000000",
|
|
// "volume":"2.0000",
|
|
// "imbalance":"198.0000",
|
|
// "logicalTime":"2023-10-22T23:02:25.000Z",
|
|
// "auctionCode":"MATIC-USD-2023-10-22T23:02:25.000Z"
|
|
// },
|
|
// "volume_base_24h":"34.0555",
|
|
// "volume_quote_24h":"19.9282",
|
|
// "price_change_percent_24h":"7.50925436",
|
|
// "highest_price_24h":"0.68560000",
|
|
// "lowest_price_24h":"0.55500000"
|
|
// },
|
|
// }
|
|
//
|
|
ch <- this.ParseTickers(tickers, symbols, params)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchTicker
|
|
* @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-market-summary
|
|
* @param {string} symbol unified symbol of the market to fetch the ticker for
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
|
*/
|
|
func (this *coinlist) FetchTicker(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes6258 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes6258)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
|
|
ticker:= (<-this.PublicGetV1SymbolsSymbolSummary(this.Extend(request, params)))
|
|
PanicOnError(ticker)
|
|
|
|
//
|
|
// {
|
|
// "type":"spot",
|
|
// "last_price":"31125.00000000",
|
|
// "lowest_ask":"31349.99000000",
|
|
// "highest_bid":"30900.00000000",
|
|
// "last_trade": {
|
|
// "price":"31000.00000000",
|
|
// "volume":"0.0003",
|
|
// "imbalance":"0.0000",
|
|
// "logicalTime":"2023-10-23T16:57:15.000Z",
|
|
// "auctionCode":"BTC-USDT-2023-10-23T16:57:15.000Z"
|
|
// },
|
|
// "volume_base_24h":"0.3752",
|
|
// "volume_quote_24h":"11382.7181",
|
|
// "price_change_percent_24h":"3.66264694",
|
|
// "highest_price_24h":"31225.12000000",
|
|
// "lowest_price_24h":"29792.81000000"
|
|
// }
|
|
//
|
|
ch <- this.ParseTicker(ticker, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "type":"spot",
|
|
// "last_price":"0.60990000",
|
|
// "lowest_ask":"0.61190000",
|
|
// "highest_bid":"0.60790000",
|
|
// "last_trade": {
|
|
// "price":"0.60000000",
|
|
// "volume":"2.0000",
|
|
// "imbalance":"198.0000",
|
|
// "logicalTime":"2023-10-22T23:02:25.000Z",
|
|
// "auctionCode":"MATIC-USD-2023-10-22T23:02:25.000Z"
|
|
// },
|
|
// "volume_base_24h":"34.0555",
|
|
// "volume_quote_24h":"19.9282",
|
|
// "price_change_percent_24h":"7.50925436",
|
|
// "highest_price_24h":"0.68560000",
|
|
// "lowest_price_24h":"0.55500000"
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var lastTrade interface{} = this.SafeValue(ticker, "last_trade", map[string]interface{} {})
|
|
var timestamp interface{} = this.Parse8601(this.SafeString(lastTrade, "logicalTime"))
|
|
var bid interface{} = this.SafeString(ticker, "highest_bid")
|
|
var ask interface{} = this.SafeString(ticker, "lowest_ask")
|
|
var baseVolume interface{} = this.SafeString(ticker, "volume_base_24h")
|
|
var quoteVolume interface{} = this.SafeString(ticker, "volume_quote_24h")
|
|
var high interface{} = this.SafeString(ticker, "highest_price_24h")
|
|
var low interface{} = this.SafeString(ticker, "lowest_price_24h")
|
|
var close interface{} = this.SafeString(ticker, "last_price")
|
|
var changePcnt interface{} = this.SafeString(ticker, "price_change_percent_24h")
|
|
return this.SafeTicker(map[string]interface{} {
|
|
"symbol": GetValue(market, "symbol"),
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"open": nil,
|
|
"high": high,
|
|
"low": low,
|
|
"close": close,
|
|
"bid": bid,
|
|
"bidVolume": nil,
|
|
"ask": ask,
|
|
"askVolume": nil,
|
|
"vwap": nil,
|
|
"previousClose": nil,
|
|
"change": nil,
|
|
"percentage": changePcnt,
|
|
"average": nil,
|
|
"baseVolume": baseVolume,
|
|
"quoteVolume": quoteVolume,
|
|
"info": ticker,
|
|
}, market)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchOrderBook
|
|
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-order-book-level-2
|
|
* @param {string} symbol unified symbol of the market to fetch the order book for
|
|
* @param {int} [limit] the maximum amount of order book entries to return (default 100, max 200)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
|
|
*/
|
|
func (this *coinlist) FetchOrderBook(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
limit := GetArg(optionalArgs, 0, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes7198 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes7198)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
|
|
response:= (<-this.PublicGetV1SymbolsSymbolBook(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "bids": [
|
|
// [ "30900.00000000", "0.0001" ],
|
|
// [ "30664.21000000", "0.0172" ],
|
|
// [ "30664.20000000", "0.0906" ],
|
|
// ],
|
|
// "asks": [
|
|
// [ "31349.99000000", "0.0003" ],
|
|
// [ "31350.00000000", "0.0023" ],
|
|
// [ "31359.33000000", "0.0583" ],
|
|
// ],
|
|
// "after_auction_code": "BTC-USDT-2023-10-23T18:40:51.000Z",
|
|
// "call_time": "2023-10-23T18:40:51.068Z",
|
|
// "logical_time": "2023-10-23T18:40:51.000Z"
|
|
// }
|
|
//
|
|
var logical_time interface{} = this.Parse8601(this.SafeString(response, "logical_time"))
|
|
var orderbook interface{} = this.ParseOrderBook(response, symbol, logical_time)
|
|
AddElementToObject(orderbook, "nonce", nil)
|
|
|
|
ch <- orderbook
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchOHLCV
|
|
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-candles
|
|
* @param {string} symbol unified symbol of the market to fetch OHLCV data for
|
|
* @param {string} timeframe the length of time each candle represents
|
|
* @param {int} [since] timestamp in ms of the earliest candle to fetch
|
|
* @param {int} [limit] the maximum amount of candles to fetch
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
|
|
*/
|
|
func (this *coinlist) FetchOHLCV(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
timeframe := GetArg(optionalArgs, 0, "1m")
|
|
_ = timeframe
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes7628 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes7628)
|
|
var market interface{} = this.Market(symbol)
|
|
var granularity interface{} = this.SafeString(this.Timeframes, timeframe)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
"granularity": granularity,
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "start_time", this.Iso8601(since))
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
var duration interface{} = Multiply(this.ParseTimeframe(timeframe), 1000)
|
|
AddElementToObject(request, "end_time", this.Iso8601(this.Sum(since, Multiply(duration, (limit)))))
|
|
} else {
|
|
AddElementToObject(request, "end_time", this.Iso8601(this.Milliseconds()))
|
|
}
|
|
}
|
|
var until interface{} = this.SafeInteger(params, "until")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "end_time", this.Iso8601(until))
|
|
}
|
|
|
|
response:= (<-this.PublicGetV1SymbolsSymbolCandles(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "candles": [
|
|
// [
|
|
// "2023-10-17T15:00:00.000Z",
|
|
// "28522.96000000",
|
|
// "28522.96000000",
|
|
// "28522.96000000",
|
|
// "28522.96000000",
|
|
// "0.1881",
|
|
// null
|
|
// ],
|
|
// [
|
|
// "2023-10-17T15:30:00.000Z",
|
|
// "28582.64000000",
|
|
// "28582.64000000",
|
|
// "28582.64000000",
|
|
// "28582.64000000",
|
|
// "0.0050",
|
|
// null
|
|
// ]
|
|
// ]
|
|
// }
|
|
//
|
|
var candles interface{} = this.SafeList(response, "candles", []interface{}{})
|
|
|
|
ch <- this.ParseOHLCVs(candles, market, timeframe, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// [
|
|
// "2023-10-17T15:30:00.000Z",
|
|
// "28582.64000000",
|
|
// "28582.64000000",
|
|
// "28582.64000000",
|
|
// "28582.64000000",
|
|
// "0.0050",
|
|
// null
|
|
// ]
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
return []interface{}{this.Parse8601(this.SafeString(ohlcv, 0)), this.SafeNumber(ohlcv, 1), this.SafeNumber(ohlcv, 2), this.SafeNumber(ohlcv, 3), this.SafeNumber(ohlcv, 4), this.SafeNumber(ohlcv, 5)}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchTrades
|
|
* @description get the list of most recent trades for a particular symbol
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-auctions
|
|
* @param {string} symbol unified symbol of the market to fetch trades for
|
|
* @param {int} [since] timestamp in ms of the earliest trade to fetch
|
|
* @param {int} [limit] the maximum amount of trades to fetch (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
|
|
*/
|
|
func (this *coinlist) FetchTrades(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
since := GetArg(optionalArgs, 0, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 1, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes8478 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes8478)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "start_time", this.Iso8601(since))
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "count", mathMin(limit, 500))
|
|
}
|
|
var until interface{} = this.SafeInteger(params, "until")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "end_time", this.Iso8601(until))
|
|
}
|
|
|
|
response:= (<-this.PublicGetV1SymbolsSymbolAuctions(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "auctions": [
|
|
// {
|
|
// "symbol":"BTC-USDT",
|
|
// "auction_code":"BTC-USDT-2023-10-01T08:05:56.000Z",
|
|
// "price":"27241.53000000",
|
|
// "volume":"0.0052",
|
|
// "imbalance":"-1.0983",
|
|
// "logical_time":"2023-10-01T08:05:56.000Z",
|
|
// "call_time":"2023-10-01T08:05:56.068Z"
|
|
// },
|
|
// {
|
|
// "symbol":"BTC-USDT",
|
|
// "auction_code":"BTC-USDT-2023-10-01T08:09:09.000Z",
|
|
// "price":"27236.83000000",
|
|
// "volume":"0.0283",
|
|
// "imbalance":"-1.0754",
|
|
// "logical_time":"2023-10-01T08:09:09.000Z",
|
|
// "call_time":"2023-10-01T08:09:09.078Z"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var auctions interface{} = this.SafeList(response, "auctions", []interface{}{})
|
|
|
|
ch <- this.ParseTrades(auctions, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// fetchTrades
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "auction_code": "BTC-USDT-2023-10-01T08:05:56.000Z",
|
|
// "price": "27241.53000000",
|
|
// "volume": "0.0052",
|
|
// "imbalance": "-1.0983",
|
|
// "logical_time": "2023-10-01T08:05:56.000Z",
|
|
// "call_time": "2023-10-01T08:05:56.068Z"
|
|
// }
|
|
//
|
|
// fetchMyTrades
|
|
// {
|
|
// "symbol": "ETH-USDT",
|
|
// "auction_code": "ETH-USDT-2023-10-20T13:22:14.000Z",
|
|
// "order_id": "83ed365f-497d-433b-96c1-9d08c1a12842",
|
|
// "quantity": "0.0008",
|
|
// "price": "1615.24000000",
|
|
// "fee": "0.005815",
|
|
// "fee_type": "taker",
|
|
// "fee_currency": "USDT",
|
|
// "logical_time": "2023-10-20T13:22:14.000Z"
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var marketId interface{} = this.SafeString(trade, "symbol")
|
|
market = this.SafeMarket(marketId, market)
|
|
var symbol interface{} = GetValue(market, "symbol")
|
|
var id interface{} = this.SafeString(trade, "auction_code")
|
|
var timestamp interface{} = this.Parse8601(this.SafeString(trade, "logical_time"))
|
|
var priceString interface{} = this.SafeString(trade, "price")
|
|
var amountString interface{} = this.SafeString2(trade, "volume", "quantity")
|
|
var order interface{} = this.SafeString(trade, "order_id")
|
|
var fee interface{} = nil
|
|
var side interface{} = nil
|
|
var feeCost interface{} = this.SafeString(trade, "fee")
|
|
if IsTrue(!IsEqual(feeCost, nil)) {
|
|
// only in fetchMyTrades
|
|
var amountIsNegative interface{} = Precise.StringLt(amountString, "0")
|
|
if IsTrue(amountIsNegative) {
|
|
side = "sell"
|
|
amountString = Precise.StringNeg(amountString)
|
|
} else {
|
|
side = "buy"
|
|
}
|
|
fee = map[string]interface{} {
|
|
"cost": feeCost,
|
|
"currency": this.SafeString(trade, "fee_currency"),
|
|
}
|
|
} else {
|
|
var imbalance interface{} = this.SafeString(trade, "imbalance")
|
|
if IsTrue(Precise.StringLt(imbalance, "0")) {
|
|
side = "buy"
|
|
} else {
|
|
side = "sell"
|
|
}
|
|
}
|
|
var takerOrMaker interface{} = this.SafeString(trade, "fee_type")
|
|
return this.SafeTrade(map[string]interface{} {
|
|
"id": id,
|
|
"order": order,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"symbol": symbol,
|
|
"type": nil,
|
|
"side": side,
|
|
"takerOrMaker": takerOrMaker,
|
|
"price": priceString,
|
|
"amount": amountString,
|
|
"cost": nil,
|
|
"fee": fee,
|
|
"info": trade,
|
|
}, market)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchTradingFees
|
|
* @description fetch the trading fees for multiple markets
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-fees
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a dictionary of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure} indexed by market symbols
|
|
*/
|
|
func (this *coinlist) FetchTradingFees(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes9778 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes9778)
|
|
|
|
response:= (<-this.PrivateGetV1Fees(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// fees_by_symbols: {
|
|
// 'BTC-USD,BTC-USDT,ETH-USD,ETH-USDT,ETH-BTC,AAVE-USD,AAVE-USDT,ALGO-USD,ALGO-USDT,AVAX-USD,AVAX-USDT,BICO-USD,BICO-USDT,BLD-USD,BLD-USDT,BTRST-USDT,BZZ-USDT,CELO-USD,CELO-BTC,CFG-USD,CFG-USDT,CLV-USDT,COMP-USD,COMP-USDT,CYBER-USDT,CQT-USDT,CSPR-USD,CSPR-USDT,CUSD-USD,CUSD-USDC,DOGE-USD,DOGE-USDT,DOT-USD,DOT-USDT,EFI-USDT,FIL-USD,FIL-USDT,FLOW-USD,FLOW-USDT,GAL-USD,GAL-USDT,GODS-USDT,GOG-USDT,HMT-USD,HMT-USDT,ICP-USD,ICP-USDT,IMX-USD,IMX-USDT,LINK-USD,LINK-USDT,MATIC-USD,MATIC-USDT,MINA-USD,MINA-USDT,MKR-USD,MKR-USDT,NEON-USDT,NYM-USD,NYM-USDT,OCEAN-USD,OXT-USD,ROSE-USD,ROSE-USDT,SKL-USD,SKL-USDT,SOL-USD,SOL-USDT,STX-USDT,SUI-USDT,T-USDT,UNI-USD,UNI-USDT,USDT-USD,VEGA-USDT,WAXL-USD,WAXL-USDT,WBTC-BTC,WCFG-USD,WCFG-USDT,XTZ-USD': {
|
|
// base: {
|
|
// fees: { maker: '0', taker: '0.0045', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_1: {
|
|
// fees: { maker: '0', taker: '0.003', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_2: {
|
|
// fees: { maker: '0', taker: '0.0025', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_3: {
|
|
// fees: { maker: '0', taker: '0.002', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_4: {
|
|
// fees: { maker: '0', taker: '0.0018', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_5: {
|
|
// fees: { maker: '0', taker: '0.0018', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_6: {
|
|
// fees: { maker: '0', taker: '0.0016', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_7: {
|
|
// fees: { maker: '0', taker: '0.0013', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_8: {
|
|
// fees: { maker: '0', taker: '0.0012', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_9: {
|
|
// fees: { maker: '0', taker: '0.001', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// }
|
|
// volume_tier_10: {
|
|
// fees: { maker: '0', taker: '0.0005', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_11: {
|
|
// fees: { maker: '0', taker: '0.0005', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
var fees interface{} = this.SafeValue(response, "fees_by_symbols", map[string]interface{} {})
|
|
var result interface{} = map[string]interface{} {}
|
|
var groupsOfSymbols interface{} = ObjectKeys(fees)
|
|
for i := 0; IsLessThan(i, GetArrayLength(groupsOfSymbols)); i++ {
|
|
var group interface{} = GetValue(groupsOfSymbols, i)
|
|
var feeTiers interface{} = this.SafeValue(fees, group, map[string]interface{} {})
|
|
var tiers interface{} = this.ParseFeeTiers(feeTiers)
|
|
var firstTier interface{} = this.SafeValue(feeTiers, "base", map[string]interface{} {})
|
|
var firstTierFees interface{} = this.SafeValue(firstTier, "fees", map[string]interface{} {})
|
|
var ids interface{} = Split(group, ",")
|
|
for j := 0; IsLessThan(j, GetArrayLength(ids)); j++ {
|
|
var id interface{} = GetValue(ids, j)
|
|
var market interface{} = this.SafeMarket(id)
|
|
var symbol interface{} = GetValue(market, "symbol")
|
|
var info interface{} = map[string]interface{} {}
|
|
AddElementToObject(info, group, feeTiers)
|
|
AddElementToObject(result, symbol, map[string]interface{} {
|
|
"info": info,
|
|
"symbol": symbol,
|
|
"maker": this.SafeNumber(firstTierFees, "maker"),
|
|
"taker": this.SafeNumber(firstTierFees, "taker"),
|
|
"percentage": true,
|
|
"tierBased": true,
|
|
"tiers": tiers,
|
|
})
|
|
}
|
|
}
|
|
|
|
ch <- result
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseFeeTiers(feeTiers interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// base: {
|
|
// fees: { maker: '0', taker: '0.0045', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_1: {
|
|
// fees: { maker: '0', taker: '0.003', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_2: {
|
|
// fees: { maker: '0', taker: '0.0025', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_3: {
|
|
// fees: { maker: '0', taker: '0.002', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_4: {
|
|
// fees: { maker: '0', taker: '0.0018', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_5: {
|
|
// fees: { maker: '0', taker: '0.0018', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_6: {
|
|
// fees: { maker: '0', taker: '0.0016', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_7: {
|
|
// fees: { maker: '0', taker: '0.0013', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_8: {
|
|
// fees: { maker: '0', taker: '0.0012', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_9: {
|
|
// fees: { maker: '0', taker: '0.001', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// }
|
|
// volume_tier_10: {
|
|
// fees: { maker: '0', taker: '0.0005', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
// volume_tier_11: {
|
|
// fees: { maker: '0', taker: '0.0005', liquidation: '0' },
|
|
// floors: { maker: null, taker: null }
|
|
// },
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var takerFees interface{} = []interface{}{}
|
|
var makerFees interface{} = []interface{}{}
|
|
var keys interface{} = ObjectKeys(feeTiers)
|
|
var keysLength interface{} = GetArrayLength(keys)
|
|
if IsTrue(IsGreaterThan(keysLength, 0)) {
|
|
for i := 0; IsLessThan(i, keysLength); i++ {
|
|
var key interface{} = GetValue(keys, i)
|
|
var tier interface{} = this.SafeValue(feeTiers, key, map[string]interface{} {})
|
|
var tierFees interface{} = this.SafeValue(tier, "fees", map[string]interface{} {})
|
|
var taker interface{} = this.SafeString(tierFees, "taker")
|
|
var maker interface{} = this.SafeString(tierFees, "maker")
|
|
AppendToArray(&makerFees,[]interface{}{nil, this.ParseNumber(maker)})
|
|
AppendToArray(&takerFees,[]interface{}{nil, this.ParseNumber(taker)})
|
|
}
|
|
takerFees = this.SortBy(takerFees, 1, true)
|
|
makerFees = this.SortBy(makerFees, 1, true)
|
|
var firstTier interface{} = this.SafeDict(takerFees, 0, []interface{}{})
|
|
var exchangeFees interface{} = this.SafeDict(this, "fees", map[string]interface{} {})
|
|
var exchangeFeesTrading interface{} = this.SafeDict(exchangeFees, "trading", map[string]interface{} {})
|
|
var exchangeFeesTradingTiers interface{} = this.SafeDict(exchangeFeesTrading, "tiers", map[string]interface{} {})
|
|
var exchangeFeesTradingTiersTaker interface{} = this.SafeList(exchangeFeesTradingTiers, "taker", []interface{}{})
|
|
var exchangeFeesTradingTiersMaker interface{} = this.SafeList(exchangeFeesTradingTiers, "maker", []interface{}{})
|
|
var exchangeFeesTradingTiersTakerLength interface{} = GetArrayLength(exchangeFeesTradingTiersTaker)
|
|
var firstTierLength interface{} = GetArrayLength(firstTier)
|
|
if IsTrue(IsTrue((IsEqual(keysLength, exchangeFeesTradingTiersTakerLength))) && IsTrue((IsGreaterThan(firstTierLength, 0)))) {
|
|
for i := 0; IsLessThan(i, keysLength); i++ {
|
|
AddElementToObject(GetValue(takerFees, i), 0, GetValue(GetValue(exchangeFeesTradingTiersTaker, i), 0))
|
|
AddElementToObject(GetValue(makerFees, i), 0, GetValue(GetValue(exchangeFeesTradingTiersMaker, i), 0))
|
|
}
|
|
}
|
|
}
|
|
return map[string]interface{} {
|
|
"maker": makerFees,
|
|
"taker": takerFees,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchAccounts
|
|
* @description fetch all the accounts associated with a profile
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-accounts
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a dictionary of [account structures]{@link https://docs.ccxt.com/#/?id=account-structure} indexed by the account type
|
|
*/
|
|
func (this *coinlist) FetchAccounts(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes11628 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes11628)
|
|
|
|
response:= (<-this.PrivateGetV1Accounts(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "accounts": [
|
|
// {
|
|
// "trader_id": "b18507ce-7d55-4bf1-b12a-0ccca5b90936",
|
|
// "name": "string"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var accounts interface{} = this.SafeValue(response, "accounts", []interface{}{})
|
|
|
|
ch <- this.ParseAccounts(accounts, params)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseAccount(account interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "trader_id": "b18507ce-7d55-4bf1-b12a-0ccca5b90936",
|
|
// "name": "string"
|
|
// }
|
|
//
|
|
return map[string]interface{} {
|
|
"id": this.SafeString(account, "trader_id"),
|
|
"type": "trading",
|
|
"code": nil,
|
|
"info": account,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchBalance
|
|
* @description query for balance and get the amount of funds available for trading or funds locked in orders
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-balances
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
|
|
*/
|
|
func (this *coinlist) FetchBalance(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes12028 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes12028)
|
|
|
|
response:= (<-this.PrivateGetV1Balances(params))
|
|
PanicOnError(response)
|
|
|
|
ch <- this.ParseBalance(response)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseBalance(response interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "asset_balances": {
|
|
// "BTC": "0.00308696",
|
|
// "ETH": "20.000000000000000000"
|
|
// },
|
|
// "asset_holds": {
|
|
// "BTC": "0.00000000",
|
|
// "ETH": "1.000000000000000000"
|
|
// },
|
|
// "net_liquidation_value_usd": "string"
|
|
// }
|
|
//
|
|
var result interface{} = map[string]interface{} {
|
|
"info": response,
|
|
"timestamp": nil,
|
|
"datetime": nil,
|
|
}
|
|
var totalBalances interface{} = this.SafeValue(response, "asset_balances", map[string]interface{} {})
|
|
var usedBalances interface{} = this.SafeValue(response, "asset_holds", map[string]interface{} {})
|
|
var currencyIds interface{} = ObjectKeys(totalBalances)
|
|
for i := 0; IsLessThan(i, GetArrayLength(currencyIds)); i++ {
|
|
var currencyId interface{} = GetValue(currencyIds, i)
|
|
var code interface{} = this.SafeCurrencyCode(currencyId)
|
|
var account interface{} = this.Account()
|
|
AddElementToObject(account, "total", this.SafeString(totalBalances, currencyId))
|
|
AddElementToObject(account, "used", this.SafeString(usedBalances, currencyId, "0"))
|
|
AddElementToObject(result, code, account)
|
|
}
|
|
return this.SafeBalance(result)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchMyTrades
|
|
* @description fetch all trades made by the user
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-fills
|
|
* @param {string} symbol unified market symbol
|
|
* @param {int} [since] the earliest time in ms to fetch trades for
|
|
* @param {int} [limit] the maximum number of trades structures to retrieve (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
|
|
*/
|
|
func (this *coinlist) FetchMyTrades(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes12538 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes12538)
|
|
var request interface{} = map[string]interface{} {}
|
|
var market interface{} = nil
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
market = this.Market(symbol)
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "start_time", this.Iso8601(since))
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "count", limit)
|
|
}
|
|
var until interface{} = this.SafeInteger(params, "until")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "end_time", this.Iso8601(until))
|
|
}
|
|
|
|
response:= (<-this.PrivateGetV1Fills(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "fills": [
|
|
// {
|
|
// "symbol": "ETH-USDT",
|
|
// "auction_code": "ETH-USDT-2023-10-20T13:16:30.000Z",
|
|
// "order_id": "39911d5f-c789-4a7d-ad34-820a804d1da6",
|
|
// "quantity": "-0.0009",
|
|
// "price": "1608.83000000",
|
|
// "fee": "0.006516",
|
|
// "fee_type": "taker",
|
|
// "fee_currency": "USDT",
|
|
// "logical_time": "2023-10-20T13:16:30.000Z"
|
|
// },
|
|
// {
|
|
// "symbol": "ETH-USDT",
|
|
// "auction_code": "ETH-USDT-2023-10-20T13:22:14.000Z",
|
|
// "order_id": "83ed365f-497d-433b-96c1-9d08c1a12842",
|
|
// "quantity": "0.0008",
|
|
// "price": "1615.24000000",
|
|
// "fee": "0.005815",
|
|
// "fee_type": "taker",
|
|
// "fee_currency": "USDT",
|
|
// "logical_time": "2023-10-20T13:22:14.000Z"
|
|
// },
|
|
// ]
|
|
// }
|
|
//
|
|
var fills interface{} = this.SafeList(response, "fills", []interface{}{})
|
|
|
|
ch <- this.ParseTrades(fills, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchOrderTrades
|
|
* @description fetch all the trades made from a single order
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-fills
|
|
* @param {string} id order id
|
|
* @param {string} symbol unified market symbol
|
|
* @param {int} [since] the earliest time in ms to fetch trades for
|
|
* @param {int} [limit] the maximum number of trades to retrieve
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
|
|
*/
|
|
func (this *coinlist) FetchOrderTrades(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
var request interface{} = map[string]interface{} {
|
|
"order_id": id,
|
|
}
|
|
|
|
retRes132015 := (<-this.FetchMyTrades(symbol, since, limit, this.Extend(request, params)))
|
|
PanicOnError(retRes132015)
|
|
ch <- retRes132015
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchOrders
|
|
* @description fetches information on multiple orders made by the user
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-orders
|
|
* @param {string} symbol unified market symbol of the market orders were made in
|
|
* @param {int} [since] the earliest time in ms to fetch orders for
|
|
* @param {int} [limit] the maximum number of order structures to retrieve (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @param {string|string[]} [params.status] the status of the order - 'accepted', 'done', 'canceled', 'rejected', 'pending' (default [ 'accepted', 'done', 'canceled', 'rejected', 'pending' ])
|
|
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) FetchOrders(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes13378 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes13378)
|
|
var status interface{} = this.SafeString(params, "status")
|
|
if IsTrue(IsEqual(status, nil)) {
|
|
status = []interface{}{"accepted", "done", "canceled", "rejected", "pending"}
|
|
}
|
|
var request interface{} = map[string]interface{} {
|
|
"status": status,
|
|
}
|
|
var market interface{} = nil
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
market = this.Market(symbol)
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "start_time", this.Iso8601(since))
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "count", limit)
|
|
}
|
|
var until interface{} = this.SafeInteger(params, "until")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "end_time", this.Iso8601(until))
|
|
}
|
|
|
|
response:= (<-this.PrivateGetV1Orders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "orders":[
|
|
// {
|
|
// "order_id":"913ea6e7-9fc9-43fb-9db1-f195d3baa93f",
|
|
// "price":"35800.00000000",
|
|
// "stop_price":null,
|
|
// "cost":"0.00000000",
|
|
// "fill_fees":"0.00000000",
|
|
// "trader_id":"9c6f737e-a829-4843-87b1-b1ce86f2853b",
|
|
// "status":"accepted",
|
|
// "epoch_timestamp":"2023-10-26T08:20:56.307Z",
|
|
// "origin":"web",
|
|
// "self_trade_prevention":null,
|
|
// "client_id":null,
|
|
// "created_at":"2023-10-26T08:20:56.307Z",
|
|
// "symbol":"BTC-USDT",
|
|
// "size":"0.0003",
|
|
// "side":"sell",
|
|
// "type":"limit",
|
|
// "post_only":false,
|
|
// "size_filled":"0.0000"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var orders interface{} = this.SafeList(response, "orders", []interface{}{})
|
|
|
|
ch <- this.ParseOrders(orders, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchOrder
|
|
* @description fetches information on an order made by the user
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-specific-order-by-id
|
|
* @param {int|string} id order id
|
|
* @param {string} symbol not used by coinlist fetchOrder ()
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) FetchOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes14038 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes14038)
|
|
var request interface{} = map[string]interface{} {
|
|
"order_id": id,
|
|
}
|
|
|
|
response:= (<-this.PrivateGetV1OrdersOrderId(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// {
|
|
// "order_id": "93101167-9065-4b9c-b98b-5d789a3ed9fe",
|
|
// "client_id": "string",
|
|
// "symbol": "string",
|
|
// "type": "market",
|
|
// "side": "buy",
|
|
// "size": "string",
|
|
// "price": "string",
|
|
// "stop_price": "string",
|
|
// "stop_trigger": "last",
|
|
// "self_trade_prevention": "keep-newest",
|
|
// "average_fill_price": "string",
|
|
// "fill_fees": "string",
|
|
// "size_filled": "string",
|
|
// "created_at": "2019-08-24T14:15:22Z",
|
|
// "epoch_timestamp": "2019-08-24T14:15:22Z",
|
|
// "post_only": true,
|
|
// "peg_price_type": "trailing-stop",
|
|
// "peg_offset_value": "string",
|
|
// "origin": "web",
|
|
// "status": "pending"
|
|
// }
|
|
//
|
|
ch <- this.ParseOrder(response)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchOpenOrders
|
|
* @description fetch all unfilled currently open orders
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-orders
|
|
* @param {string} symbol unified market symbol
|
|
* @param {int} [since] the earliest time in ms to fetch open orders for
|
|
* @param {int} [limit] the maximum number of open order structures to retrieve (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) FetchOpenOrders(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes14488 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes14488)
|
|
var request interface{} = map[string]interface{} {
|
|
"status": "accepted",
|
|
}
|
|
|
|
ch <- this.FetchOrders(symbol, since, limit, this.Extend(request, params))
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchClosedOrders
|
|
* @description fetches information on multiple closed orders made by the user
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-orders
|
|
* @param {string} symbol unified market symbol of the market orders were made in
|
|
* @param {int} [since] the earliest time in ms to fetch orders for
|
|
* @param {int} [limit] the maximum number of closed order structures to retrieve (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) FetchClosedOrders(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes14688 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes14688)
|
|
var request interface{} = map[string]interface{} {
|
|
"status": "done",
|
|
}
|
|
|
|
ch <- this.FetchOrders(symbol, since, limit, this.Extend(request, params))
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchCanceledOrders
|
|
* @description fetches information on multiple canceled orders made by the user
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-orders
|
|
* @param {string} symbol unified market symbol of the market orders were made in
|
|
* @param {int} [since] the earliest time in ms to fetch orders for
|
|
* @param {int} [limit] the maximum number of canceled order structures to retrieve (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {object} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) FetchCanceledOrders(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes14888 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes14888)
|
|
var request interface{} = map[string]interface{} {
|
|
"status": "canceled",
|
|
}
|
|
|
|
ch <- this.FetchOrders(symbol, since, limit, this.Extend(request, params))
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#cancelAllOrders
|
|
* @description cancel open orders of market
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#cancel-all-orders
|
|
* @param {string} symbol unified market symbol
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) CancelAllOrders(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes15058 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes15058)
|
|
var market interface{} = nil
|
|
var request interface{} = map[string]interface{} {}
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
market = this.Market(symbol)
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
}
|
|
|
|
response:= (<-this.PrivateDeleteV1Orders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "message": "Order cancellation request received.",
|
|
// "timestamp": "2023-10-26T10:29:28.652Z"
|
|
// }
|
|
//
|
|
var orders interface{} = []interface{}{response}
|
|
|
|
ch <- this.ParseOrders(orders, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#cancelOrder
|
|
* @description cancels an open order
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#cancel-specific-order-by-id
|
|
* @param {string} id order id
|
|
* @param {string} symbol not used by coinlist cancelOrder ()
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) CancelOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes15348 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes15348)
|
|
var request interface{} = map[string]interface{} {
|
|
"order_id": id,
|
|
}
|
|
|
|
response:= (<-this.PrivateDeleteV1OrdersOrderId(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// {
|
|
// "message": "Cancel order request received.",
|
|
// "order_id": "d36e7588-6525-485c-b768-8ad8b3f745f9",
|
|
// "timestamp": "2023-10-26T14:36:37.559Z"
|
|
// }
|
|
//
|
|
ch <- this.ParseOrder(response)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#cancelOrders
|
|
* @description cancel multiple orders
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#cancel-specific-orders
|
|
* @param {string[]} ids order ids
|
|
* @param {string} symbol not used by coinlist cancelOrders ()
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) CancelOrders(ids interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes15608 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes15608)
|
|
params = ids
|
|
|
|
response:= (<-this.PrivateDeleteV1OrdersBulk(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "message": "Cancel order requests received.",
|
|
// "order_ids": [
|
|
// "ff132955-43bc-4fe5-9d9c-5ba226cc89a0"
|
|
// ],
|
|
// "timestamp": "2024-06-01T02:32:30.305Z"
|
|
// }
|
|
//
|
|
var orderIds interface{} = this.SafeList(response, "order_ids", []interface{}{})
|
|
var orders interface{} = []interface{}{}
|
|
var datetime interface{} = this.SafeString(response, "timestamp")
|
|
for i := 0; IsLessThan(i, GetArrayLength(orderIds)); i++ {
|
|
AppendToArray(&orders,this.SafeOrder(map[string]interface{} {
|
|
"info": GetValue(orderIds, i),
|
|
"id": GetValue(orderIds, i),
|
|
"lastUpdateTimestamp": this.Parse8601(datetime),
|
|
}))
|
|
}
|
|
|
|
ch <- orders
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#createOrder
|
|
* @description create a trade order
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#create-new-order
|
|
* @param {string} symbol unified symbol of the market to create an order in
|
|
* @param {string} type 'market' or 'limit' or 'stop_market' or 'stop_limit' or 'take_market' or 'take_limit'
|
|
* @param {string} side 'buy' or 'sell'
|
|
* @param {float} amount how much of currency you want to trade in units of base currency
|
|
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {bool} [params.postOnly] if true, the order will only be posted to the order book and not executed immediately (default false)
|
|
* @param {float} [params.triggerPrice] only for the 'stop_market', 'stop_limit', 'take_market' or 'take_limit' orders (the price at which an order is triggered)
|
|
* @param {string} [params.clientOrderId] client order id (default undefined)
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) CreateOrder(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
price := GetArg(optionalArgs, 0, nil)
|
|
_ = price
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes16028 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes16028)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
"type": typeVar,
|
|
"side": side,
|
|
"size": this.AmountToPrecision(symbol, amount),
|
|
}
|
|
var isMarket interface{} = false
|
|
if IsTrue(IsTrue(IsTrue((IsEqual(typeVar, "limit"))) || IsTrue((IsEqual(typeVar, "stop_limit")))) || IsTrue((IsEqual(typeVar, "take_limit")))) {
|
|
if IsTrue(IsEqual(price, nil)) {
|
|
panic(ArgumentsRequired(Add(Add(Add(this.Id, " createOrder() requires a price argument for a "), typeVar), " order")))
|
|
}
|
|
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
|
|
} else {
|
|
isMarket = true
|
|
}
|
|
var postOnly interface{} = nil
|
|
postOnlyparamsVariable := this.HandlePostOnly(isMarket, false, params);
|
|
postOnly = GetValue(postOnlyparamsVariable,0);
|
|
params = GetValue(postOnlyparamsVariable,1)
|
|
if IsTrue(postOnly) {
|
|
AddElementToObject(request, "post_only", true)
|
|
}
|
|
var triggerPrice interface{} = this.SafeNumberN(params, []interface{}{"triggerPrice", "trigger_price", "stopPrice", "stop_price"})
|
|
if IsTrue(!IsEqual(triggerPrice, nil)) {
|
|
params = this.Omit(params, []interface{}{"triggerPrice", "trigger_price", "stopPrice"})
|
|
AddElementToObject(request, "stop_price", this.PriceToPrecision(symbol, triggerPrice))
|
|
if IsTrue(IsEqual(typeVar, "market")) {
|
|
AddElementToObject(request, "type", "stop_market")
|
|
} else if IsTrue(IsEqual(typeVar, "limit")) {
|
|
AddElementToObject(request, "type", "stop_limit")
|
|
}
|
|
} else if IsTrue(IsTrue(IsTrue(IsTrue((IsEqual(typeVar, "stop_market"))) || IsTrue((IsEqual(typeVar, "stop_limit")))) || IsTrue((IsEqual(typeVar, "take_market")))) || IsTrue((IsEqual(typeVar, "take_limit")))) {
|
|
panic(ArgumentsRequired(Add(this.Id, " createOrder() requires a triggerPrice parameter for stop-loss and take-profit orders")))
|
|
}
|
|
var clientOrderId interface{} = this.SafeString2(params, "clientOrderId", "client_id")
|
|
if IsTrue(!IsEqual(clientOrderId, nil)) {
|
|
AddElementToObject(request, "client_id", clientOrderId)
|
|
params = this.Omit(params, []interface{}{"clientOrderId", "client_id"})
|
|
}
|
|
|
|
response:= (<-this.PrivatePostV1Orders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "message": "New order request received.",
|
|
// "order": {
|
|
// "symbol": "BTC-USDT",
|
|
// "type": "market",
|
|
// "side": "sell",
|
|
// "size": "0.0003",
|
|
// "order_id": "cad67c0f-9aec-4ac8-ac03-aaf5db299ff7",
|
|
// "trader_id": "9c6f737e-a829-4843-87b1-b1ce86f2853b"
|
|
// },
|
|
// "timestamp": "2023-10-26T11:30:55.376Z"
|
|
// }
|
|
//
|
|
var order interface{} = this.SafeDict(response, "order", map[string]interface{} {})
|
|
|
|
ch <- this.ParseOrder(order, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#editOrder
|
|
* @description create a trade order
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#modify-existing-order
|
|
* @param {string} id order id
|
|
* @param {string} symbol unified symbol of the market to create an order in
|
|
* @param {string} type 'market' or 'limit' or 'stop_market' or 'stop_limit' or 'take_market' or 'take_limit'
|
|
* @param {string} side 'buy' or 'sell'
|
|
* @param {float} amount how much of currency you want to trade in units of base currency
|
|
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *coinlist) EditOrder(id interface{}, symbol interface{}, typeVar interface{}, side interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
amount := GetArg(optionalArgs, 0, nil)
|
|
_ = amount
|
|
price := GetArg(optionalArgs, 1, nil)
|
|
_ = price
|
|
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes16758 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes16758)
|
|
if IsTrue(IsEqual(amount, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " editOrder() requires an amount argument")))
|
|
}
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"order_id": id,
|
|
"type": typeVar,
|
|
"side": side,
|
|
"size": this.AmountToPrecision(symbol, amount),
|
|
}
|
|
if IsTrue(!IsEqual(price, nil)) {
|
|
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
|
|
}
|
|
|
|
response:= (<-this.PrivatePatchV1OrdersOrderId(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
ch <- this.ParseOrder(response, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// fetchOrder
|
|
// {
|
|
// "order_id": "913ea6e7-9fc9-43fb-9db1-f195d3baa93f",
|
|
// "price": "35800.00000000",
|
|
// "stop_price":null,
|
|
// "cost": "0.00000000",
|
|
// "fill_fees": "0.00000000",
|
|
// "trader_id": "9c6f737e-a829-4843-87b1-b1ce86f2853b",
|
|
// "status": "canceled",
|
|
// "epoch_timestamp": "2023-10-26T08:20:56.307Z",
|
|
// "origin": "web",
|
|
// "self_trade_prevention":null,
|
|
// "client_id":null,
|
|
// "symbol": "BTC-USDT",
|
|
// "size": "0.0003",
|
|
// "side": "sell",
|
|
// "type": "limit",
|
|
// "post_only":false,
|
|
// "size_filled": "0.0000"
|
|
// }
|
|
//
|
|
// fetchOrders
|
|
// {
|
|
// "order_id":"913ea6e7-9fc9-43fb-9db1-f195d3baa93f",
|
|
// "price":"35800.00000000",
|
|
// "stop_price":null,
|
|
// "cost":"0.00000000",
|
|
// "fill_fees":"0.00000000",
|
|
// "trader_id":"9c6f737e-a829-4843-87b1-b1ce86f2853b",
|
|
// "status":"accepted",
|
|
// "epoch_timestamp":"2023-10-26T08:20:56.307Z",
|
|
// "origin":"web",
|
|
// "self_trade_prevention":null,
|
|
// "client_id":null,
|
|
// "created_at":"2023-10-26T08:20:56.307Z",
|
|
// "symbol":"BTC-USDT",
|
|
// "size":"0.0003",
|
|
// "side":"sell",
|
|
// "type":"limit",
|
|
// "post_only":false,
|
|
// "size_filled":"0.0000"
|
|
// }
|
|
//
|
|
// createOrder
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "type": "market",
|
|
// "side": "sell",
|
|
// "size": "0.0003",
|
|
// "order_id": "cad67c0f-9aec-4ac8-ac03-aaf5db299ff7",
|
|
// "trader_id": "9c6f737e-a829-4843-87b1-b1ce86f2853b"
|
|
// },
|
|
//
|
|
// cancelOrder
|
|
// {
|
|
// "message": "Cancel order request received.",
|
|
// "order_id": "d36e7588-6525-485c-b768-8ad8b3f745f9",
|
|
// "timestamp": "2023-10-26T14:36:37.559Z"
|
|
// }
|
|
//
|
|
// cancelOrders
|
|
// {
|
|
// "message": "Order cancellation request received.",
|
|
// "timestamp": "2023-10-26T10:29:28.652Z"
|
|
// }
|
|
//
|
|
// cancelAllOrders
|
|
// {
|
|
// "message": "Order cancellation request received.",
|
|
// "timestamp": "2023-10-26T10:29:28.652Z"
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var id interface{} = this.SafeString(order, "order_id")
|
|
var marketId interface{} = this.SafeString(order, "symbol")
|
|
market = this.SafeMarket(marketId, market)
|
|
var clientOrderId interface{} = this.SafeString(order, "client_id")
|
|
var timestampString interface{} = this.SafeString2(order, "created_at", "epoch_timestamp")
|
|
if IsTrue(IsEqual(timestampString, nil)) {
|
|
timestampString = this.SafeString(order, "timestamp")
|
|
}
|
|
var timestamp interface{} = this.Parse8601(timestampString)
|
|
var status interface{} = this.ParseOrderStatus(this.SafeString(order, "status"))
|
|
var typeVar interface{} = this.ParseOrderType(this.SafeString(order, "type"))
|
|
var side interface{} = this.SafeString(order, "side")
|
|
var price interface{} = this.SafeString(order, "price")
|
|
var triggerPrice interface{} = this.SafeString(order, "stop_price")
|
|
var average interface{} = this.SafeString(order, "average_fill_price") // from documentation
|
|
var amount interface{} = this.SafeString(order, "size")
|
|
var filled interface{} = this.SafeString(order, "size_filled")
|
|
var feeCost interface{} = this.SafeString(order, "fill_fees")
|
|
var postOnly interface{} = this.SafeValue(order, "post_only")
|
|
var fee interface{} = nil
|
|
if IsTrue(!IsEqual(feeCost, nil)) {
|
|
fee = map[string]interface{} {
|
|
"currency": GetValue(market, "quote"),
|
|
"cost": feeCost,
|
|
"rate": nil,
|
|
}
|
|
}
|
|
return this.SafeOrder(map[string]interface{} {
|
|
"id": id,
|
|
"clientOrderId": clientOrderId,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"lastTradeTimestamp": nil,
|
|
"status": status,
|
|
"symbol": GetValue(market, "symbol"),
|
|
"type": typeVar,
|
|
"timeInForce": "GTC",
|
|
"side": side,
|
|
"price": price,
|
|
"triggerPrice": triggerPrice,
|
|
"average": average,
|
|
"amount": amount,
|
|
"cost": nil,
|
|
"filled": filled,
|
|
"remaining": nil,
|
|
"fee": fee,
|
|
"trades": nil,
|
|
"info": order,
|
|
"postOnly": postOnly,
|
|
}, market)
|
|
}
|
|
func (this *coinlist) ParseOrderStatus(status interface{}) interface{} {
|
|
var statuses interface{} = map[string]interface{} {
|
|
"pending": "open",
|
|
"accepted": "open",
|
|
"rejected": "rejected",
|
|
"done": "closed",
|
|
"canceled": "canceled",
|
|
}
|
|
return this.SafeString(statuses, status, status)
|
|
}
|
|
func (this *coinlist) ParseOrderType(status interface{}) interface{} {
|
|
var statuses interface{} = map[string]interface{} {
|
|
"market": "market",
|
|
"limit": "limit",
|
|
"stop_market": "market",
|
|
"stop_limit": "limit",
|
|
"take_market": "market",
|
|
"take_limit": "limit",
|
|
}
|
|
return this.SafeString(statuses, status, status)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#transfer
|
|
* @description transfer currency internally between wallets on the same account
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#transfer-funds-between-entities
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#transfer-funds-from-wallet-to-pro
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#transfer-funds-from-pro-to-wallet
|
|
* @param {string} code unified currency code
|
|
* @param {float} amount amount to transfer
|
|
* @param {string} fromAccount account to transfer from
|
|
* @param {string} toAccount account to transfer to
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
|
|
*/
|
|
func (this *coinlist) Transfer(code interface{}, amount interface{}, fromAccount interface{}, toAccount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes18578 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes18578)
|
|
var currency interface{} = this.Currency(code)
|
|
var request interface{} = map[string]interface{} {
|
|
"asset": GetValue(currency, "id"),
|
|
"amount": this.CurrencyToPrecision(code, amount),
|
|
}
|
|
var accountsByType interface{} = this.SafeValue(this.Options, "accountsByType", map[string]interface{} {})
|
|
var fromAcc interface{} = this.SafeString(accountsByType, fromAccount, fromAccount)
|
|
var toAcc interface{} = this.SafeString(accountsByType, toAccount, toAccount)
|
|
var response interface{} = nil
|
|
if IsTrue(IsTrue((IsEqual(fromAcc, "funding"))) && IsTrue((IsEqual(toAcc, "trading")))) {
|
|
|
|
response = (<-this.PrivatePostV1TransfersFromWallet(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else if IsTrue(IsTrue((IsEqual(fromAcc, "trading"))) && IsTrue((IsEqual(toAcc, "funding")))) {
|
|
|
|
response = (<-this.PrivatePostV1TransfersToWallet(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
AddElementToObject(request, "from_trader_id", fromAcc)
|
|
AddElementToObject(request, "to_trader_id", toAcc)
|
|
|
|
response = (<-this.PrivatePostV1TransfersInternalTransfer(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
//
|
|
// privatePostV1TransfersInternalTransfer
|
|
// {
|
|
// "from_trader_id": "1f494ace-b3ed-4324-b202-55526ed06381",
|
|
// "to_trader_id": "d32c7a40-cc24-44b0-8597-f9edb3da989f",
|
|
// "asset": "string",
|
|
// "amount": "string"
|
|
// }
|
|
//
|
|
// privatePostV1TransfersFromWallet, privatePostV1TransfersToWallet
|
|
// {
|
|
// "transfer_id": "bb34f528-d9b0-47c6-b11f-4d4840b86ee3"
|
|
// }
|
|
//
|
|
var transfer interface{} = this.ParseTransfer(response, currency)
|
|
|
|
ch <- transfer
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchTransfers
|
|
* @description fetch a history of internal transfers between CoinList.co and CoinList Pro. It does not return external deposits or withdrawals
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#list-transfers
|
|
* @param {string} code unified currency code
|
|
* @param {int} [since] the earliest time in ms to fetch transfers for
|
|
* @param {int} [limit] the maximum number of transfer structures to retrieve (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {object[]} a list of [transfer structures]{@link https://docs.ccxt.com/#/?id=transfer-structure}
|
|
*/
|
|
func (this *coinlist) FetchTransfers(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
code := GetArg(optionalArgs, 0, nil)
|
|
_ = code
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes19078 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes19078)
|
|
var currency interface{} = nil
|
|
if IsTrue(!IsEqual(code, nil)) {
|
|
currency = this.Currency(code)
|
|
}
|
|
var request interface{} = map[string]interface{} {}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "start_time", this.Iso8601(since))
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "count", limit)
|
|
}
|
|
var until interface{} = this.SafeInteger(params, "until")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "end_time", this.Iso8601(until))
|
|
}
|
|
|
|
response:= (<-this.PrivateGetV1Transfers(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "transfers": [
|
|
// {
|
|
// "transfer_id": "2c02db25-e8f2-4271-8222-e110bfd0aa2a",
|
|
// "created_at": "2023-10-20T13:15:37.000Z",
|
|
// "confirmed_at": "2023-10-20T13:15:37.000Z",
|
|
// "asset": "ETH",
|
|
// "amount": "0.010000000000000000",
|
|
// "status": "confirmed"
|
|
// },
|
|
// {
|
|
// "transfer_id": "890694db-156c-4e93-a3ef-4db61685aca7",
|
|
// "created_at": "2023-10-26T14:32:22.000Z",
|
|
// "confirmed_at": "2023-10-26T14:32:22.000Z",
|
|
// "asset": "USD",
|
|
// "amount": "-3.00",
|
|
// "status": "confirmed"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var transfers interface{} = this.SafeList(response, "transfers", []interface{}{})
|
|
|
|
ch <- this.ParseTransfers(transfers, currency, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// fetchTransfers
|
|
// {
|
|
// "transfer_id": "890694db-156c-4e93-a3ef-4db61685aca7",
|
|
// "created_at": "2023-10-26T14:32:22.000Z",
|
|
// "confirmed_at": "2023-10-26T14:32:22.000Z",
|
|
// "asset": "USD",
|
|
// "amount": "-3.00",
|
|
// "status": "confirmed"
|
|
// }
|
|
//
|
|
// transfer - privatePostV1TransfersInternalTransfer
|
|
// {
|
|
// "from_trader_id": "1f494ace-b3ed-4324-b202-55526ed06381",
|
|
// "to_trader_id": "d32c7a40-cc24-44b0-8597-f9edb3da989f",
|
|
// "asset": "string",
|
|
// "amount": "string"
|
|
// }
|
|
//
|
|
// transfer - privatePostV1TransfersFromWallet, privatePostV1TransfersToWallet
|
|
// {
|
|
// "transfer_id": "bb34f528-d9b0-47c6-b11f-4d4840b86ee3"
|
|
// }
|
|
//
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var currencyId interface{} = this.SafeString(transfer, "asset")
|
|
var confirmedAt interface{} = this.SafeString(transfer, "confirmed_at")
|
|
var timetstamp interface{} = this.Parse8601(confirmedAt)
|
|
var status interface{} = this.SafeString(transfer, "status")
|
|
var amountString interface{} = this.SafeString(transfer, "amount")
|
|
var fromAccount interface{} = nil
|
|
var toAccount interface{} = nil
|
|
var amount interface{} = nil
|
|
if IsTrue(!IsEqual(amountString, nil)) {
|
|
var amountIsNegative interface{} = Precise.StringLt(amountString, "0")
|
|
if IsTrue(amountIsNegative) {
|
|
fromAccount = "trading"
|
|
toAccount = "funding"
|
|
amountString = Precise.StringNeg(amountString)
|
|
} else {
|
|
fromAccount = "funding"
|
|
toAccount = "trading"
|
|
}
|
|
amount = this.ParseNumber(amountString)
|
|
}
|
|
return map[string]interface{} {
|
|
"info": transfer,
|
|
"id": this.SafeString(transfer, "transfer_id"),
|
|
"timestamp": timetstamp,
|
|
"datetime": this.Iso8601(timetstamp),
|
|
"currency": this.SafeCurrencyCode(currencyId, currency),
|
|
"amount": amount,
|
|
"fromAccount": fromAccount,
|
|
"toAccount": toAccount,
|
|
"status": this.ParseTransferStatus(status),
|
|
}
|
|
}
|
|
func (this *coinlist) ParseTransferStatus(status interface{}) interface{} {
|
|
var statuses interface{} = map[string]interface{} {
|
|
"confirmed": "ok",
|
|
}
|
|
return this.SafeString(statuses, status, status)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchDepositsWithdrawals
|
|
* @description fetch history of deposits and withdrawals from external wallets and between CoinList Pro trading account and CoinList wallet
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-coinlist-wallet-ledger
|
|
* @param {string} [code] unified currency code for the currency of the deposit/withdrawals
|
|
* @param {int} [since] timestamp in ms of the earliest deposit/withdrawal
|
|
* @param {int} [limit] max number of deposit/withdrawals to return (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a list of [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
|
*/
|
|
func (this *coinlist) FetchDepositsWithdrawals(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
code := GetArg(optionalArgs, 0, nil)
|
|
_ = code
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
if IsTrue(IsEqual(code, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchDepositsWithdrawals() requires a code argument")))
|
|
}
|
|
var traderId interface{} = this.SafeString2(params, "trader_id", "traderId")
|
|
if IsTrue(IsEqual(traderId, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchDepositsWithdrawals() requires a traderId argument in the params")))
|
|
}
|
|
|
|
retRes20358 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes20358)
|
|
var currency interface{} = this.Currency(code)
|
|
var request interface{} = map[string]interface{} {
|
|
"asset": GetValue(currency, "id"),
|
|
"trader_id": traderId,
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "count", limit)
|
|
}
|
|
params = this.Omit(params, []interface{}{"trader_id", "traderId"})
|
|
|
|
response:= (<-this.PrivateGetV1AccountsTraderIdWalletLedger(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// [
|
|
// {
|
|
// "id": "2c02db25-e8f2-4271-8222-e110bfd0aa2a",
|
|
// "asset": "ETH",
|
|
// "amount": "0.01",
|
|
// "created_at": "2023-10-20T13:15:37.000Z",
|
|
// "description": "Transfer to CoinList Pro",
|
|
// "type": "PRO_TRANSFER",
|
|
// "delta": "-0.010000000000000000"
|
|
// },
|
|
// {
|
|
// "id": "7139384d-6cec-479e-a19c-d498647ccb47",
|
|
// "asset": "ETH",
|
|
// "amount": "0.01",
|
|
// "created_at": "2023-10-20T13:10:55.000Z",
|
|
// "description": "CRYPTO_DEPOSIT",
|
|
// "type": "CRYPTO_DEPOSIT",
|
|
// "delta": "0.010000000000000000"
|
|
// },
|
|
//
|
|
// ...
|
|
//
|
|
// {
|
|
// "id": "91bbbb22-5ede-4e9a-81ef-3f9318aa83d2",
|
|
// "asset": "USDT",
|
|
// "amount": "4.169654",
|
|
// "withdrawal_fee_amount": "8.830346000000000000",
|
|
// "created_at": "2023-10-27T16:14:11.000Z",
|
|
// "description": "CRYPTO_WITHDRAWAL",
|
|
// "type": "CRYPTO_WITHDRAWAL",
|
|
// "delta": "-4.169654000000000000"
|
|
// },
|
|
// {
|
|
// "id": "830261bd-cda9-401f-b6df-105f4da3b37c",
|
|
// "asset": "USDT",
|
|
// "amount": "13",
|
|
// "created_at": "2023-10-27T14:52:05.000Z",
|
|
// "description": "Transfer from CoinList Pro",
|
|
// "type": "PRO_TRANSFER",
|
|
// "delta": "13.000000000000000000"
|
|
// }
|
|
// ]
|
|
//
|
|
// coinlist returns both internal transfers and blockchain transactions
|
|
ch <- this.ParseTransactions(response, currency, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#withdraw
|
|
* @description request a withdrawal from CoinList wallet. (Disabled by default. Contact CoinList to apply for an exception.)
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#request-withdrawal-from-wallet
|
|
* @param {string} code unified currency code
|
|
* @param {float} amount the amount to withdraw
|
|
* @param {string} address the address to withdraw to
|
|
* @param {string} tag
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
|
*/
|
|
func (this *coinlist) Withdraw(code interface{}, amount interface{}, address interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
tag := GetArg(optionalArgs, 0, nil)
|
|
_ = tag
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes21078 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes21078)
|
|
var currency interface{} = this.Currency(code)
|
|
var request interface{} = map[string]interface{} {
|
|
"asset": GetValue(currency, "id"),
|
|
"amount": this.CurrencyToPrecision(code, amount),
|
|
"destination_address": address,
|
|
}
|
|
|
|
response:= (<-this.PrivatePostV1TransfersWithdrawalRequest(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "transfer_id": "d4a2d8dd-7def-4545-a062-761683b9aa05"
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
|
|
ch <- this.ParseTransaction(data, currency)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} {
|
|
// withdraw
|
|
//
|
|
// {
|
|
// "transfer_id": "d4a2d8dd-7def-4545-a062-761683b9aa05"
|
|
// }
|
|
//
|
|
// fetchDepositsWithdrawals
|
|
// {
|
|
// "id": "91bbbb22-5ede-4e9a-81ef-3f9318aa83d2",
|
|
// "asset": "USDT",
|
|
// "amount": "4.169654",
|
|
// "withdrawal_fee_amount": "8.830346000000000000",
|
|
// "created_at": "2023-10-27T16:14:11.000Z",
|
|
// "description": "CRYPTO_WITHDRAWAL",
|
|
// "type": "CRYPTO_WITHDRAWAL",
|
|
// "delta": "-4.169654000000000000"
|
|
// },
|
|
//
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var currencyId interface{} = this.SafeString(transaction, "asset")
|
|
var code interface{} = this.SafeCurrencyCode(currencyId, currency)
|
|
var id interface{} = this.SafeString2(transaction, "id", "transfer_id")
|
|
var amount interface{} = this.SafeNumber(transaction, "amount")
|
|
var timestamp interface{} = this.Parse8601(this.SafeString(transaction, "created_at"))
|
|
var typeVar interface{} = this.SafeString(transaction, "type", nil)
|
|
if IsTrue(IsEqual(typeVar, nil)) {
|
|
typeVar = "withdrawal" // undefined only in withdraw() method
|
|
} else {
|
|
typeVar = this.ParseTransactionType(typeVar)
|
|
}
|
|
var fee interface{} = nil
|
|
var feeCost interface{} = this.SafeString(transaction, "withdrawal_fee_amount")
|
|
if IsTrue(!IsEqual(feeCost, nil)) {
|
|
fee = map[string]interface{} {
|
|
"cost": feeCost,
|
|
"currency": code,
|
|
}
|
|
}
|
|
return map[string]interface{} {
|
|
"info": transaction,
|
|
"id": id,
|
|
"txid": nil,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"network": nil,
|
|
"addressFrom": nil,
|
|
"address": nil,
|
|
"addressTo": nil,
|
|
"tagFrom": nil,
|
|
"tag": nil,
|
|
"tagTo": nil,
|
|
"type": typeVar,
|
|
"amount": amount,
|
|
"currency": code,
|
|
"status": nil,
|
|
"updated": nil,
|
|
"fee": fee,
|
|
"comment": this.SafeString(transaction, "description"),
|
|
"internal": nil,
|
|
}
|
|
}
|
|
func (this *coinlist) ParseTransactionType(typeVar interface{}) interface{} {
|
|
var types interface{} = map[string]interface{} {
|
|
"CRYPTO_DEPOSIT": "deposit",
|
|
"CRYPTO_WITHDRAWAL": "withdrawal",
|
|
"PRO_TRANSFER": "transfer",
|
|
}
|
|
return this.SafeString(types, typeVar, typeVar)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name coinlist#fetchLedger
|
|
* @description fetch the history of changes, actions done by the user or operations that altered the balance of the user
|
|
* @see https://trade-docs.coinlist.co/?javascript--nodejs#get-account-history
|
|
* @param {string} [code] unified currency code, default is undefined
|
|
* @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
|
|
* @param {int} [limit] max number of ledger entries to return (default 200, max 500)
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch entries for
|
|
* @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger}
|
|
*/
|
|
func (this *coinlist) FetchLedger(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
code := GetArg(optionalArgs, 0, nil)
|
|
_ = code
|
|
since := GetArg(optionalArgs, 1, nil)
|
|
_ = since
|
|
limit := GetArg(optionalArgs, 2, nil)
|
|
_ = limit
|
|
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
|
_ = params
|
|
var traderId interface{} = this.SafeString2(params, "trader_id", "traderId")
|
|
if IsTrue(IsEqual(traderId, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchLedger() requires a traderId argument in the params")))
|
|
}
|
|
|
|
retRes22128 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes22128)
|
|
var request interface{} = map[string]interface{} {
|
|
"trader_id": traderId,
|
|
}
|
|
var currency interface{} = nil
|
|
if IsTrue(!IsEqual(code, nil)) {
|
|
currency = this.Currency(code)
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "start_time", this.Iso8601(since))
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "count", limit)
|
|
}
|
|
var until interface{} = this.SafeInteger(params, "until")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "end_time", this.Iso8601(until))
|
|
}
|
|
params = this.Omit(params, []interface{}{"trader_id", "traderId"})
|
|
|
|
response:= (<-this.PrivateGetV1AccountsTraderIdLedger(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "transactions": [
|
|
// {
|
|
// "transaction_id": "0288634e-49bd-494d-b04a-18fd1832d394",
|
|
// "transaction_type": "XFER",
|
|
// "type": "deposit",
|
|
// "asset": "ETH",
|
|
// "symbol": null,
|
|
// "amount": "0.010000000000000000",
|
|
// "details": null,
|
|
// "created_at": "2023-10-20T13:15:39.443Z"
|
|
// },
|
|
// {
|
|
// "transaction_id": "47a45928-abcd-4c12-8bd6-587c3028025f",
|
|
// "transaction_type": "SWAP",
|
|
// "type": "atomic token swap",
|
|
// "asset": "USDT",
|
|
// "symbol": "ETH-USDT",
|
|
// "amount": "1.447947",
|
|
// "details": null,
|
|
// "created_at": "2023-10-20T13:16:30.373Z"
|
|
// },
|
|
// {
|
|
// "transaction_id": "1ffe3a54-916e-41f0-b957-3a01309eb009",
|
|
// "transaction_type": "FEE",
|
|
// "type": "fee",
|
|
// "asset": "USDT",
|
|
// "symbol": "ETH-USDT",
|
|
// "amount": "-0.006516",
|
|
// "details": {
|
|
// "fee_details": [
|
|
// {
|
|
// "insurance_fee": "0",
|
|
// "order_id": "39911d5f-c789-4a7d-ad34-820a804d1da6",
|
|
// "fee_type": "taker",
|
|
// "fee_currency": "USDT"
|
|
// }
|
|
// ]
|
|
// },
|
|
// "created_at": "2023-10-20T13:16:30.373Z"
|
|
// },
|
|
// {
|
|
// "transaction_id": "3930e8a3-2218-481f-8c3c-2219287e205e",
|
|
// "transaction_type": "SWAP",
|
|
// "type": "atomic token swap",
|
|
// "asset": "ETH",
|
|
// "symbol": "ETH-USDT",
|
|
// "amount": "-0.000900000000000000",
|
|
// "details": null,
|
|
// "created_at": "2023-10-20T13:16:30.373Z"
|
|
// },
|
|
// {
|
|
// "transaction_id": "a6c65cb3-95d0-44e2-8202-f70581d6e55c",
|
|
// "transaction_type": "XFER",
|
|
// "type": "withdrawal",
|
|
// "asset": "USD",
|
|
// "symbol": null,
|
|
// "amount": "-3.00",
|
|
// "details": null,
|
|
// "created_at": "2023-10-26T14:32:24.887Z"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var ledger interface{} = this.SafeValue(response, "transactions", []interface{}{})
|
|
|
|
ch <- this.ParseLedger(ledger, currency, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *coinlist) ParseLedgerEntry(item interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// deposit transaction from wallet (funding) to pro (trading)
|
|
// {
|
|
// "transaction_id": "0288634e-49bd-494d-b04a-18fd1832d394",
|
|
// "transaction_type": "XFER",
|
|
// "type": "deposit",
|
|
// "asset": "ETH",
|
|
// "symbol": null,
|
|
// "amount": "0.010000000000000000",
|
|
// "details": null,
|
|
// "created_at": "2023-10-20T13:15:39.443Z"
|
|
// }
|
|
//
|
|
// withdrawal transaction from pro (trading) to wallet (funding)
|
|
// {
|
|
// "transaction_id": "a6c65cb3-95d0-44e2-8202-f70581d6e55c",
|
|
// "transaction_type": "XFER",
|
|
// "type": "withdrawal",
|
|
// "asset": "USD",
|
|
// "symbol": null,
|
|
// "amount": "-3.00",
|
|
// "details": null,
|
|
// "created_at": "2023-10-26T14:32:24.887Z"
|
|
// }
|
|
//
|
|
// sell trade
|
|
// {
|
|
// "transaction_id": "47a45928-abcd-4c12-8bd6-587c3028025f",
|
|
// "transaction_type": "SWAP",
|
|
// "type": "atomic token swap",
|
|
// "asset": "USDT",
|
|
// "symbol": "ETH-USDT",
|
|
// "amount": "1.447947",
|
|
// "details": null,
|
|
// "created_at": "2023-10-20T13:16:30.373Z"
|
|
// }
|
|
//
|
|
// buy trade
|
|
// {
|
|
// "transaction_id": "46d20a93-45c4-4441-a238-f89602eb8c8c",
|
|
// "transaction_type": "SWAP",
|
|
// "type": "atomic token swap",
|
|
// "asset": "ETH",
|
|
// "symbol": "ETH-USDT",
|
|
// "amount": "0.000800000000000000",
|
|
// "details": null,
|
|
// "created_at": "2023-10-20T13:22:14.256Z"
|
|
// },
|
|
//
|
|
// fee
|
|
// {
|
|
// "transaction_id": "57fd526c-36b1-4721-83ce-42aadcb1e953",
|
|
// "transaction_type": "FEE",
|
|
// "type": "fee",
|
|
// "asset": "USDT",
|
|
// "symbol": "BTC-USDT",
|
|
// "amount": "-0.047176",
|
|
// "details": {
|
|
// "fee_details": [
|
|
// {
|
|
// "insurance_fee": "0",
|
|
// "order_id": "c0bc33cd-eeb9-40a0-ab5f-2d99f323ef58",
|
|
// "fee_type": "taker",
|
|
// "fee_currency": "USDT"
|
|
// }
|
|
// ]
|
|
// },
|
|
// "created_at": "2023-10-25T16:46:24.294Z"
|
|
// }
|
|
//
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var id interface{} = this.SafeString(item, "transaction_id")
|
|
var createdAt interface{} = this.SafeString(item, "created_at")
|
|
var timestamp interface{} = this.Parse8601(createdAt)
|
|
var amount interface{} = this.SafeString(item, "amount")
|
|
var amountIsNegative interface{} = Precise.StringLt(amount, "0")
|
|
var direction interface{} = nil
|
|
if IsTrue(amountIsNegative) {
|
|
direction = "out"
|
|
amount = Precise.StringNeg(amount)
|
|
} else {
|
|
direction = "in"
|
|
}
|
|
var currencyId interface{} = this.SafeString(item, "asset")
|
|
var code interface{} = this.SafeCurrencyCode(currencyId, currency)
|
|
currency = this.SafeCurrency(currencyId, currency)
|
|
var typeVar interface{} = this.ParseLedgerEntryType(this.SafeString(item, "type"))
|
|
return this.SafeLedgerEntry(map[string]interface{} {
|
|
"info": item,
|
|
"id": id,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"direction": direction,
|
|
"account": "trading",
|
|
"referenceId": nil,
|
|
"referenceAccount": nil,
|
|
"type": typeVar,
|
|
"currency": code,
|
|
"amount": this.ParseNumber(amount),
|
|
"before": nil,
|
|
"after": nil,
|
|
"status": "ok",
|
|
"fee": nil,
|
|
}, currency)
|
|
}
|
|
func (this *coinlist) ParseLedgerEntryType(typeVar interface{}) interface{} {
|
|
var types interface{} = map[string]interface{} {
|
|
"atomic token swap": "trade",
|
|
"fee": "fee",
|
|
"deposit": "transfer",
|
|
"withdrawal": "transfer",
|
|
}
|
|
return this.SafeString(types, typeVar, typeVar)
|
|
}
|
|
func (this *coinlist) Sign(path interface{}, optionalArgs ...interface{}) interface{} {
|
|
api := GetArg(optionalArgs, 0, "public")
|
|
_ = api
|
|
method := GetArg(optionalArgs, 1, "GET")
|
|
_ = method
|
|
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
|
_ = params
|
|
headers := GetArg(optionalArgs, 3, nil)
|
|
_ = headers
|
|
body := GetArg(optionalArgs, 4, nil)
|
|
_ = body
|
|
var request interface{} = this.Omit(params, this.ExtractParams(path))
|
|
var endpoint interface{} = Add("/", this.ImplodeParams(path, params))
|
|
var url interface{} = Add(GetValue(GetValue(this.Urls, "api"), api), endpoint)
|
|
var isBulk interface{} = IsArray(params)
|
|
var query interface{} = nil
|
|
if !IsTrue(isBulk) {
|
|
query = this.Urlencode(request)
|
|
}
|
|
if IsTrue(IsEqual(api, "private")) {
|
|
this.CheckRequiredCredentials()
|
|
var timestamp interface{} = ToString(this.Seconds())
|
|
var auth interface{} = Add(Add(timestamp, method), endpoint)
|
|
if IsTrue(IsTrue(IsTrue((IsEqual(method, "POST"))) || IsTrue((IsEqual(method, "PATCH")))) || IsTrue(isBulk)) {
|
|
body = this.Json(request)
|
|
auth = Add(auth, body)
|
|
} else if IsTrue(IsTrue(!IsEqual(query, nil)) && IsTrue(!IsEqual(GetLength(query), 0))) {
|
|
auth = Add(auth, Add("?", query))
|
|
url = Add(url, Add("?", query))
|
|
}
|
|
var signature interface{} = this.Hmac(this.Encode(auth), this.Base64ToBinary(this.Secret), sha256, "base64")
|
|
headers = map[string]interface{} {
|
|
"CL-ACCESS-KEY": this.ApiKey,
|
|
"CL-ACCESS-SIG": signature,
|
|
"CL-ACCESS-TIMESTAMP": timestamp,
|
|
"Content-Type": "application/json",
|
|
}
|
|
} else if IsTrue(IsTrue(!IsEqual(query, nil)) && IsTrue(!IsEqual(GetLength(query), 0))) {
|
|
url = Add(url, Add("?", query))
|
|
}
|
|
return map[string]interface{} {
|
|
"url": url,
|
|
"method": method,
|
|
"body": body,
|
|
"headers": headers,
|
|
}
|
|
}
|
|
func (this *coinlist) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} {
|
|
if IsTrue(IsEqual(response, nil)) {
|
|
// In some cases the exchange returns 202 Accepted for bad orders.
|
|
// The body of that response contains order_id of the order.
|
|
// Some bad orders will get status 'rejected' and could be fetched later (by using fetchOrders() or fetchOrder(order_id)).
|
|
// While others don't get any status, they simply disappear, but the response is still 202 Accepted and contains their order_id.
|
|
// When using fechOrder(order_id) for such disappeared orders, the exchange returns an empty response with code 404.
|
|
if IsTrue(IsTrue(IsTrue((IsEqual(code, 404))) && IsTrue((IsGreaterThanOrEqual(GetIndexOf(url, "/orders/"), 0)))) && IsTrue((IsEqual(method, "GET")))) {
|
|
var parts interface{} = Split(url, "/orders/")
|
|
var orderId interface{} = this.SafeString(parts, 1)
|
|
panic(OrderNotFound(Add(Add(Add(this.Id, " order "), orderId), " not found (or rejected on the exchange side)")))
|
|
}
|
|
return nil
|
|
}
|
|
var responseCode interface{} = this.SafeString(response, "status")
|
|
var messageCode interface{} = this.SafeString(response, "message_code")
|
|
if IsTrue(IsTrue((!IsEqual(messageCode, nil))) || IsTrue((IsTrue(IsTrue(IsTrue(IsTrue((!IsEqual(responseCode, nil))) && IsTrue((!IsEqual(code, 200)))) && IsTrue((!IsEqual(code, 202)))) && IsTrue((!IsEqual(responseCode, "200")))) && IsTrue((!IsEqual(responseCode, "202")))))) {
|
|
var feedback interface{} = Add(Add(this.Id, " "), body)
|
|
var message interface{} = this.SafeString(response, "message")
|
|
this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), message, feedback)
|
|
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), messageCode, feedback)
|
|
panic(ExchangeError(feedback))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
|
|
func (this *coinlist) Init(userConfig map[string]interface{}) {
|
|
this.Exchange = Exchange{}
|
|
this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this)
|
|
this.Exchange.DerivedExchange = this
|
|
}
|