1530 lines
63 KiB
JavaScript
1530 lines
63 KiB
JavaScript
'use strict';
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const Exchange = require ('./base/Exchange');
|
|
const { ExchangeError, BadRequest, AuthenticationError, InvalidOrder, InsufficientFunds, OrderNotFound, PermissionDenied, AddressPending } = require ('./base/errors');
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
module.exports = class upbit extends Exchange {
|
|
describe () {
|
|
return this.deepExtend (super.describe (), {
|
|
'id': 'upbit',
|
|
'name': 'Upbit',
|
|
'countries': [ 'KR' ],
|
|
'version': 'v1',
|
|
'rateLimit': 1000,
|
|
'certified': true,
|
|
'pro': true,
|
|
// new metainfo interface
|
|
'has': {
|
|
'CORS': true,
|
|
'createDepositAddress': true,
|
|
'createMarketOrder': true,
|
|
'fetchDepositAddress': true,
|
|
'fetchClosedOrders': true,
|
|
'fetchMyTrades': false,
|
|
'fetchOHLCV': true,
|
|
'fetchOrder': true,
|
|
'fetchOrderBooks': true,
|
|
'fetchOpenOrders': true,
|
|
'fetchOrders': false,
|
|
'fetchTickers': true,
|
|
'withdraw': true,
|
|
'fetchDeposits': true,
|
|
'fetchWithdrawals': true,
|
|
'fetchTransactions': false,
|
|
},
|
|
'timeframes': {
|
|
'1m': 'minutes',
|
|
'3m': 'minutes',
|
|
'5m': 'minutes',
|
|
'15m': 'minutes',
|
|
'30m': 'minutes',
|
|
'1h': 'minutes',
|
|
'4h': 'minutes',
|
|
'1d': 'days',
|
|
'1w': 'weeks',
|
|
'1M': 'months',
|
|
},
|
|
'hostname': 'api.upbit.com',
|
|
'urls': {
|
|
'logo': 'https://user-images.githubusercontent.com/1294454/49245610-eeaabe00-f423-11e8-9cba-4b0aed794799.jpg',
|
|
'api': {
|
|
'public': 'https://{hostname}',
|
|
'private': 'https://{hostname}',
|
|
},
|
|
'www': 'https://upbit.com',
|
|
'doc': 'https://docs.upbit.com/docs/%EC%9A%94%EC%B2%AD-%EC%88%98-%EC%A0%9C%ED%95%9C',
|
|
'fees': 'https://upbit.com/service_center/guide',
|
|
},
|
|
'api': {
|
|
'public': {
|
|
'get': [
|
|
'market/all',
|
|
'candles/{timeframe}',
|
|
'candles/{timeframe}/{unit}',
|
|
'candles/minutes/{unit}',
|
|
'candles/minutes/1',
|
|
'candles/minutes/3',
|
|
'candles/minutes/5',
|
|
'candles/minutes/15',
|
|
'candles/minutes/30',
|
|
'candles/minutes/60',
|
|
'candles/minutes/240',
|
|
'candles/days',
|
|
'candles/weeks',
|
|
'candles/months',
|
|
'trades/ticks',
|
|
'ticker',
|
|
'orderbook',
|
|
],
|
|
},
|
|
'private': {
|
|
'get': [
|
|
'accounts',
|
|
'orders/chance',
|
|
'order',
|
|
'orders',
|
|
'withdraws',
|
|
'withdraw',
|
|
'withdraws/chance',
|
|
'deposits',
|
|
'deposit',
|
|
'deposits/coin_addresses',
|
|
'deposits/coin_address',
|
|
],
|
|
'post': [
|
|
'orders',
|
|
'withdraws/coin',
|
|
'withdraws/krw',
|
|
'deposits/generate_coin_address',
|
|
],
|
|
'delete': [
|
|
'order',
|
|
],
|
|
},
|
|
},
|
|
'fees': {
|
|
'trading': {
|
|
'tierBased': false,
|
|
'percentage': true,
|
|
'maker': 0.0025,
|
|
'taker': 0.0025,
|
|
},
|
|
'funding': {
|
|
'tierBased': false,
|
|
'percentage': false,
|
|
'withdraw': {},
|
|
'deposit': {},
|
|
},
|
|
},
|
|
'exceptions': {
|
|
'exact': {
|
|
'This key has expired.': AuthenticationError,
|
|
'Missing request parameter error. Check the required parameters!': BadRequest,
|
|
'side is missing, side does not have a valid value': InvalidOrder,
|
|
},
|
|
'broad': {
|
|
'thirdparty_agreement_required': PermissionDenied,
|
|
'out_of_scope': PermissionDenied,
|
|
'order_not_found': OrderNotFound,
|
|
'insufficient_funds': InsufficientFunds,
|
|
'invalid_access_key': AuthenticationError,
|
|
'jwt_verification': AuthenticationError,
|
|
'create_ask_error': ExchangeError,
|
|
'create_bid_error': ExchangeError,
|
|
'volume_too_large': InvalidOrder,
|
|
'invalid_funds': InvalidOrder,
|
|
},
|
|
},
|
|
'options': {
|
|
'createMarketBuyOrderRequiresPrice': true,
|
|
'fetchTickersMaxLength': 4096, // 2048,
|
|
'fetchOrderBooksMaxLength': 4096, // 2048,
|
|
'symbolSeparator': '-',
|
|
'tradingFeesByQuoteCurrency': {
|
|
'KRW': 0.0005,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
async fetchCurrency (code, params = {}) {
|
|
// this method is for retrieving funding fees and limits per currency
|
|
// it requires private access and API keys properly set up
|
|
await this.loadMarkets ();
|
|
const currency = this.currency (code);
|
|
return await this.fetchCurrencyById (currency['id'], params);
|
|
}
|
|
|
|
async fetchCurrencyById (id, params = {}) {
|
|
// this method is for retrieving funding fees and limits per currency
|
|
// it requires private access and API keys properly set up
|
|
const request = {
|
|
'currency': id,
|
|
};
|
|
const response = await this.privateGetWithdrawsChance (this.extend (request, params));
|
|
//
|
|
// {
|
|
// "member_level": {
|
|
// "security_level": 3,
|
|
// "fee_level": 0,
|
|
// "email_verified": true,
|
|
// "identity_auth_verified": true,
|
|
// "bank_account_verified": true,
|
|
// "kakao_pay_auth_verified": false,
|
|
// "locked": false,
|
|
// "wallet_locked": false
|
|
// },
|
|
// "currency": {
|
|
// "code": "BTC",
|
|
// "withdraw_fee": "0.0005",
|
|
// "is_coin": true,
|
|
// "wallet_state": "working",
|
|
// "wallet_support": [ "deposit", "withdraw" ]
|
|
// },
|
|
// "account": {
|
|
// "currency": "BTC",
|
|
// "balance": "10.0",
|
|
// "locked": "0.0",
|
|
// "avg_krw_buy_price": "8042000",
|
|
// "modified": false
|
|
// },
|
|
// "withdraw_limit": {
|
|
// "currency": "BTC",
|
|
// "minimum": null,
|
|
// "onetime": null,
|
|
// "daily": "10.0",
|
|
// "remaining_daily": "10.0",
|
|
// "remaining_daily_krw": "0.0",
|
|
// "fixed": null,
|
|
// "can_withdraw": true
|
|
// }
|
|
// }
|
|
//
|
|
const memberInfo = this.safeValue (response, 'member_level', {});
|
|
const currencyInfo = this.safeValue (response, 'currency', {});
|
|
const withdrawLimits = this.safeValue (response, 'withdraw_limit', {});
|
|
const canWithdraw = this.safeValue (withdrawLimits, 'can_withdraw');
|
|
const walletState = this.safeString (currencyInfo, 'wallet_state');
|
|
const walletLocked = this.safeValue (memberInfo, 'wallet_locked');
|
|
const locked = this.safeValue (memberInfo, 'locked');
|
|
let active = true;
|
|
if ((canWithdraw !== undefined) && canWithdraw) {
|
|
active = false;
|
|
} else if (walletState !== 'working') {
|
|
active = false;
|
|
} else if ((walletLocked !== undefined) && walletLocked) {
|
|
active = false;
|
|
} else if ((locked !== undefined) && locked) {
|
|
active = false;
|
|
}
|
|
const maxOnetimeWithdrawal = this.safeFloat (withdrawLimits, 'onetime');
|
|
const maxDailyWithdrawal = this.safeFloat (withdrawLimits, 'daily', maxOnetimeWithdrawal);
|
|
const remainingDailyWithdrawal = this.safeFloat (withdrawLimits, 'remaining_daily', maxDailyWithdrawal);
|
|
let maxWithdrawLimit = undefined;
|
|
if (remainingDailyWithdrawal > 0) {
|
|
maxWithdrawLimit = remainingDailyWithdrawal;
|
|
} else {
|
|
maxWithdrawLimit = maxDailyWithdrawal;
|
|
}
|
|
const precision = undefined;
|
|
const currencyId = this.safeString (currencyInfo, 'code');
|
|
const code = this.safeCurrencyCode (currencyId);
|
|
return {
|
|
'info': response,
|
|
'id': currencyId,
|
|
'code': code,
|
|
'name': code,
|
|
'active': active,
|
|
'fee': this.safeFloat (currencyInfo, 'withdraw_fee'),
|
|
'precision': precision,
|
|
'limits': {
|
|
'withdraw': {
|
|
'min': this.safeFloat (withdrawLimits, 'minimum'),
|
|
'max': maxWithdrawLimit,
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
async fetchMarket (symbol, params = {}) {
|
|
// this method is for retrieving trading fees and limits per market
|
|
// it requires private access and API keys properly set up
|
|
await this.loadMarkets ();
|
|
const market = this.market (symbol);
|
|
return await this.fetchMarketById (market['id'], params);
|
|
}
|
|
|
|
async fetchMarketById (id, params = {}) {
|
|
// this method is for retrieving trading fees and limits per market
|
|
// it requires private access and API keys properly set up
|
|
const request = {
|
|
'market': id,
|
|
};
|
|
const response = await this.privateGetOrdersChance (this.extend (request, params));
|
|
//
|
|
// { bid_fee: "0.0005",
|
|
// ask_fee: "0.0005",
|
|
// market: { id: "KRW-BTC",
|
|
// name: "BTC/KRW",
|
|
// order_types: ["limit"],
|
|
// order_sides: ["ask", "bid"],
|
|
// bid: { currency: "KRW",
|
|
// price_unit: null,
|
|
// min_total: 1000 },
|
|
// ask: { currency: "BTC",
|
|
// price_unit: null,
|
|
// min_total: 1000 },
|
|
// max_total: "1000000000.0",
|
|
// state: "active" },
|
|
// bid_account: { currency: "KRW",
|
|
// balance: "0.0",
|
|
// locked: "0.0",
|
|
// avg_krw_buy_price: "0",
|
|
// modified: false },
|
|
// ask_account: { currency: "BTC",
|
|
// balance: "0.00780836",
|
|
// locked: "0.0",
|
|
// avg_krw_buy_price: "6465564.67",
|
|
// modified: false } }
|
|
//
|
|
const marketInfo = this.safeValue (response, 'market');
|
|
const bid = this.safeValue (marketInfo, 'bid');
|
|
const ask = this.safeValue (marketInfo, 'ask');
|
|
const marketId = this.safeString (marketInfo, 'id');
|
|
const baseId = this.safeString (ask, 'currency');
|
|
const quoteId = this.safeString (bid, 'currency');
|
|
const base = this.safeCurrencyCode (baseId);
|
|
const quote = this.safeCurrencyCode (quoteId);
|
|
const symbol = base + '/' + quote;
|
|
const precision = {
|
|
'amount': 8,
|
|
'price': 8,
|
|
};
|
|
const state = this.safeString (marketInfo, 'state');
|
|
const active = (state === 'active');
|
|
const bidFee = this.safeFloat (response, 'bid_fee');
|
|
const askFee = this.safeFloat (response, 'ask_fee');
|
|
const fee = Math.max (bidFee, askFee);
|
|
return {
|
|
'info': response,
|
|
'id': marketId,
|
|
'symbol': symbol,
|
|
'base': base,
|
|
'quote': quote,
|
|
'baseId': baseId,
|
|
'quoteId': quoteId,
|
|
'active': active,
|
|
'precision': precision,
|
|
'maker': fee,
|
|
'taker': fee,
|
|
'limits': {
|
|
'amount': {
|
|
'min': this.safeFloat (ask, 'min_total'),
|
|
'max': undefined,
|
|
},
|
|
'price': {
|
|
'min': Math.pow (10, -precision['price']),
|
|
'max': undefined,
|
|
},
|
|
'cost': {
|
|
'min': this.safeFloat (bid, 'min_total'),
|
|
'max': this.safeFloat (marketInfo, 'max_total'),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
async fetchMarkets (params = {}) {
|
|
const response = await this.publicGetMarketAll (params);
|
|
//
|
|
// [ { market: "KRW-BTC",
|
|
// korean_name: "비트코인",
|
|
// english_name: "Bitcoin" },
|
|
// { market: "KRW-DASH",
|
|
// korean_name: "대시",
|
|
// english_name: "Dash" },
|
|
// { market: "KRW-ETH",
|
|
// korean_name: "이더리움",
|
|
// english_name: "Ethereum" },
|
|
// { market: "BTC-ETH",
|
|
// korean_name: "이더리움",
|
|
// english_name: "Ethereum" },
|
|
// ...,
|
|
// { market: "BTC-BSV",
|
|
// korean_name: "비트코인에스브이",
|
|
// english_name: "Bitcoin SV" } ]
|
|
//
|
|
const result = [];
|
|
for (let i = 0; i < response.length; i++) {
|
|
const market = response[i];
|
|
const id = this.safeString (market, 'market');
|
|
const [ quoteId, baseId ] = id.split ('-');
|
|
const base = this.safeCurrencyCode (baseId);
|
|
const quote = this.safeCurrencyCode (quoteId);
|
|
const symbol = base + '/' + quote;
|
|
const precision = {
|
|
'amount': 8,
|
|
'price': 8,
|
|
};
|
|
const active = true;
|
|
const makerFee = this.safeFloat (this.options['tradingFeesByQuoteCurrency'], quote, this.fees['trading']['maker']);
|
|
const takerFee = this.safeFloat (this.options['tradingFeesByQuoteCurrency'], quote, this.fees['trading']['taker']);
|
|
result.push ({
|
|
'id': id,
|
|
'symbol': symbol,
|
|
'base': base,
|
|
'quote': quote,
|
|
'baseId': baseId,
|
|
'quoteId': quoteId,
|
|
'active': active,
|
|
'info': market,
|
|
'precision': precision,
|
|
'maker': makerFee,
|
|
'taker': takerFee,
|
|
'limits': {
|
|
'amount': {
|
|
'min': Math.pow (10, -precision['amount']),
|
|
'max': undefined,
|
|
},
|
|
'price': {
|
|
'min': Math.pow (10, -precision['price']),
|
|
'max': undefined,
|
|
},
|
|
'cost': {
|
|
'min': undefined,
|
|
'max': undefined,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
async fetchBalance (params = {}) {
|
|
await this.loadMarkets ();
|
|
const response = await this.privateGetAccounts (params);
|
|
//
|
|
// [ { currency: "BTC",
|
|
// balance: "0.005",
|
|
// locked: "0.0",
|
|
// avg_krw_buy_price: "7446000",
|
|
// modified: false },
|
|
// { currency: "ETH",
|
|
// balance: "0.1",
|
|
// locked: "0.0",
|
|
// avg_krw_buy_price: "250000",
|
|
// modified: false } ]
|
|
//
|
|
const result = { 'info': response };
|
|
for (let i = 0; i < response.length; i++) {
|
|
const balance = response[i];
|
|
const currencyId = this.safeString (balance, 'currency');
|
|
const code = this.safeCurrencyCode (currencyId);
|
|
const account = this.account ();
|
|
account['free'] = this.safeFloat (balance, 'balance');
|
|
account['used'] = this.safeFloat (balance, 'locked');
|
|
result[code] = account;
|
|
}
|
|
return this.parseBalance (result);
|
|
}
|
|
|
|
getSymbolFromMarketId (marketId, market = undefined) {
|
|
if (marketId === undefined) {
|
|
return undefined;
|
|
}
|
|
market = this.safeValue (this.markets_by_id, marketId, market);
|
|
if (market !== undefined) {
|
|
return market['symbol'];
|
|
}
|
|
const [ baseId, quoteId ] = marketId.split (this.options['symbolSeparator']);
|
|
const base = this.safeCurrencyCode (baseId);
|
|
const quote = this.safeCurrencyCode (quoteId);
|
|
return base + '/' + quote;
|
|
}
|
|
|
|
async fetchOrderBooks (symbols = undefined, limit = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
let ids = undefined;
|
|
if (symbols === undefined) {
|
|
ids = this.ids.join (',');
|
|
// max URL length is 2083 symbols, including http schema, hostname, tld, etc...
|
|
if (ids.length > this.options['fetchOrderBooksMaxLength']) {
|
|
const numIds = this.ids.length;
|
|
throw new ExchangeError (this.id + ' has ' + numIds.toString () + ' symbols (' + ids.length.toString () + ' characters) exceeding max URL length (' + this.options['fetchOrderBooksMaxLength'].toString () + ' characters), you are required to specify a list of symbols in the first argument to fetchOrderBooks');
|
|
}
|
|
} else {
|
|
ids = this.marketIds (symbols);
|
|
ids = ids.join (',');
|
|
}
|
|
const request = {
|
|
'markets': ids,
|
|
};
|
|
const response = await this.publicGetOrderbook (this.extend (request, params));
|
|
//
|
|
// [ { market: "BTC-ETH",
|
|
// timestamp: 1542899030043,
|
|
// total_ask_size: 109.57065201,
|
|
// total_bid_size: 125.74430631,
|
|
// orderbook_units: [ { ask_price: 0.02926679,
|
|
// bid_price: 0.02919904,
|
|
// ask_size: 4.20293961,
|
|
// bid_size: 11.65043576 },
|
|
// ...,
|
|
// { ask_price: 0.02938209,
|
|
// bid_price: 0.0291231,
|
|
// ask_size: 0.05135782,
|
|
// bid_size: 13.5595 } ] },
|
|
// { market: "KRW-BTC",
|
|
// timestamp: 1542899034662,
|
|
// total_ask_size: 12.89790974,
|
|
// total_bid_size: 4.88395783,
|
|
// orderbook_units: [ { ask_price: 5164000,
|
|
// bid_price: 5162000,
|
|
// ask_size: 2.57606495,
|
|
// bid_size: 0.214 },
|
|
// ...,
|
|
// { ask_price: 5176000,
|
|
// bid_price: 5152000,
|
|
// ask_size: 2.752,
|
|
// bid_size: 0.4650305 } ] } ]
|
|
//
|
|
const result = {};
|
|
for (let i = 0; i < response.length; i++) {
|
|
const orderbook = response[i];
|
|
const symbol = this.getSymbolFromMarketId (this.safeString (orderbook, 'market'));
|
|
const timestamp = this.safeInteger (orderbook, 'timestamp');
|
|
result[symbol] = {
|
|
'bids': this.sortBy (this.parseBidsAsks (orderbook['orderbook_units'], 'bid_price', 'bid_size'), 0, true),
|
|
'asks': this.sortBy (this.parseBidsAsks (orderbook['orderbook_units'], 'ask_price', 'ask_size'), 0),
|
|
'timestamp': timestamp,
|
|
'datetime': this.iso8601 (timestamp),
|
|
'nonce': undefined,
|
|
};
|
|
}
|
|
return result;
|
|
}
|
|
|
|
async fetchOrderBook (symbol, limit = undefined, params = {}) {
|
|
const orderbooks = await this.fetchOrderBooks ([ symbol ], limit, params);
|
|
return this.safeValue (orderbooks, symbol);
|
|
}
|
|
|
|
parseTicker (ticker, market = undefined) {
|
|
//
|
|
// { market: "BTC-ETH",
|
|
// trade_date: "20181122",
|
|
// trade_time: "104543",
|
|
// trade_date_kst: "20181122",
|
|
// trade_time_kst: "194543",
|
|
// trade_timestamp: 1542883543097,
|
|
// opening_price: 0.02976455,
|
|
// high_price: 0.02992577,
|
|
// low_price: 0.02934283,
|
|
// trade_price: 0.02947773,
|
|
// prev_closing_price: 0.02966,
|
|
// change: "FALL",
|
|
// change_price: 0.00018227,
|
|
// change_rate: 0.0061453136,
|
|
// signed_change_price: -0.00018227,
|
|
// signed_change_rate: -0.0061453136,
|
|
// trade_volume: 1.00000005,
|
|
// acc_trade_price: 100.95825586,
|
|
// acc_trade_price_24h: 289.58650166,
|
|
// acc_trade_volume: 3409.85311036,
|
|
// acc_trade_volume_24h: 9754.40510513,
|
|
// highest_52_week_price: 0.12345678,
|
|
// highest_52_week_date: "2018-02-01",
|
|
// lowest_52_week_price: 0.023936,
|
|
// lowest_52_week_date: "2017-12-08",
|
|
// timestamp: 1542883543813 }
|
|
//
|
|
const timestamp = this.safeInteger (ticker, 'trade_timestamp');
|
|
const symbol = this.getSymbolFromMarketId (this.safeString2 (ticker, 'market', 'code'), market);
|
|
const previous = this.safeFloat (ticker, 'prev_closing_price');
|
|
const last = this.safeFloat (ticker, 'trade_price');
|
|
const change = this.safeFloat (ticker, 'signed_change_price');
|
|
const percentage = this.safeFloat (ticker, 'signed_change_rate');
|
|
return {
|
|
'symbol': symbol,
|
|
'timestamp': timestamp,
|
|
'datetime': this.iso8601 (timestamp),
|
|
'high': this.safeFloat (ticker, 'high_price'),
|
|
'low': this.safeFloat (ticker, 'low_price'),
|
|
'bid': undefined,
|
|
'bidVolume': undefined,
|
|
'ask': undefined,
|
|
'askVolume': undefined,
|
|
'vwap': undefined,
|
|
'open': this.safeFloat (ticker, 'opening_price'),
|
|
'close': last,
|
|
'last': last,
|
|
'previousClose': previous,
|
|
'change': change,
|
|
'percentage': percentage,
|
|
'average': undefined,
|
|
'baseVolume': this.safeFloat (ticker, 'acc_trade_volume_24h'),
|
|
'quoteVolume': this.safeFloat (ticker, 'acc_trade_price_24h'),
|
|
'info': ticker,
|
|
};
|
|
}
|
|
|
|
async fetchTickers (symbols = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
let ids = undefined;
|
|
if (symbols === undefined) {
|
|
ids = this.ids.join (',');
|
|
// max URL length is 2083 symbols, including http schema, hostname, tld, etc...
|
|
if (ids.length > this.options['fetchTickersMaxLength']) {
|
|
const numIds = this.ids.length;
|
|
throw new ExchangeError (this.id + ' has ' + numIds.toString () + ' symbols exceeding max URL length, you are required to specify a list of symbols in the first argument to fetchTickers');
|
|
}
|
|
} else {
|
|
ids = this.marketIds (symbols);
|
|
ids = ids.join (',');
|
|
}
|
|
const request = {
|
|
'markets': ids,
|
|
};
|
|
const response = await this.publicGetTicker (this.extend (request, params));
|
|
//
|
|
// [ { market: "BTC-ETH",
|
|
// trade_date: "20181122",
|
|
// trade_time: "104543",
|
|
// trade_date_kst: "20181122",
|
|
// trade_time_kst: "194543",
|
|
// trade_timestamp: 1542883543097,
|
|
// opening_price: 0.02976455,
|
|
// high_price: 0.02992577,
|
|
// low_price: 0.02934283,
|
|
// trade_price: 0.02947773,
|
|
// prev_closing_price: 0.02966,
|
|
// change: "FALL",
|
|
// change_price: 0.00018227,
|
|
// change_rate: 0.0061453136,
|
|
// signed_change_price: -0.00018227,
|
|
// signed_change_rate: -0.0061453136,
|
|
// trade_volume: 1.00000005,
|
|
// acc_trade_price: 100.95825586,
|
|
// acc_trade_price_24h: 289.58650166,
|
|
// acc_trade_volume: 3409.85311036,
|
|
// acc_trade_volume_24h: 9754.40510513,
|
|
// highest_52_week_price: 0.12345678,
|
|
// highest_52_week_date: "2018-02-01",
|
|
// lowest_52_week_price: 0.023936,
|
|
// lowest_52_week_date: "2017-12-08",
|
|
// timestamp: 1542883543813 } ]
|
|
//
|
|
const result = {};
|
|
for (let t = 0; t < response.length; t++) {
|
|
const ticker = this.parseTicker (response[t]);
|
|
const symbol = ticker['symbol'];
|
|
result[symbol] = ticker;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
async fetchTicker (symbol, params = {}) {
|
|
const tickers = await this.fetchTickers ([ symbol ], params);
|
|
return this.safeValue (tickers, symbol);
|
|
}
|
|
|
|
parseTrade (trade, market = undefined) {
|
|
//
|
|
// fetchTrades
|
|
//
|
|
// { market: "BTC-ETH",
|
|
// trade_date_utc: "2018-11-22",
|
|
// trade_time_utc: "13:55:24",
|
|
// timestamp: 1542894924397,
|
|
// trade_price: 0.02914289,
|
|
// trade_volume: 0.20074397,
|
|
// prev_closing_price: 0.02966,
|
|
// change_price: -0.00051711,
|
|
// ask_bid: "ASK",
|
|
// sequential_id: 15428949259430000 }
|
|
//
|
|
// fetchOrder trades
|
|
//
|
|
// {
|
|
// "market": "KRW-BTC",
|
|
// "uuid": "78162304-1a4d-4524-b9e6-c9a9e14d76c3",
|
|
// "price": "101000.0",
|
|
// "volume": "0.77368323",
|
|
// "funds": "78142.00623",
|
|
// "ask_fee": "117.213009345",
|
|
// "bid_fee": "117.213009345",
|
|
// "created_at": "2018-04-05T14:09:15+09:00",
|
|
// "side": "bid",
|
|
// }
|
|
//
|
|
const id = this.safeString2 (trade, 'sequential_id', 'uuid');
|
|
const orderId = undefined;
|
|
let timestamp = this.safeInteger (trade, 'timestamp');
|
|
if (timestamp === undefined) {
|
|
timestamp = this.parse8601 (this.safeString (trade, 'created_at'));
|
|
}
|
|
let side = undefined;
|
|
const askOrBid = this.safeStringLower2 (trade, 'ask_bid', 'side');
|
|
if (askOrBid === 'ask') {
|
|
side = 'sell';
|
|
} else if (askOrBid === 'bid') {
|
|
side = 'buy';
|
|
}
|
|
let cost = this.safeFloat (trade, 'funds');
|
|
const price = this.safeFloat2 (trade, 'trade_price', 'price');
|
|
const amount = this.safeFloat2 (trade, 'trade_volume', 'volume');
|
|
if (cost === undefined) {
|
|
if (amount !== undefined) {
|
|
if (price !== undefined) {
|
|
cost = price * amount;
|
|
}
|
|
}
|
|
}
|
|
const marketId = this.safeString2 (trade, 'market', 'code');
|
|
market = this.safeValue (this.markets_by_id, marketId, market);
|
|
let fee = undefined;
|
|
let feeCurrency = undefined;
|
|
let symbol = undefined;
|
|
if (market !== undefined) {
|
|
symbol = market['symbol'];
|
|
feeCurrency = market['quote'];
|
|
} else {
|
|
const [ baseId, quoteId ] = marketId.split ('-');
|
|
const base = this.safeCurrencyCode (baseId);
|
|
const quote = this.safeCurrencyCode (quoteId);
|
|
symbol = base + '/' + quote;
|
|
feeCurrency = quote;
|
|
}
|
|
const feeCost = this.safeString (trade, askOrBid + '_fee');
|
|
if (feeCost !== undefined) {
|
|
fee = {
|
|
'currency': feeCurrency,
|
|
'cost': feeCost,
|
|
};
|
|
}
|
|
return {
|
|
'id': id,
|
|
'info': trade,
|
|
'order': orderId,
|
|
'timestamp': timestamp,
|
|
'datetime': this.iso8601 (timestamp),
|
|
'symbol': symbol,
|
|
'type': 'limit',
|
|
'side': side,
|
|
'takerOrMaker': undefined,
|
|
'price': price,
|
|
'amount': amount,
|
|
'cost': cost,
|
|
'fee': fee,
|
|
};
|
|
}
|
|
|
|
async fetchTrades (symbol, since = undefined, limit = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const market = this.market (symbol);
|
|
if (limit === undefined) {
|
|
limit = 200;
|
|
}
|
|
const request = {
|
|
'market': market['id'],
|
|
'count': limit,
|
|
};
|
|
const response = await this.publicGetTradesTicks (this.extend (request, params));
|
|
//
|
|
// [ { market: "BTC-ETH",
|
|
// trade_date_utc: "2018-11-22",
|
|
// trade_time_utc: "13:55:24",
|
|
// timestamp: 1542894924397,
|
|
// trade_price: 0.02914289,
|
|
// trade_volume: 0.20074397,
|
|
// prev_closing_price: 0.02966,
|
|
// change_price: -0.00051711,
|
|
// ask_bid: "ASK",
|
|
// sequential_id: 15428949259430000 },
|
|
// { market: "BTC-ETH",
|
|
// trade_date_utc: "2018-11-22",
|
|
// trade_time_utc: "13:03:10",
|
|
// timestamp: 1542891790123,
|
|
// trade_price: 0.02917,
|
|
// trade_volume: 7.392,
|
|
// prev_closing_price: 0.02966,
|
|
// change_price: -0.00049,
|
|
// ask_bid: "ASK",
|
|
// sequential_id: 15428917910540000 } ]
|
|
//
|
|
return this.parseTrades (response, market, since, limit);
|
|
}
|
|
|
|
parseOHLCV (ohlcv, market = undefined, timeframe = '1d', since = undefined, limit = undefined) {
|
|
//
|
|
// { market: "BTC-ETH",
|
|
// candle_date_time_utc: "2018-11-22T13:47:00",
|
|
// candle_date_time_kst: "2018-11-22T22:47:00",
|
|
// opening_price: 0.02915963,
|
|
// high_price: 0.02915963,
|
|
// low_price: 0.02915448,
|
|
// trade_price: 0.02915448,
|
|
// timestamp: 1542894473674,
|
|
// candle_acc_trade_price: 0.0981629437535248,
|
|
// candle_acc_trade_volume: 3.36693173,
|
|
// unit: 1 },
|
|
//
|
|
return [
|
|
this.parse8601 (this.safeString (ohlcv, 'candle_date_time_utc')),
|
|
this.safeFloat (ohlcv, 'opening_price'),
|
|
this.safeFloat (ohlcv, 'high_price'),
|
|
this.safeFloat (ohlcv, 'low_price'),
|
|
this.safeFloat (ohlcv, 'trade_price'),
|
|
this.safeFloat (ohlcv, 'candle_acc_trade_volume'), // base volume
|
|
];
|
|
}
|
|
|
|
async fetchOHLCV (symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const market = this.market (symbol);
|
|
const timeframePeriod = this.parseTimeframe (timeframe);
|
|
const timeframeValue = this.timeframes[timeframe];
|
|
if (limit === undefined) {
|
|
limit = 200;
|
|
}
|
|
const request = {
|
|
'market': market['id'],
|
|
'timeframe': timeframeValue,
|
|
'count': limit,
|
|
};
|
|
let method = 'publicGetCandlesTimeframe';
|
|
if (timeframeValue === 'minutes') {
|
|
const numMinutes = Math.round (timeframePeriod / 60);
|
|
request['unit'] = numMinutes;
|
|
method += 'Unit';
|
|
}
|
|
if (since !== undefined) {
|
|
// convert `since` to `to` value
|
|
request['to'] = this.iso8601 (this.sum (since, timeframePeriod * limit * 1000));
|
|
}
|
|
const response = await this[method] (this.extend (request, params));
|
|
//
|
|
// [ { market: "BTC-ETH",
|
|
// candle_date_time_utc: "2018-11-22T13:47:00",
|
|
// candle_date_time_kst: "2018-11-22T22:47:00",
|
|
// opening_price: 0.02915963,
|
|
// high_price: 0.02915963,
|
|
// low_price: 0.02915448,
|
|
// trade_price: 0.02915448,
|
|
// timestamp: 1542894473674,
|
|
// candle_acc_trade_price: 0.0981629437535248,
|
|
// candle_acc_trade_volume: 3.36693173,
|
|
// unit: 1 },
|
|
// { market: "BTC-ETH",
|
|
// candle_date_time_utc: "2018-11-22T10:06:00",
|
|
// candle_date_time_kst: "2018-11-22T19:06:00",
|
|
// opening_price: 0.0294,
|
|
// high_price: 0.02940882,
|
|
// low_price: 0.02934283,
|
|
// trade_price: 0.02937354,
|
|
// timestamp: 1542881219276,
|
|
// candle_acc_trade_price: 0.0762597110943884,
|
|
// candle_acc_trade_volume: 2.5949617,
|
|
// unit: 1 } ]
|
|
//
|
|
return this.parseOHLCVs (response, market, timeframe, since, limit);
|
|
}
|
|
|
|
async createOrder (symbol, type, side, amount, price = undefined, params = {}) {
|
|
if (type === 'market') {
|
|
// for market buy it requires the amount of quote currency to spend
|
|
if (side === 'buy') {
|
|
if (this.options['createMarketBuyOrderRequiresPrice']) {
|
|
if (price === undefined) {
|
|
throw new InvalidOrder (this.id + " createOrder() requires the price argument with market buy orders to calculate total order cost (amount to spend), where cost = amount * price. Supply a price argument to createOrder() call if you want the cost to be calculated for you from price and amount, or, alternatively, add .options['createMarketBuyOrderRequiresPrice'] = false to supply the cost in the amount argument (the exchange-specific behaviour)");
|
|
} else {
|
|
amount = amount * price;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let orderSide = undefined;
|
|
if (side === 'buy') {
|
|
orderSide = 'bid';
|
|
} else if (side === 'sell') {
|
|
orderSide = 'ask';
|
|
} else {
|
|
throw new InvalidOrder (this.id + ' createOrder allows buy or sell side only!');
|
|
}
|
|
await this.loadMarkets ();
|
|
const market = this.market (symbol);
|
|
const request = {
|
|
'market': market['id'],
|
|
'side': orderSide,
|
|
};
|
|
if (type === 'limit') {
|
|
request['volume'] = this.amountToPrecision (symbol, amount);
|
|
request['price'] = this.priceToPrecision (symbol, price);
|
|
request['ord_type'] = type;
|
|
} else if (type === 'market') {
|
|
if (side === 'buy') {
|
|
request['ord_type'] = 'price';
|
|
request['price'] = this.priceToPrecision (symbol, amount);
|
|
} else if (side === 'sell') {
|
|
request['ord_type'] = type;
|
|
request['volume'] = this.amountToPrecision (symbol, amount);
|
|
}
|
|
}
|
|
const response = await this.privatePostOrders (this.extend (request, params));
|
|
//
|
|
// {
|
|
// 'uuid': 'cdd92199-2897-4e14-9448-f923320408ad',
|
|
// 'side': 'bid',
|
|
// 'ord_type': 'limit',
|
|
// 'price': '100.0',
|
|
// 'avg_price': '0.0',
|
|
// 'state': 'wait',
|
|
// 'market': 'KRW-BTC',
|
|
// 'created_at': '2018-04-10T15:42:23+09:00',
|
|
// 'volume': '0.01',
|
|
// 'remaining_volume': '0.01',
|
|
// 'reserved_fee': '0.0015',
|
|
// 'remaining_fee': '0.0015',
|
|
// 'paid_fee': '0.0',
|
|
// 'locked': '1.0015',
|
|
// 'executed_volume': '0.0',
|
|
// 'trades_count': 0
|
|
// }
|
|
//
|
|
return this.parseOrder (response);
|
|
}
|
|
|
|
async cancelOrder (id, symbol = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const request = {
|
|
'uuid': id,
|
|
};
|
|
const response = await this.privateDeleteOrder (this.extend (request, params));
|
|
//
|
|
// {
|
|
// "uuid": "cdd92199-2897-4e14-9448-f923320408ad",
|
|
// "side": "bid",
|
|
// "ord_type": "limit",
|
|
// "price": "100.0",
|
|
// "state": "wait",
|
|
// "market": "KRW-BTC",
|
|
// "created_at": "2018-04-10T15:42:23+09:00",
|
|
// "volume": "0.01",
|
|
// "remaining_volume": "0.01",
|
|
// "reserved_fee": "0.0015",
|
|
// "remaining_fee": "0.0015",
|
|
// "paid_fee": "0.0",
|
|
// "locked": "1.0015",
|
|
// "executed_volume": "0.0",
|
|
// "trades_count": 0
|
|
// }
|
|
//
|
|
return this.parseOrder (response);
|
|
}
|
|
|
|
async fetchDeposits (code = undefined, since = undefined, limit = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const request = {
|
|
// 'page': 1,
|
|
// 'order_by': 'asc', // 'desc'
|
|
};
|
|
let currency = undefined;
|
|
if (code !== undefined) {
|
|
currency = this.currency (code);
|
|
request['currency'] = currency['id'];
|
|
}
|
|
if (limit !== undefined) {
|
|
request['limit'] = limit; // default is 100
|
|
}
|
|
const response = await this.privateGetDeposits (this.extend (request, params));
|
|
//
|
|
// [
|
|
// {
|
|
// "type": "deposit",
|
|
// "uuid": "94332e99-3a87-4a35-ad98-28b0c969f830",
|
|
// "currency": "KRW",
|
|
// "txid": "9e37c537-6849-4c8b-a134-57313f5dfc5a",
|
|
// "state": "ACCEPTED",
|
|
// "created_at": "2017-12-08T15:38:02+09:00",
|
|
// "done_at": "2017-12-08T15:38:02+09:00",
|
|
// "amount": "100000.0",
|
|
// "fee": "0.0"
|
|
// },
|
|
// ...,
|
|
// ]
|
|
//
|
|
return this.parseTransactions (response, currency, since, limit);
|
|
}
|
|
|
|
async fetchWithdrawals (code = undefined, since = undefined, limit = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const request = {
|
|
// 'state': 'submitting', // 'submitted', 'almost_accepted', 'rejected', 'accepted', 'processing', 'done', 'canceled'
|
|
};
|
|
let currency = undefined;
|
|
if (code !== undefined) {
|
|
currency = this.currency (code);
|
|
request['currency'] = currency['id'];
|
|
}
|
|
if (limit !== undefined) {
|
|
request['limit'] = limit; // default is 100
|
|
}
|
|
const response = await this.privateGetWithdraws (this.extend (request, params));
|
|
//
|
|
// [
|
|
// {
|
|
// "type": "withdraw",
|
|
// "uuid": "9f432943-54e0-40b7-825f-b6fec8b42b79",
|
|
// "currency": "BTC",
|
|
// "txid": null,
|
|
// "state": "processing",
|
|
// "created_at": "2018-04-13T11:24:01+09:00",
|
|
// "done_at": null,
|
|
// "amount": "0.01",
|
|
// "fee": "0.0",
|
|
// "krw_amount": "80420.0"
|
|
// },
|
|
// ...,
|
|
// ]
|
|
//
|
|
return this.parseTransactions (response, currency, since, limit);
|
|
}
|
|
|
|
parseTransactionStatus (status) {
|
|
const statuses = {
|
|
'ACCEPTED': 'ok', // deposits
|
|
// withdrawals:
|
|
'submitting': 'pending', // 처리 중
|
|
'submitted': 'pending', // 처리 완료
|
|
'almost_accepted': 'pending', // 출금대기중
|
|
'rejected': 'failed', // 거부
|
|
'accepted': 'pending', // 승인됨
|
|
'processing': 'pending', // 처리 중
|
|
'done': 'ok', // 완료
|
|
'canceled': 'canceled', // 취소됨
|
|
};
|
|
return this.safeString (statuses, status, status);
|
|
}
|
|
|
|
parseTransaction (transaction, currency = undefined) {
|
|
//
|
|
// fetchDeposits
|
|
//
|
|
// {
|
|
// "type": "deposit",
|
|
// "uuid": "94332e99-3a87-4a35-ad98-28b0c969f830",
|
|
// "currency": "KRW",
|
|
// "txid": "9e37c537-6849-4c8b-a134-57313f5dfc5a",
|
|
// "state": "ACCEPTED",
|
|
// "created_at": "2017-12-08T15:38:02+09:00",
|
|
// "done_at": "2017-12-08T15:38:02+09:00",
|
|
// "amount": "100000.0",
|
|
// "fee": "0.0"
|
|
// }
|
|
//
|
|
// fetchWithdrawals
|
|
//
|
|
// {
|
|
// "type": "withdraw",
|
|
// "uuid": "9f432943-54e0-40b7-825f-b6fec8b42b79",
|
|
// "currency": "BTC",
|
|
// "txid": "cd81e9b45df8da29f936836e58c907a106057e454a45767a7b06fcb19b966bba",
|
|
// "state": "processing",
|
|
// "created_at": "2018-04-13T11:24:01+09:00",
|
|
// "done_at": null,
|
|
// "amount": "0.01",
|
|
// "fee": "0.0",
|
|
// "krw_amount": "80420.0"
|
|
// }
|
|
//
|
|
const id = this.safeString (transaction, 'uuid');
|
|
const amount = this.safeFloat (transaction, 'amount');
|
|
const address = undefined; // not present in the data structure received from the exchange
|
|
const tag = undefined; // not present in the data structure received from the exchange
|
|
const txid = this.safeString (transaction, 'txid');
|
|
const updated = this.parse8601 (this.safeString (transaction, 'done_at'));
|
|
const timestamp = this.parse8601 (this.safeString (transaction, 'created_at', updated));
|
|
let type = this.safeString (transaction, 'type');
|
|
if (type === 'withdraw') {
|
|
type = 'withdrawal';
|
|
}
|
|
const currencyId = this.safeString (transaction, 'currency');
|
|
const code = this.safeCurrencyCode (currencyId);
|
|
const status = this.parseTransactionStatus (this.safeString (transaction, 'state'));
|
|
const feeCost = this.safeFloat (transaction, 'fee');
|
|
return {
|
|
'info': transaction,
|
|
'id': id,
|
|
'currency': code,
|
|
'amount': amount,
|
|
'address': address,
|
|
'tag': tag,
|
|
'status': status,
|
|
'type': type,
|
|
'updated': updated,
|
|
'txid': txid,
|
|
'timestamp': timestamp,
|
|
'datetime': this.iso8601 (timestamp),
|
|
'fee': {
|
|
'currency': code,
|
|
'cost': feeCost,
|
|
},
|
|
};
|
|
}
|
|
|
|
parseOrderStatus (status) {
|
|
const statuses = {
|
|
'wait': 'open',
|
|
'done': 'closed',
|
|
'cancel': 'canceled',
|
|
};
|
|
return this.safeString (statuses, status, status);
|
|
}
|
|
|
|
parseOrder (order, market = undefined) {
|
|
//
|
|
// {
|
|
// "uuid": "a08f09b1-1718-42e2-9358-f0e5e083d3ee",
|
|
// "side": "bid",
|
|
// "ord_type": "limit",
|
|
// "price": "17417000.0",
|
|
// "state": "done",
|
|
// "market": "KRW-BTC",
|
|
// "created_at": "2018-04-05T14:09:14+09:00",
|
|
// "volume": "1.0",
|
|
// "remaining_volume": "0.0",
|
|
// "reserved_fee": "26125.5",
|
|
// "remaining_fee": "25974.0",
|
|
// "paid_fee": "151.5",
|
|
// "locked": "17341974.0",
|
|
// "executed_volume": "1.0",
|
|
// "trades_count": 2,
|
|
// "trades": [
|
|
// {
|
|
// "market": "KRW-BTC",
|
|
// "uuid": "78162304-1a4d-4524-b9e6-c9a9e14d76c3",
|
|
// "price": "101000.0",
|
|
// "volume": "0.77368323",
|
|
// "funds": "78142.00623",
|
|
// "ask_fee": "117.213009345",
|
|
// "bid_fee": "117.213009345",
|
|
// "created_at": "2018-04-05T14:09:15+09:00",
|
|
// "side": "bid",
|
|
// },
|
|
// {
|
|
// "market": "KRW-BTC",
|
|
// "uuid": "f73da467-c42f-407d-92fa-e10d86450a20",
|
|
// "price": "101000.0",
|
|
// "volume": "0.22631677",
|
|
// "funds": "22857.99377",
|
|
// "ask_fee": "34.286990655", // missing in market orders
|
|
// "bid_fee": "34.286990655", // missing in market orders
|
|
// "created_at": "2018-04-05T14:09:15+09:00", // missing in market orders
|
|
// "side": "bid",
|
|
// },
|
|
// ],
|
|
// }
|
|
//
|
|
const id = this.safeString (order, 'uuid');
|
|
let side = this.safeString (order, 'side');
|
|
if (side === 'bid') {
|
|
side = 'buy';
|
|
} else {
|
|
side = 'sell';
|
|
}
|
|
let type = this.safeString (order, 'ord_type');
|
|
const timestamp = this.parse8601 (this.safeString (order, 'created_at'));
|
|
const status = this.parseOrderStatus (this.safeString (order, 'state'));
|
|
let lastTradeTimestamp = undefined;
|
|
let price = this.safeFloat (order, 'price');
|
|
const amount = this.safeFloat (order, 'volume');
|
|
const remaining = this.safeFloat (order, 'remaining_volume');
|
|
const filled = this.safeFloat (order, 'executed_volume');
|
|
let cost = undefined;
|
|
if (type === 'price') {
|
|
type = 'market';
|
|
cost = price;
|
|
price = undefined;
|
|
}
|
|
let average = undefined;
|
|
let fee = undefined;
|
|
let feeCost = this.safeFloat (order, 'paid_fee');
|
|
let feeCurrency = undefined;
|
|
const marketId = this.safeString (order, 'market');
|
|
market = this.safeValue (this.markets_by_id, marketId);
|
|
let symbol = undefined;
|
|
if (market !== undefined) {
|
|
symbol = market['symbol'];
|
|
feeCurrency = market['quote'];
|
|
} else {
|
|
const [ baseId, quoteId ] = marketId.split ('-');
|
|
const base = this.safeCurrencyCode (baseId);
|
|
const quote = this.safeCurrencyCode (quoteId);
|
|
symbol = base + '/' + quote;
|
|
feeCurrency = quote;
|
|
}
|
|
let trades = this.safeValue (order, 'trades', []);
|
|
trades = this.parseTrades (trades, market, undefined, undefined, { 'order': id });
|
|
const numTrades = trades.length;
|
|
if (numTrades > 0) {
|
|
// the timestamp in fetchOrder trades is missing
|
|
lastTradeTimestamp = trades[numTrades - 1]['timestamp'];
|
|
let getFeesFromTrades = false;
|
|
if (feeCost === undefined) {
|
|
getFeesFromTrades = true;
|
|
feeCost = 0;
|
|
}
|
|
cost = 0;
|
|
for (let i = 0; i < numTrades; i++) {
|
|
const trade = trades[i];
|
|
cost = this.sum (cost, trade['cost']);
|
|
if (getFeesFromTrades) {
|
|
const tradeFee = this.safeValue (trades[i], 'fee', {});
|
|
const tradeFeeCost = this.safeFloat (tradeFee, 'cost');
|
|
if (tradeFeeCost !== undefined) {
|
|
feeCost = this.sum (feeCost, tradeFeeCost);
|
|
}
|
|
}
|
|
}
|
|
average = cost / filled;
|
|
}
|
|
if (feeCost !== undefined) {
|
|
fee = {
|
|
'currency': feeCurrency,
|
|
'cost': feeCost,
|
|
};
|
|
}
|
|
const result = {
|
|
'info': order,
|
|
'id': id,
|
|
'clientOrderId': undefined,
|
|
'timestamp': timestamp,
|
|
'datetime': this.iso8601 (timestamp),
|
|
'lastTradeTimestamp': lastTradeTimestamp,
|
|
'symbol': symbol,
|
|
'type': type,
|
|
'side': side,
|
|
'price': price,
|
|
'cost': cost,
|
|
'average': average,
|
|
'amount': amount,
|
|
'filled': filled,
|
|
'remaining': remaining,
|
|
'status': status,
|
|
'fee': fee,
|
|
'trades': trades,
|
|
};
|
|
return result;
|
|
}
|
|
|
|
async fetchOrdersByState (state, symbol = undefined, since = undefined, limit = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const request = {
|
|
// 'market': this.marketId (symbol),
|
|
'state': state,
|
|
// 'page': 1,
|
|
// 'order_by': 'asc',
|
|
};
|
|
let market = undefined;
|
|
if (symbol !== undefined) {
|
|
market = this.market (symbol);
|
|
request['market'] = market['id'];
|
|
}
|
|
const response = await this.privateGetOrders (this.extend (request, params));
|
|
//
|
|
// [
|
|
// {
|
|
// "uuid": "a08f09b1-1718-42e2-9358-f0e5e083d3ee",
|
|
// "side": "bid",
|
|
// "ord_type": "limit",
|
|
// "price": "17417000.0",
|
|
// "state": "done",
|
|
// "market": "KRW-BTC",
|
|
// "created_at": "2018-04-05T14:09:14+09:00",
|
|
// "volume": "1.0",
|
|
// "remaining_volume": "0.0",
|
|
// "reserved_fee": "26125.5",
|
|
// "remaining_fee": "25974.0",
|
|
// "paid_fee": "151.5",
|
|
// "locked": "17341974.0",
|
|
// "executed_volume": "1.0",
|
|
// "trades_count":2
|
|
// },
|
|
// ]
|
|
//
|
|
return this.parseOrders (response, market, since, limit);
|
|
}
|
|
|
|
async fetchOpenOrders (symbol = undefined, since = undefined, limit = undefined, params = {}) {
|
|
return await this.fetchOrdersByState ('wait', symbol, since, limit, params);
|
|
}
|
|
|
|
async fetchClosedOrders (symbol = undefined, since = undefined, limit = undefined, params = {}) {
|
|
return await this.fetchOrdersByState ('done', symbol, since, limit, params);
|
|
}
|
|
|
|
async fetchCanceledOrders (symbol = undefined, since = undefined, limit = undefined, params = {}) {
|
|
return await this.fetchOrdersByState ('cancel', symbol, since, limit, params);
|
|
}
|
|
|
|
async fetchOrder (id, symbol = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const request = {
|
|
'uuid': id,
|
|
};
|
|
const response = await this.privateGetOrder (this.extend (request, params));
|
|
//
|
|
// {
|
|
// "uuid": "a08f09b1-1718-42e2-9358-f0e5e083d3ee",
|
|
// "side": "bid",
|
|
// "ord_type": "limit",
|
|
// "price": "17417000.0",
|
|
// "state": "done",
|
|
// "market": "KRW-BTC",
|
|
// "created_at": "2018-04-05T14:09:14+09:00",
|
|
// "volume": "1.0",
|
|
// "remaining_volume": "0.0",
|
|
// "reserved_fee": "26125.5",
|
|
// "remaining_fee": "25974.0",
|
|
// "paid_fee": "151.5",
|
|
// "locked": "17341974.0",
|
|
// "executed_volume": "1.0",
|
|
// "trades_count": 2,
|
|
// "trades": [
|
|
// {
|
|
// "market": "KRW-BTC",
|
|
// "uuid": "78162304-1a4d-4524-b9e6-c9a9e14d76c3",
|
|
// "price": "101000.0",
|
|
// "volume": "0.77368323",
|
|
// "funds": "78142.00623",
|
|
// "ask_fee": "117.213009345",
|
|
// "bid_fee": "117.213009345",
|
|
// "created_at": "2018-04-05T14:09:15+09:00",
|
|
// "side": "bid"
|
|
// },
|
|
// {
|
|
// "market": "KRW-BTC",
|
|
// "uuid": "f73da467-c42f-407d-92fa-e10d86450a20",
|
|
// "price": "101000.0",
|
|
// "volume": "0.22631677",
|
|
// "funds": "22857.99377",
|
|
// "ask_fee": "34.286990655",
|
|
// "bid_fee": "34.286990655",
|
|
// "created_at": "2018-04-05T14:09:15+09:00",
|
|
// "side": "bid"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
return this.parseOrder (response);
|
|
}
|
|
|
|
parseDepositAddresses (addresses) {
|
|
const result = [];
|
|
for (let i = 0; i < addresses.length; i++) {
|
|
result.push (this.parseDepositAddress (addresses[i]));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
async fetchDepositAddresses (codes = undefined, params = {}) {
|
|
await this.loadMarkets ();
|
|
const response = await this.privateGetDepositsCoinAddresses (params);
|
|
//
|
|
// [
|
|
// {
|
|
// "currency": "BTC",
|
|
// "deposit_address": "3EusRwybuZUhVDeHL7gh3HSLmbhLcy7NqD",
|
|
// "secondary_address": null
|
|
// },
|
|
// {
|
|
// "currency": "ETH",
|
|
// "deposit_address": "0x0d73e0a482b8cf568976d2e8688f4a899d29301c",
|
|
// "secondary_address": null
|
|
// },
|
|
// {
|
|
// "currency": "XRP",
|
|
// "deposit_address": "rN9qNpgnBaZwqCg8CvUZRPqCcPPY7wfWep",
|
|
// "secondary_address": "3057887915"
|
|
// }
|
|
// ]
|
|
//
|
|
return this.parseDepositAddresses (response);
|
|
}
|
|
|
|
parseDepositAddress (depositAddress, currency = undefined) {
|
|
//
|
|
// {
|
|
// "currency": "BTC",
|
|
// "deposit_address": "3EusRwybuZUhVDeHL7gh3HSLmbhLcy7NqD",
|
|
// "secondary_address": null
|
|
// }
|
|
//
|
|
const address = this.safeString (depositAddress, 'deposit_address');
|
|
const tag = this.safeString (depositAddress, 'secondary_address');
|
|
const currencyId = this.safeString (depositAddress, 'currency');
|
|
const code = this.safeCurrencyCode (currencyId);
|
|
this.checkAddress (address);
|
|
return {
|
|
'currency': code,
|
|
'address': address,
|
|
'tag': tag,
|
|
'info': depositAddress,
|
|
};
|
|
}
|
|
|
|
async fetchDepositAddress (code, params = {}) {
|
|
await this.loadMarkets ();
|
|
const currency = this.currency (code);
|
|
const response = await this.privateGetDepositsCoinAddress (this.extend ({
|
|
'currency': currency['id'],
|
|
}, params));
|
|
//
|
|
// {
|
|
// "currency": "BTC",
|
|
// "deposit_address": "3EusRwybuZUhVDeHL7gh3HSLmbhLcy7NqD",
|
|
// "secondary_address": null
|
|
// }
|
|
//
|
|
return this.parseDepositAddress (response);
|
|
}
|
|
|
|
async createDepositAddress (code, params = {}) {
|
|
await this.loadMarkets ();
|
|
const currency = this.currency (code);
|
|
const request = {
|
|
'currency': currency['id'],
|
|
};
|
|
// https://github.com/ccxt/ccxt/issues/6452
|
|
const response = await this.privatePostDepositsGenerateCoinAddress (this.extend (request, params));
|
|
//
|
|
// https://docs.upbit.com/v1.0/reference#%EC%9E%85%EA%B8%88-%EC%A3%BC%EC%86%8C-%EC%83%9D%EC%84%B1-%EC%9A%94%EC%B2%AD
|
|
// can be any of the two responses:
|
|
//
|
|
// {
|
|
// "success" : true,
|
|
// "message" : "Creating BTC deposit address."
|
|
// }
|
|
//
|
|
// {
|
|
// "currency": "BTC",
|
|
// "deposit_address": "3EusRwybuZUhVDeHL7gh3HSLmbhLcy7NqD",
|
|
// "secondary_address": null
|
|
// }
|
|
//
|
|
const message = this.safeString (response, 'message');
|
|
if (message !== undefined) {
|
|
throw new AddressPending (this.id + ' is generating ' + code + ' deposit address, call fetchDepositAddress or createDepositAddress one more time later to retrieve the generated address');
|
|
}
|
|
return this.parseDepositAddress (response);
|
|
}
|
|
|
|
async withdraw (code, amount, address, tag = undefined, params = {}) {
|
|
this.checkAddress (address);
|
|
await this.loadMarkets ();
|
|
const currency = this.currency (code);
|
|
const request = {
|
|
'amount': amount,
|
|
};
|
|
let method = 'privatePostWithdraws';
|
|
if (code !== 'KRW') {
|
|
method += 'Coin';
|
|
request['currency'] = currency['id'];
|
|
request['address'] = address;
|
|
if (tag !== undefined) {
|
|
request['secondary_address'] = tag;
|
|
}
|
|
} else {
|
|
method += 'Krw';
|
|
}
|
|
const response = await this[method] (this.extend (request, params));
|
|
//
|
|
// {
|
|
// "type": "withdraw",
|
|
// "uuid": "9f432943-54e0-40b7-825f-b6fec8b42b79",
|
|
// "currency": "BTC",
|
|
// "txid": "ebe6937b-130e-4066-8ac6-4b0e67f28adc",
|
|
// "state": "processing",
|
|
// "created_at": "2018-04-13T11:24:01+09:00",
|
|
// "done_at": null,
|
|
// "amount": "0.01",
|
|
// "fee": "0.0",
|
|
// "krw_amount": "80420.0"
|
|
// }
|
|
//
|
|
return this.parseTransaction (response);
|
|
}
|
|
|
|
nonce () {
|
|
return this.milliseconds ();
|
|
}
|
|
|
|
sign (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
|
|
let url = this.implodeParams (this.urls['api'][api], {
|
|
'hostname': this.hostname,
|
|
});
|
|
url += '/' + this.version + '/' + this.implodeParams (path, params);
|
|
const query = this.omit (params, this.extractParams (path));
|
|
if (method !== 'POST') {
|
|
if (Object.keys (query).length) {
|
|
url += '?' + this.urlencode (query);
|
|
}
|
|
}
|
|
if (api === 'private') {
|
|
this.checkRequiredCredentials ();
|
|
const nonce = this.nonce ();
|
|
const request = {
|
|
'access_key': this.apiKey,
|
|
'nonce': nonce,
|
|
};
|
|
if (Object.keys (query).length) {
|
|
const auth = this.urlencode (query);
|
|
const hash = this.hash (this.encode (auth), 'sha512');
|
|
request['query_hash'] = hash;
|
|
request['query_hash_alg'] = 'SHA512';
|
|
}
|
|
const jwt = this.jwt (request, this.encode (this.secret));
|
|
headers = {
|
|
'Authorization': 'Bearer ' + jwt,
|
|
};
|
|
if ((method !== 'GET') && (method !== 'DELETE')) {
|
|
body = this.json (params);
|
|
headers['Content-Type'] = 'application/json';
|
|
}
|
|
}
|
|
return { 'url': url, 'method': method, 'body': body, 'headers': headers };
|
|
}
|
|
|
|
handleErrors (httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody) {
|
|
if (response === undefined) {
|
|
return; // fallback to default error handler
|
|
}
|
|
//
|
|
// { 'error': { 'message': "Missing request parameter error. Check the required parameters!", 'name': 400 } },
|
|
// { 'error': { 'message': "side is missing, side does not have a valid value", 'name': "validation_error" } },
|
|
// { 'error': { 'message': "개인정보 제 3자 제공 동의가 필요합니다.", 'name': "thirdparty_agreement_required" } },
|
|
// { 'error': { 'message': "권한이 부족합니다.", 'name': "out_of_scope" } },
|
|
// { 'error': { 'message': "주문을 찾지 못했습니다.", 'name': "order_not_found" } },
|
|
// { 'error': { 'message': "주문가능한 금액(ETH)이 부족합니다.", 'name': "insufficient_funds_ask" } },
|
|
// { 'error': { 'message': "주문가능한 금액(BTC)이 부족합니다.", 'name': "insufficient_funds_bid" } },
|
|
// { 'error': { 'message': "잘못된 엑세스 키입니다.", 'name': "invalid_access_key" } },
|
|
// { 'error': { 'message': "Jwt 토큰 검증에 실패했습니다.", 'name': "jwt_verification" } }
|
|
//
|
|
const error = this.safeValue (response, 'error');
|
|
if (error !== undefined) {
|
|
const message = this.safeString (error, 'message');
|
|
const name = this.safeString (error, 'name');
|
|
const feedback = this.id + ' ' + body;
|
|
this.throwExactlyMatchedException (this.exceptions['exact'], message, feedback);
|
|
this.throwExactlyMatchedException (this.exceptions['exact'], name, feedback);
|
|
this.throwBroadlyMatchedException (this.exceptions['broad'], message, feedback);
|
|
this.throwBroadlyMatchedException (this.exceptions['broad'], name, feedback);
|
|
throw new ExchangeError (feedback); // unknown message
|
|
}
|
|
}
|
|
};
|