tokenlon-sdk
Version:
imToken Tokenlon API for node
671 lines • 37.6 kB
JavaScript
"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var _0x_js_1 = require("0x.js");
var constants_1 = require("0x.js/lib/src/utils/constants");
var format_1 = require("./utils/format");
var assert_1 = require("@0xproject/assert");
var assert_2 = require("./utils/assert");
var pair_1 = require("./utils/pair");
var dex_1 = require("./utils/dex");
var types_1 = require("./types");
var helper_1 = require("./utils/helper");
var Tokenlon = /** @class */ (function () {
function Tokenlon() {
}
Tokenlon.prototype.getPairs = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, Promise.resolve(this._pairs)];
});
});
};
Tokenlon.prototype.getPairInfo = function (baseQuote) {
return __awaiter(this, void 0, void 0, function () {
var pair;
return __generator(this, function (_a) {
pair = pair_1.getPairBySymbol(baseQuote, this._pairs);
return [2 /*return*/, Promise.resolve(pair)];
});
});
};
Tokenlon.prototype.getTokenInfo = function (tokenName) {
return __awaiter(this, void 0, void 0, function () {
var token;
return __generator(this, function (_a) {
token = pair_1.getTokenByName(tokenName, this._pairs);
return [2 /*return*/, Promise.resolve(token)];
});
});
};
Tokenlon.prototype.getOrderBook = function (params) {
return __awaiter(this, void 0, void 0, function () {
var pair, baseTokenAddress, quoteTokenAddress, wallet, orderBook;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
pair = pair_1.getPairBySymbol(params, this._pairs);
baseTokenAddress = pair.base.contractAddress;
quoteTokenAddress = pair.quote.contractAddress;
wallet = this._config.wallet;
return [4 /*yield*/, this.server.getOrderBook({ baseTokenAddress: baseTokenAddress, quoteTokenAddress: quoteTokenAddress })];
case 1:
orderBook = _a.sent();
return [2 /*return*/, {
asks: dex_1.translateOrderBookToSimple({
orderbookItems: orderBook.asks,
pair: pair,
wallet: wallet,
}).sort(function (a, b) { return a.price - b.price; }),
bids: dex_1.translateOrderBookToSimple({
orderbookItems: orderBook.bids,
pair: pair,
wallet: wallet,
}).sort(function (a, b) { return b.price - a.price; }),
}];
}
});
});
};
Tokenlon.prototype.getOrders = function (params) {
return __awaiter(this, void 0, void 0, function () {
var pair, baseTokenAddress, quoteTokenAddress, page, perpage, wallet, myOrders;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
pair = pair_1.getPairBySymbol(params, this._pairs);
baseTokenAddress = pair.base.contractAddress;
quoteTokenAddress = pair.quote.contractAddress;
page = params.page, perpage = params.perpage;
wallet = this._config.wallet;
return [4 /*yield*/, this.server.getOrders({
maker: wallet.address,
page: page,
perpage: perpage,
tokenPair: [baseTokenAddress, quoteTokenAddress],
})];
case 1:
myOrders = _a.sent();
return [2 /*return*/, dex_1.translateOrderBookToSimple({
orderbookItems: myOrders,
pair: pair,
})];
}
});
});
};
Tokenlon.prototype.getOrder = function (rawOrder) {
return __awaiter(this, void 0, void 0, function () {
var signedOrder, orderHash, pair, order, ob;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
signedOrder = JSON.parse(rawOrder);
orderHash = _0x_js_1.ZeroEx.getOrderHashHex(signedOrder);
pair = pair_1.getPairBySignedOrder(signedOrder, this._pairs);
return [4 /*yield*/, this.server.getOrder(orderHash)];
case 1:
order = _a.sent();
ob = dex_1.translateOrderBookToSimple({
orderbookItems: [order],
pair: pair,
})[0];
return [2 /*return*/, __assign({}, ob, { trades: order.trades })];
}
});
});
};
Tokenlon.prototype.getMakerTrades = function (params) {
return __awaiter(this, void 0, void 0, function () {
var pair, baseTokenAddress, quoteTokenAddress, timeRange, page, perpage, wallet, trades;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
pair = pair_1.getPairBySymbol(params, this._pairs);
baseTokenAddress = pair.base.contractAddress;
quoteTokenAddress = pair.quote.contractAddress;
timeRange = params.timeRange, page = params.page, perpage = params.perpage;
wallet = this._config.wallet;
return [4 /*yield*/, this.server.getMakerTrades({
page: page,
perpage: perpage,
timeRange: timeRange,
baseTokenAddress: baseTokenAddress,
quoteTokenAddress: quoteTokenAddress,
maker: wallet.address,
})];
case 1:
trades = _a.sent();
return [2 /*return*/, helper_1.convertTrades(trades)];
}
});
});
};
Tokenlon.prototype.getTakerTrades = function (params) {
return __awaiter(this, void 0, void 0, function () {
var pair, baseTokenAddress, quoteTokenAddress, timeRange, page, perpage, wallet, trades;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
pair = pair_1.getPairBySymbol(params, this._pairs);
baseTokenAddress = pair.base.contractAddress;
quoteTokenAddress = pair.quote.contractAddress;
timeRange = params.timeRange, page = params.page, perpage = params.perpage;
wallet = this._config.wallet;
return [4 /*yield*/, this.server.getTakerTrades({
page: page,
perpage: perpage,
timeRange: timeRange,
baseTokenAddress: baseTokenAddress,
quoteTokenAddress: quoteTokenAddress,
taker: wallet.address,
})];
case 1:
trades = _a.sent();
return [2 /*return*/, helper_1.convertTrades(trades)];
}
});
});
};
Tokenlon.prototype.placeOrder = function (params) {
return __awaiter(this, void 0, void 0, function () {
var pairs, pair, precision, quoteMinUnit, toBePlacedOrder;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
pairs = this._pairs;
assert_2.assert.isValidBaseQuote(params, pairs);
pair = pair_1.getPairBySymbol(params, pairs);
precision = pair.precision, quoteMinUnit = pair.quoteMinUnit;
assert_2.assert.isValidSimpleOrder(params, precision);
assert_2.assert.isValidAmount(params, quoteMinUnit);
return [4 /*yield*/, this.utils.getSignedOrderBySimpleOrderAsync(params)];
case 1:
toBePlacedOrder = _a.sent();
return [4 /*yield*/, this.server.placeOrder(toBePlacedOrder)];
case 2:
_a.sent();
return [2 /*return*/, {
isMaker: true,
side: params.side,
price: params.price,
amount: params.amount,
amountTotal: params.amount,
expirationUnixTimestampSec: params.expirationUnixTimestampSec || +toBePlacedOrder.expirationUnixTimestampSec,
// for key sequence to be same with server order rawOrder
rawOrder: JSON.stringify({
exchangeContractAddress: toBePlacedOrder.exchangeContractAddress,
maker: toBePlacedOrder.maker,
taker: toBePlacedOrder.taker,
makerTokenAddress: toBePlacedOrder.makerTokenAddress,
takerTokenAddress: toBePlacedOrder.takerTokenAddress,
feeRecipient: toBePlacedOrder.feeRecipient,
makerTokenAmount: toBePlacedOrder.makerTokenAmount,
takerTokenAmount: toBePlacedOrder.takerTokenAmount,
makerFee: toBePlacedOrder.makerFee,
takerFee: toBePlacedOrder.takerFee,
expirationUnixTimestampSec: toBePlacedOrder.expirationUnixTimestampSec,
salt: toBePlacedOrder.salt,
ecSignature: toBePlacedOrder.ecSignature,
}),
}];
}
});
});
};
Tokenlon.prototype.deposit = function (amount, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, wallet, zeroEx;
return __generator(this, function (_b) {
_a = this._config, wallet = _a.wallet, zeroEx = _a.zeroEx;
assert_1.assert.isNumber('amount', amount);
return [2 /*return*/, this.zeroExWrapper.etherToken.depositAsync(zeroEx.etherTokenContractAddress, format_1.fromUnitToDecimalBN(amount, 18), wallet.address, helper_1.convertTokenlonTxOptsTo0xOpts(opts))];
});
});
};
Tokenlon.prototype.withdraw = function (amount, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, wallet, zeroEx;
return __generator(this, function (_b) {
_a = this._config, wallet = _a.wallet, zeroEx = _a.zeroEx;
assert_1.assert.isNumber('amount', amount);
return [2 /*return*/, this.zeroExWrapper.etherToken.withdrawAsync(zeroEx.etherTokenContractAddress, format_1.fromUnitToDecimalBN(amount, 18), wallet.address, helper_1.convertTokenlonTxOptsTo0xOpts(opts))];
});
});
};
Tokenlon.prototype.getTokenBalance = function (tokenName, address) {
return __awaiter(this, void 0, void 0, function () {
var wallet, balanceDecimalBN, decimal, token;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (address) {
assert_1.assert.isETHAddressHex('address', address);
}
wallet = this._config.wallet;
if (!(tokenName === 'ETH')) return [3 /*break*/, 1];
balanceDecimalBN = this.web3Wrapper.eth.getBalance(address || wallet.address);
decimal = 18;
return [3 /*break*/, 3];
case 1:
token = pair_1.getTokenByName(tokenName, this._pairs);
return [4 /*yield*/, this.zeroExWrapper.token.getBalanceAsync(token.contractAddress, address || wallet.address)];
case 2:
balanceDecimalBN = _a.sent();
decimal = token.decimal;
_a.label = 3;
case 3: return [2 /*return*/, format_1.fromDecimalToUnit(balanceDecimalBN, decimal).toNumber()];
}
});
});
};
Tokenlon.prototype.getAllowance = function (tokenName, address) {
return __awaiter(this, void 0, void 0, function () {
var _a, wallet, zeroEx, token, allowanceBN;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (helper_1.helpCompareStr(tokenName, 'ETH'))
throw helper_1.newError(types_1.TokenlonError.EthDoseNotHaveApprovedMethod);
if (address) {
assert_1.assert.isETHAddressHex('address', address);
}
_a = this._config, wallet = _a.wallet, zeroEx = _a.zeroEx;
token = pair_1.getTokenByName(tokenName, this._pairs);
return [4 /*yield*/, this.zeroExWrapper.token.getAllowanceAsync(token.contractAddress, (address || wallet.address).toLowerCase(), zeroEx.tokenTransferProxyContractAddress)];
case 1:
allowanceBN = _b.sent();
return [2 /*return*/, format_1.fromDecimalToUnit(allowanceBN, token.decimal).toNumber()];
}
});
});
};
Tokenlon.prototype.setAllowance = function (tokenName, amount, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, wallet, zeroEx, token, amountDecimalBN;
return __generator(this, function (_b) {
if (helper_1.helpCompareStr(tokenName, 'ETH'))
throw helper_1.newError(types_1.TokenlonError.EthDoseNotHaveApprovedMethod);
_a = this._config, wallet = _a.wallet, zeroEx = _a.zeroEx;
assert_1.assert.isNumber('amount', amount);
token = pair_1.getTokenByName(tokenName, this._pairs);
amountDecimalBN = format_1.fromUnitToDecimalBN(amount, token.decimal);
return [2 /*return*/, this.zeroExWrapper.token.setAllowanceAsync(token.contractAddress, wallet.address, zeroEx.tokenTransferProxyContractAddress, amountDecimalBN, helper_1.convertTokenlonTxOptsTo0xOpts(opts))];
});
});
};
Tokenlon.prototype.setUnlimitedAllowance = function (tokenName, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, wallet, zeroEx, token;
return __generator(this, function (_b) {
if (helper_1.helpCompareStr(tokenName, 'ETH'))
throw helper_1.newError(types_1.TokenlonError.EthDoseNotHaveApprovedMethod);
_a = this._config, wallet = _a.wallet, zeroEx = _a.zeroEx;
token = pair_1.getTokenByName(tokenName, this._pairs);
return [2 /*return*/, this.zeroExWrapper.token.setAllowanceAsync(token.contractAddress, wallet.address, zeroEx.tokenTransferProxyContractAddress, constants_1.constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS, helper_1.convertTokenlonTxOptsTo0xOpts(opts))];
});
});
};
Tokenlon.prototype.fillOrderHelper = function (_a) {
var params = _a.params, fill = _a.fill, validate = _a.validate;
return __awaiter(this, void 0, void 0, function () {
var _b, wallet, onChainValidate, rawOrder, orderFillRequest, signedOrder, takerTokenFillAmount, txHash;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = this._config, wallet = _b.wallet, onChainValidate = _b.onChainValidate;
rawOrder = params.rawOrder;
orderFillRequest = dex_1.getOrderFillRequest(params, this._pairs);
signedOrder = orderFillRequest.signedOrder, takerTokenFillAmount = orderFillRequest.takerTokenFillAmount;
txHash = '';
if (!onChainValidate) return [3 /*break*/, 2];
return [4 /*yield*/, validate(signedOrder, takerTokenFillAmount, wallet.address)];
case 1:
_c.sent();
_c.label = 2;
case 2: return [4 /*yield*/, fill(signedOrder, takerTokenFillAmount, wallet.address)];
case 3:
txHash = _c.sent();
return [4 /*yield*/, this.server.fillOrder({
txHash: txHash,
order: JSON.parse(rawOrder),
amount: takerTokenFillAmount.toString(),
})];
case 4:
_c.sent();
return [2 /*return*/, txHash];
}
});
});
};
Tokenlon.prototype.fillOrder = function (params, opts) {
return __awaiter(this, void 0, void 0, function () {
var _this = this;
return __generator(this, function (_a) {
return [2 /*return*/, this.fillOrderHelper({
fill: function (signedOrder, takerTokenFillAmount, address) {
return _this.zeroExWrapper.exchange.fillOrderAsync(signedOrder, takerTokenFillAmount, false, address, helper_1.convertTokenlonTxOptsTo0xOpts(opts));
},
validate: function (signedOrder, takerTokenFillAmount, address) {
return _this.zeroExWrapper.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, takerTokenFillAmount, address);
},
params: params,
})];
});
});
};
Tokenlon.prototype.fillOrKillOrder = function (params, opts) {
return __awaiter(this, void 0, void 0, function () {
var _this = this;
return __generator(this, function (_a) {
return [2 /*return*/, this.fillOrderHelper({
fill: function (signedOrder, takerTokenFillAmount, address) {
return _this.zeroExWrapper.exchange.fillOrKillOrderAsync(signedOrder, takerTokenFillAmount, address, helper_1.convertTokenlonTxOptsTo0xOpts(opts));
},
validate: function (signedOrder, takerTokenFillAmount, address) {
return _this.zeroExWrapper.exchange.validateFillOrKillOrderThrowIfInvalidAsync(signedOrder, takerTokenFillAmount, address);
},
params: params,
})];
});
});
};
Tokenlon.prototype.batchFillOrdersHelper = function (_a) {
var batchFill = _a.batchFill, validate = _a.validate, orderFillReqs = _a.orderFillReqs;
return __awaiter(this, void 0, void 0, function () {
var _this = this;
var _b, wallet, onChainValidate, orderFillRequests, errors, errorMsg, _i, orderFillRequests_1, r, signedOrder, takerTokenFillAmount, e_1, txHash;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = this._config, wallet = _b.wallet, onChainValidate = _b.onChainValidate;
orderFillRequests = orderFillReqs.map(function (req) { return dex_1.getOrderFillRequest(req, _this._pairs); });
errors = [];
errorMsg = '';
if (!onChainValidate) return [3 /*break*/, 7];
_i = 0, orderFillRequests_1 = orderFillRequests;
_c.label = 1;
case 1:
if (!(_i < orderFillRequests_1.length)) return [3 /*break*/, 6];
r = orderFillRequests_1[_i];
signedOrder = r.signedOrder, takerTokenFillAmount = r.takerTokenFillAmount;
_c.label = 2;
case 2:
_c.trys.push([2, 4, , 5]);
return [4 /*yield*/, validate(signedOrder, takerTokenFillAmount, wallet.address)];
case 3:
_c.sent();
return [3 /*break*/, 5];
case 4:
e_1 = _c.sent();
errors.push(e_1 && e_1.message && e_1.message.toString());
return [3 /*break*/, 5];
case 5:
_i++;
return [3 /*break*/, 1];
case 6:
if (errors.length) {
errorMsg = "These orders are invalid " + JSON.stringify(errors);
}
_c.label = 7;
case 7:
if (!(errors.length !== orderFillRequests.length)) return [3 /*break*/, 10];
if (errorMsg) {
console.log(errorMsg);
}
return [4 /*yield*/, batchFill(orderFillRequests, wallet.address)];
case 8:
txHash = _c.sent();
return [4 /*yield*/, this.server.batchFillOrders({
txHash: txHash,
orders: orderFillReqs.map(function (_a, index) {
var rawOrder = _a.rawOrder;
return {
order: JSON.parse(rawOrder),
amount: orderFillRequests[index].takerTokenFillAmount.toString(),
};
}),
})];
case 9:
_c.sent();
return [2 /*return*/, txHash];
case 10:
console.log(errorMsg);
throw helper_1.newError(types_1.TokenlonError.InvalidOrders);
}
});
});
};
Tokenlon.prototype.batchFillOrders = function (orderFillReqs, opts) {
return __awaiter(this, void 0, void 0, function () {
var _this = this;
return __generator(this, function (_a) {
return [2 /*return*/, this.batchFillOrdersHelper({
batchFill: function (orderFillRequests, address) {
return _this.zeroExWrapper.exchange.batchFillOrdersAsync(orderFillRequests, false, address, helper_1.convertTokenlonTxOptsTo0xOpts(opts));
},
validate: function (signedOrder, takerTokenFillAmount, address) {
return _this.zeroExWrapper.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, takerTokenFillAmount, address);
},
orderFillReqs: orderFillReqs,
})];
});
});
};
Tokenlon.prototype.batchFillOrKill = function (orderFillReqs, opts) {
return __awaiter(this, void 0, void 0, function () {
var _this = this;
return __generator(this, function (_a) {
return [2 /*return*/, this.batchFillOrdersHelper({
batchFill: function (orderFillRequests, address) {
return _this.zeroExWrapper.exchange.batchFillOrKillAsync(orderFillRequests, address, helper_1.convertTokenlonTxOptsTo0xOpts(opts));
},
validate: function (signedOrder, takerTokenFillAmount, address) {
return _this.zeroExWrapper.exchange.validateFillOrKillOrderThrowIfInvalidAsync(signedOrder, takerTokenFillAmount, address);
},
orderFillReqs: orderFillReqs,
})];
});
});
};
Tokenlon.prototype.fillOrdersUpTo = function (params, opts) {
return __awaiter(this, void 0, void 0, function () {
var wallet, side, rawOrders, amount, signedOrders, isBuy, makerTaker, checkSamePair, pair, maker, taker, simpleOrders, takerTokenAmountBN, txHash;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
wallet = this._config.wallet;
side = params.side, rawOrders = params.rawOrders, amount = params.amount;
signedOrders = rawOrders.map(function (s) { return JSON.parse(s); });
isBuy = side === 'BUY';
makerTaker = {};
checkSamePair = signedOrders.every(function (o) {
var maker = makerTaker.maker, taker = makerTaker.taker;
var makerTokenAddress = o.makerTokenAddress, takerTokenAddress = o.takerTokenAddress;
if (maker && taker) {
return helper_1.helpCompareStr(maker, makerTokenAddress) && helper_1.helpCompareStr(taker, takerTokenAddress);
}
else if (!maker && !taker) {
makerTaker = { maker: makerTokenAddress, taker: takerTokenAddress };
return true;
}
else {
return false;
}
});
if (!checkSamePair) {
throw helper_1.newError(types_1.TokenlonError.OrdersMustBeSamePairAndSameSideWithFillOrdersUpTo);
}
pair = pair_1.getPairBySymbol(params, this._pairs);
maker = makerTaker.maker, taker = makerTaker.taker;
// to filled order is another side
if ((isBuy && (pair.base.contractAddress !== maker || pair.quote.contractAddress !== taker)) ||
(!isBuy && (pair.base.contractAddress !== taker || pair.quote.contractAddress !== maker))) {
throw helper_1.newError(types_1.TokenlonError.InvalidSideWithOrder);
}
signedOrders.sort(function (s1, s2) {
var simple1 = dex_1.getSimpleOrder({ order: s1, pair: pair });
var simple2 = dex_1.getSimpleOrder({ order: s2, pair: pair });
if (side === 'BUY') {
return simple1.price - simple2.price;
}
else {
return simple2.price - simple1.price;
}
});
simpleOrders = signedOrders.map(function (order) { return dex_1.getSimpleOrder({ order: order, pair: pair }); });
takerTokenAmountBN = dex_1.getFillTakerTokenAmountBNByUpToOrders(side, amount, simpleOrders, pair);
return [4 /*yield*/, this.zeroExWrapper.exchange.fillOrdersUpToAsync(signedOrders.map(dex_1.orderStringToBN), takerTokenAmountBN, false, wallet.address, helper_1.convertTokenlonTxOptsTo0xOpts(opts))];
case 1:
txHash = _a.sent();
return [4 /*yield*/, this.server.batchFillOrders({
txHash: txHash,
orders: signedOrders.map(function (signedOrder) {
return {
order: dex_1.orderBNToString(signedOrder),
// TODO use signedOrder takerTokenAmount temporality, the server dosen't solve this amount param
amount: signedOrder.takerTokenAmount.toString(),
};
}),
})];
case 2:
_a.sent();
return [2 /*return*/, txHash];
}
});
});
};
Tokenlon.prototype.cancelOrder = function (rawOrder, onChain, opts) {
return __awaiter(this, void 0, void 0, function () {
var onChainValidate, order, bnOrder, orderHash, txHash;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
onChainValidate = this._config.onChainValidate;
order = JSON.parse(rawOrder);
bnOrder = dex_1.orderStringToBN(order);
orderHash = _0x_js_1.ZeroEx.getOrderHashHex(bnOrder);
if (!onChain) return [3 /*break*/, 5];
if (!onChainValidate) return [3 /*break*/, 2];
return [4 /*yield*/, this.zeroExWrapper.exchange.validateCancelOrderThrowIfInvalidAsync(bnOrder, bnOrder.takerTokenAmount)];
case 1:
_a.sent();
_a.label = 2;
case 2: return [4 /*yield*/, this.zeroExWrapper.exchange.cancelOrderAsync(bnOrder, bnOrder.takerTokenAmount, helper_1.convertTokenlonTxOptsTo0xOpts(opts))];
case 3:
txHash = _a.sent();
return [4 /*yield*/, this.server.cancelOrdersWithHash([{ orderHash: orderHash, txHash: txHash }])];
case 4:
_a.sent();
return [2 /*return*/, txHash];
case 5: return [2 /*return*/, this.server.cancelOrders([orderHash])];
}
});
});
};
Tokenlon.prototype.batchCancelOrders = function (rawOrders, onChain, opts) {
return __awaiter(this, void 0, void 0, function () {
var onChainValidate, bnOrders, orderHashs, errors, errorMsg, _i, bnOrders_1, bnOrder, e_2, orderCancellationRequests, txHash_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
onChainValidate = this._config.onChainValidate;
bnOrders = rawOrders.map(function (rawOrder) { return dex_1.orderStringToBN(JSON.parse(rawOrder)); });
orderHashs = bnOrders.map(_0x_js_1.ZeroEx.getOrderHashHex);
if (!onChain) return [3 /*break*/, 12];
errors = [];
errorMsg = '';
_i = 0, bnOrders_1 = bnOrders;
_a.label = 1;
case 1:
if (!(_i < bnOrders_1.length)) return [3 /*break*/, 7];
bnOrder = bnOrders_1[_i];
_a.label = 2;
case 2:
_a.trys.push([2, 5, , 6]);
if (!onChainValidate) return [3 /*break*/, 4];
return [4 /*yield*/, this.zeroExWrapper.exchange.validateCancelOrderThrowIfInvalidAsync(bnOrder, bnOrder.takerTokenAmount)];
case 3:
_a.sent();
_a.label = 4;
case 4: return [3 /*break*/, 6];
case 5:
e_2 = _a.sent();
errors.push(e_2 && e_2.message && e_2.message.toString());
return [3 /*break*/, 6];
case 6:
_i++;
return [3 /*break*/, 1];
case 7:
if (errors.length) {
errorMsg = "These orders are invalid " + JSON.stringify(errors);
console.log(errorMsg);
}
if (!(errors.length !== bnOrders.length)) return [3 /*break*/, 10];
orderCancellationRequests = bnOrders.map(function (bnOrder) {
return {
order: bnOrder,
takerTokenCancelAmount: bnOrder.takerTokenAmount,
};
});
return [4 /*yield*/, this.zeroExWrapper.exchange.batchCancelOrdersAsync(orderCancellationRequests, helper_1.convertTokenlonTxOptsTo0xOpts(opts))];
case 8:
txHash_1 = _a.sent();
return [4 /*yield*/, this.server.cancelOrdersWithHash(orderHashs.map(function (orderHash) { return ({ orderHash: orderHash, txHash: txHash_1 }); }))];
case 9:
_a.sent();
return [2 /*return*/, txHash_1];
case 10: throw helper_1.newError(errorMsg);
case 11: return [3 /*break*/, 13];
case 12: return [2 /*return*/, this.server.cancelOrders(orderHashs)];
case 13: return [2 /*return*/];
}
});
});
};
return Tokenlon;
}());
exports.default = Tokenlon;
//# sourceMappingURL=tokenlon.js.map