@velora-dex/sdk
Version:
1,417 lines (1,397 loc) • 191 kB
JavaScript
import { SwapSide, ContractMethod } from '@paraswap/core';
export { ContractMethod, ContractMethodV5, ContractMethodV6, SwapSide } from '@paraswap/core';
import { assert } from 'ts-essentials';
function _assertThisInitialized(e) {
if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return e;
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
try {
var i = n[a](c),
u = i.value;
} catch (n) {
return void e(n);
}
i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
return function () {
var t = this,
e = arguments;
return new Promise(function (r, o) {
var a = n.apply(t, e);
function _next(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
}
function _throw(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
}
_next(void 0);
});
};
}
function _construct(t, e, r) {
if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
var o = [null];
o.push.apply(o, e);
var p = new (t.bind.apply(t, o))();
return r && _setPrototypeOf(p, r.prototype), p;
}
function _extends() {
return _extends = Object.assign ? Object.assign.bind() : function (n) {
for (var e = 1; e < arguments.length; e++) {
var t = arguments[e];
for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
}
return n;
}, _extends.apply(null, arguments);
}
function _getPrototypeOf(t) {
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
}, _getPrototypeOf(t);
}
function _inheritsLoose(t, o) {
t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
}
function _isNativeFunction(t) {
try {
return -1 !== Function.toString.call(t).indexOf("[native code]");
} catch (n) {
return "function" == typeof t;
}
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
} catch (t) {}
return (_isNativeReflectConstruct = function () {
return !!t;
})();
}
function _objectWithoutPropertiesLoose(r, e) {
if (null == r) return {};
var t = {};
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
if (e.includes(n)) continue;
t[n] = r[n];
}
return t;
}
function _regeneratorRuntime() {
_regeneratorRuntime = function () {
return e;
};
var t,
e = {},
r = Object.prototype,
n = r.hasOwnProperty,
o = Object.defineProperty || function (t, e, r) {
t[e] = r.value;
},
i = "function" == typeof Symbol ? Symbol : {},
a = i.iterator || "@@iterator",
c = i.asyncIterator || "@@asyncIterator",
u = i.toStringTag || "@@toStringTag";
function define(t, e, r) {
return Object.defineProperty(t, e, {
value: r,
enumerable: !0,
configurable: !0,
writable: !0
}), t[e];
}
try {
define({}, "");
} catch (t) {
define = function (t, e, r) {
return t[e] = r;
};
}
function wrap(t, e, r, n) {
var i = e && e.prototype instanceof Generator ? e : Generator,
a = Object.create(i.prototype),
c = new Context(n || []);
return o(a, "_invoke", {
value: makeInvokeMethod(t, r, c)
}), a;
}
function tryCatch(t, e, r) {
try {
return {
type: "normal",
arg: t.call(e, r)
};
} catch (t) {
return {
type: "throw",
arg: t
};
}
}
e.wrap = wrap;
var h = "suspendedStart",
l = "suspendedYield",
f = "executing",
s = "completed",
y = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var p = {};
define(p, a, function () {
return this;
});
var d = Object.getPrototypeOf,
v = d && d(d(values([])));
v && v !== r && n.call(v, a) && (p = v);
var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
function defineIteratorMethods(t) {
["next", "throw", "return"].forEach(function (e) {
define(t, e, function (t) {
return this._invoke(e, t);
});
});
}
function AsyncIterator(t, e) {
function invoke(r, o, i, a) {
var c = tryCatch(t[r], t, o);
if ("throw" !== c.type) {
var u = c.arg,
h = u.value;
return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
invoke("next", t, i, a);
}, function (t) {
invoke("throw", t, i, a);
}) : e.resolve(h).then(function (t) {
u.value = t, i(u);
}, function (t) {
return invoke("throw", t, i, a);
});
}
a(c.arg);
}
var r;
o(this, "_invoke", {
value: function (t, n) {
function callInvokeWithMethodAndArg() {
return new e(function (e, r) {
invoke(t, n, e, r);
});
}
return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
}
});
}
function makeInvokeMethod(e, r, n) {
var o = h;
return function (i, a) {
if (o === f) throw Error("Generator is already running");
if (o === s) {
if ("throw" === i) throw a;
return {
value: t,
done: !0
};
}
for (n.method = i, n.arg = a;;) {
var c = n.delegate;
if (c) {
var u = maybeInvokeDelegate(c, n);
if (u) {
if (u === y) continue;
return u;
}
}
if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
if (o === h) throw o = s, n.arg;
n.dispatchException(n.arg);
} else "return" === n.method && n.abrupt("return", n.arg);
o = f;
var p = tryCatch(e, r, n);
if ("normal" === p.type) {
if (o = n.done ? s : l, p.arg === y) continue;
return {
value: p.arg,
done: n.done
};
}
"throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
}
};
}
function maybeInvokeDelegate(e, r) {
var n = r.method,
o = e.iterator[n];
if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
var i = tryCatch(o, e.iterator, r.arg);
if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
var a = i.arg;
return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
}
function pushTryEntry(t) {
var e = {
tryLoc: t[0]
};
1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
}
function resetTryEntry(t) {
var e = t.completion || {};
e.type = "normal", delete e.arg, t.completion = e;
}
function Context(t) {
this.tryEntries = [{
tryLoc: "root"
}], t.forEach(pushTryEntry, this), this.reset(!0);
}
function values(e) {
if (e || "" === e) {
var r = e[a];
if (r) return r.call(e);
if ("function" == typeof e.next) return e;
if (!isNaN(e.length)) {
var o = -1,
i = function next() {
for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
return next.value = t, next.done = !0, next;
};
return i.next = i;
}
}
throw new TypeError(typeof e + " is not iterable");
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
value: GeneratorFunctionPrototype,
configurable: !0
}), o(GeneratorFunctionPrototype, "constructor", {
value: GeneratorFunction,
configurable: !0
}), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
var e = "function" == typeof t && t.constructor;
return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
}, e.mark = function (t) {
return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
}, e.awrap = function (t) {
return {
__await: t
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
return this;
}), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
void 0 === i && (i = Promise);
var a = new AsyncIterator(wrap(t, r, n, o), i);
return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
return t.done ? t.value : a.next();
});
}, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
return this;
}), define(g, "toString", function () {
return "[object Generator]";
}), e.keys = function (t) {
var e = Object(t),
r = [];
for (var n in e) r.push(n);
return r.reverse(), function next() {
for (; r.length;) {
var t = r.pop();
if (t in e) return next.value = t, next.done = !1, next;
}
return next.done = !0, next;
};
}, e.values = values, Context.prototype = {
constructor: Context,
reset: function (e) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
},
stop: function () {
this.done = !0;
var t = this.tryEntries[0].completion;
if ("throw" === t.type) throw t.arg;
return this.rval;
},
dispatchException: function (e) {
if (this.done) throw e;
var r = this;
function handle(n, o) {
return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
}
for (var o = this.tryEntries.length - 1; o >= 0; --o) {
var i = this.tryEntries[o],
a = i.completion;
if ("root" === i.tryLoc) return handle("end");
if (i.tryLoc <= this.prev) {
var c = n.call(i, "catchLoc"),
u = n.call(i, "finallyLoc");
if (c && u) {
if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
} else if (c) {
if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
} else {
if (!u) throw Error("try statement without catch or finally");
if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
}
}
}
},
abrupt: function (t, e) {
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
var o = this.tryEntries[r];
if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
var i = o;
break;
}
}
i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
var a = i ? i.completion : {};
return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
},
complete: function (t, e) {
if ("throw" === t.type) throw t.arg;
return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
},
finish: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
}
},
catch: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.tryLoc === t) {
var n = r.completion;
if ("throw" === n.type) {
var o = n.arg;
resetTryEntry(r);
}
return o;
}
}
throw Error("illegal catch attempt");
},
delegateYield: function (e, r, n) {
return this.delegate = {
iterator: values(e),
resultName: r,
nextLoc: n
}, "next" === this.method && (this.arg = t), y;
}
}, e;
}
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
return t.__proto__ = e, t;
}, _setPrototypeOf(t, e);
}
function _wrapNativeSuper(t) {
var r = "function" == typeof Map ? new Map() : void 0;
return _wrapNativeSuper = function (t) {
if (null === t || !_isNativeFunction(t)) return t;
if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
if (void 0 !== r) {
if (r.has(t)) return r.get(t);
r.set(t, Wrapper);
}
function Wrapper() {
return _construct(t, arguments, _getPrototypeOf(this).constructor);
}
return Wrapper.prototype = Object.create(t.prototype, {
constructor: {
value: Wrapper,
enumerable: !1,
writable: !0,
configurable: !0
}
}), _setPrototypeOf(Wrapper, t);
}, _wrapNativeSuper(t);
}
var API_URL = 'https://api.paraswap.io';
var DEFAULT_VERSION = '6.2';
var objectToFilledEntries = function objectToFilledEntries(object) {
return Object.entries(object)
// removes keys with undefined values
.filter(function (_ref) {
var value = _ref[1];
return value !== undefined;
}).map(function (_ref2) {
var key = _ref2[0],
value = _ref2[1];
return [key, String(value)];
});
};
var constructSearchString = function constructSearchString(queryOptions) {
var queryEntries = objectToFilledEntries(queryOptions);
var queryString = new URLSearchParams(queryEntries).toString();
// returns empty string or `?${string}`
return queryString && "?" + queryString;
};
var isFetcherError = function isFetcherError(error) {
return error instanceof FetcherError;
};
var FetcherError = /*#__PURE__*/function (_Error) {
function FetcherError(_ref3) {
var _this;
var code = _ref3.code,
request = _ref3.request,
response = _ref3.response,
isAxiosError = _ref3.isAxiosError,
message = _ref3.message;
_this = _Error.call(this) || this;
// Maintains proper stack trace for where our error was thrown (only available on V8)
_this.code = void 0;
_this.status = void 0;
_this.request = void 0;
_this.response = void 0;
_this.isAxiosError = false;
if (Error.captureStackTrace) {
Error.captureStackTrace(_this, FetcherError);
}
_this.name = _this.constructor.name;
_this.code = code;
_this.request = request;
_this.isAxiosError = isAxiosError;
// no response on AxiosError
if (!response) {
_this.message = message;
return _assertThisInitialized(_this);
}
_this.response = response;
var data = response.data,
status = response.status;
_this.status = status;
_this.message = isDataWithError(data) ? data.error : message;
_this.message = isDataWithError2(data) ? "" + data.errorType + (data.description ? ": " + data.description : '') : _this.message;
return _this;
}
_inheritsLoose(FetcherError, _Error);
return FetcherError;
}(/*#__PURE__*/_wrapNativeSuper(Error));
// to turn `object -> Record` for indexed variable access
function isObject(obj) {
return !!obj && typeof obj === 'object';
}
function isDataWithError(data) {
return isObject(data) && typeof data['error'] === 'string';
}
function isDataWithError2(data) {
return isObject(data) && typeof data['errorType'] === 'string';
}
// checks that array has at least one element
var isFilledArray = function isFilledArray(array) {
return array.length > 0;
};
function getRandomInt() {
return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
}
function runOnceAndCache(
// can pass `(...any[]) => any but null | undefined`
func) {
var result;
return function () {
var _result;
return (_result = result) != null ? _result : result = func.apply(void 0, arguments);
};
}
var constructGetSpender = function constructGetSpender(_ref) {
var _ref$apiURL = _ref.apiURL,
apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
_ref$version = _ref.version,
version = _ref$version === void 0 ? DEFAULT_VERSION : _ref$version,
chainId = _ref.chainId,
fetcher = _ref.fetcher;
var search = constructSearchString({
network: chainId,
version: version
});
var fetchURL = apiURL + "/adapters/contracts" + search;
var _getContracts = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(requestParams) {
var data;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 2:
data = _context.sent;
return _context.abrupt("return", data);
case 4:
case "end":
return _context.stop();
}
}, _callee);
}));
return function _getContracts(_x) {
return _ref2.apply(this, arguments);
};
}();
// cached for the same instance of `{getContracts, getSpender, getAugustusSwapper, getAugustusRFQ} = constructGetSpender()`
// so should persist across same apiUrl & network
var getContracts = runOnceAndCache(_getContracts);
var getSpender = /*#__PURE__*/function () {
var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(requestParams) {
var _yield$getContracts, TokenTransferProxy;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
_context2.next = 2;
return getContracts(requestParams);
case 2:
_yield$getContracts = _context2.sent;
TokenTransferProxy = _yield$getContracts.TokenTransferProxy;
return _context2.abrupt("return", TokenTransferProxy);
case 5:
case "end":
return _context2.stop();
}
}, _callee2);
}));
return function getSpender(_x2) {
return _ref3.apply(this, arguments);
};
}();
var getAugustusSwapper = /*#__PURE__*/function () {
var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(requestParams) {
var _yield$getContracts2, AugustusSwapper;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
_context3.next = 2;
return getContracts(requestParams);
case 2:
_yield$getContracts2 = _context3.sent;
AugustusSwapper = _yield$getContracts2.AugustusSwapper;
return _context3.abrupt("return", AugustusSwapper);
case 5:
case "end":
return _context3.stop();
}
}, _callee3);
}));
return function getAugustusSwapper(_x3) {
return _ref4.apply(this, arguments);
};
}();
var getAugustusRFQ = /*#__PURE__*/function () {
var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(requestParams) {
var _yield$getContracts3, AugustusRFQ;
return _regeneratorRuntime().wrap(function _callee4$(_context4) {
while (1) switch (_context4.prev = _context4.next) {
case 0:
_context4.next = 2;
return getContracts(requestParams);
case 2:
_yield$getContracts3 = _context4.sent;
AugustusRFQ = _yield$getContracts3.AugustusRFQ;
return _context4.abrupt("return", AugustusRFQ);
case 5:
case "end":
return _context4.stop();
}
}, _callee4);
}));
return function getAugustusRFQ(_x4) {
return _ref5.apply(this, arguments);
};
}();
return {
getContracts: getContracts,
getSpender: getSpender,
getAugustusSwapper: getAugustusSwapper,
getAugustusRFQ: getAugustusRFQ
};
};
// much smaller than the whole ERC20_ABI
var MinERC20Abi = [{
constant: false,
inputs: [{
name: '_spender',
type: 'address'
}, {
name: '_value',
type: 'uint256'
}],
name: 'approve',
outputs: [{
name: '',
type: 'bool'
}],
payable: false,
stateMutability: 'nonpayable',
type: 'function'
}];
function approveTokenMethodFactory(contractCaller, getSpender) {
return /*#__PURE__*/function () {
var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(amount, tokenAddress, overrides, requestParams) {
var spender, res;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
if (overrides === void 0) {
overrides = {};
}
_context.next = 3;
return getSpender(requestParams);
case 3:
spender = _context.sent;
_context.next = 6;
return contractCaller.transactCall({
address: tokenAddress,
abi: MinERC20Abi,
contractMethod: 'approve',
args: [spender, amount],
overrides: overrides
});
case 6:
res = _context.sent;
return _context.abrupt("return", res);
case 8:
case "end":
return _context.stop();
}
}, _callee);
}));
return function (_x, _x2, _x3, _x4) {
return _ref.apply(this, arguments);
};
}();
}
// returns whatever `contractCaller` returns
// to allow for better versatility
var constructApproveToken = function constructApproveToken(options) {
// getSpender is cached internally for the same instance of SDK
// so should persist across same apiUrl & network
var _constructGetSpender = constructGetSpender(options),
getSpender = _constructGetSpender.getSpender;
var approveToken = approveTokenMethodFactory(options.contractCaller, getSpender);
var approveTokenBulk = /*#__PURE__*/function () {
var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(amount, tokenAddresses, overrides, requestParams) {
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
return _context.abrupt("return", Promise.all(tokenAddresses.map(function (tokenAddress) {
return approveToken(amount, tokenAddress, overrides, requestParams);
})));
case 1:
case "end":
return _context.stop();
}
}, _callee);
}));
return function approveTokenBulk(_x, _x2, _x3, _x4) {
return _ref.apply(this, arguments);
};
}();
return {
approveToken: approveToken,
approveTokenBulk: approveTokenBulk
};
};
var _excluded$a = ["tokenType", "mainConnector", "connectors", "network"];
var constructToken = function constructToken(tokenProps) {
var _tokenProps$tokenType = tokenProps.tokenType,
tokenType = _tokenProps$tokenType === void 0 ? 'ERC20' : _tokenProps$tokenType,
_tokenProps$mainConne = tokenProps.mainConnector,
mainConnector = _tokenProps$mainConne === void 0 ? 'ETH' : _tokenProps$mainConne,
_tokenProps$connector = tokenProps.connectors,
connectorsInput = _tokenProps$connector === void 0 ? [] : _tokenProps$connector,
_tokenProps$network = tokenProps.network,
network = _tokenProps$network === void 0 ? 1 : _tokenProps$network,
rest = _objectWithoutPropertiesLoose(tokenProps, _excluded$a);
var connectors = connectorsInput.length > 0 ? connectorsInput : [mainConnector];
return _extends({
tokenType: tokenType,
connectors: connectors,
mainConnector: mainConnector,
network: network
}, rest);
};
var isAllowance = function isAllowance(arg) {
return 'allowance' in arg;
};
var NOT_FOUND_RESPONSE = {
message: 'Not Found'
};
var constructGetBalances = function constructGetBalances(_ref) {
var _ref$apiURL = _ref.apiURL,
apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
chainId = _ref.chainId,
fetcher = _ref.fetcher;
var tokensUrl = apiURL + "/users/tokens/" + chainId;
var getBalances = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(userAddress, requestParams) {
var fetchURL, data, tokens;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
fetchURL = tokensUrl + "/" + userAddress;
_context.next = 3;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 3:
data = _context.sent;
tokens = data.tokens.map(constructToken);
return _context.abrupt("return", tokens);
case 6:
case "end":
return _context.stop();
}
}, _callee);
}));
return function getBalances(_x, _x2) {
return _ref2.apply(this, arguments);
};
}();
var getBalance = /*#__PURE__*/function () {
var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(userAddress, tokenAddressOrSymbol, requestParams) {
var fetchURL, data;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
fetchURL = tokensUrl + "/" + userAddress + "/" + tokenAddressOrSymbol;
_context2.next = 3;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 3:
data = _context2.sent;
if (data.token) {
_context2.next = 6;
break;
}
return _context2.abrupt("return", NOT_FOUND_RESPONSE);
case 6:
return _context2.abrupt("return", constructToken(data.token));
case 7:
case "end":
return _context2.stop();
}
}, _callee2);
}));
return function getBalance(_x3, _x4, _x5) {
return _ref3.apply(this, arguments);
};
}();
var getAllowances = /*#__PURE__*/function () {
var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(userAddress, tokenAddresses, requestParams) {
var tokenAddressesLowercaseSet, balances, allowances;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
tokenAddressesLowercaseSet = new Set(tokenAddresses.map(function (address) {
return address.toLowerCase();
}));
_context3.next = 3;
return getBalances(userAddress, requestParams);
case 3:
balances = _context3.sent;
allowances = balances.filter(function (token) {
return tokenAddressesLowercaseSet.has(token.address.toLowerCase());
}).map(function (_ref5) {
var address = _ref5.address,
_ref5$allowance = _ref5.allowance,
allowance = _ref5$allowance === void 0 ? '0' : _ref5$allowance;
return {
tokenAddress: address,
allowance: allowance
};
});
return _context3.abrupt("return", allowances);
case 6:
case "end":
return _context3.stop();
}
}, _callee3);
}));
return function getAllowances(_x6, _x7, _x8) {
return _ref4.apply(this, arguments);
};
}();
var getAllowance = /*#__PURE__*/function () {
var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(userAddress, tokenAddress, requestParams) {
var balanceOrNotFound, address, _balanceOrNotFound$al, allowance;
return _regeneratorRuntime().wrap(function _callee4$(_context4) {
while (1) switch (_context4.prev = _context4.next) {
case 0:
_context4.next = 2;
return getBalance(userAddress, tokenAddress, requestParams);
case 2:
balanceOrNotFound = _context4.sent;
if (!('message' in balanceOrNotFound)) {
_context4.next = 5;
break;
}
return _context4.abrupt("return", balanceOrNotFound);
case 5:
address = balanceOrNotFound.address, _balanceOrNotFound$al = balanceOrNotFound.allowance, allowance = _balanceOrNotFound$al === void 0 ? '0' : _balanceOrNotFound$al;
return _context4.abrupt("return", {
tokenAddress: address,
allowance: allowance
});
case 7:
case "end":
return _context4.stop();
}
}, _callee4);
}));
return function getAllowance(_x9, _x10, _x11) {
return _ref6.apply(this, arguments);
};
}();
return {
getBalance: getBalance,
getBalances: getBalances,
getAllowance: getAllowance,
getAllowances: getAllowances
};
};
var constructGetAdapters = function constructGetAdapters(_ref) {
var _ref$apiURL = _ref.apiURL,
apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
_ref$version = _ref.version,
version = _ref$version === void 0 ? DEFAULT_VERSION : _ref$version,
chainId = _ref.chainId,
fetcher = _ref.fetcher;
var getAdapters = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(requestParams) {
var query, fetchURL, data;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
// always pass explicit type to make sure UrlSearchParams are correct
query = constructSearchString({
network: chainId,
version: version
});
fetchURL = apiURL + "/adapters/list" + query;
_context.next = 4;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 4:
data = _context.sent;
return _context.abrupt("return", data);
case 6:
case "end":
return _context.stop();
}
}, _callee);
}));
return function getAdapters(_x) {
return _ref2.apply(this, arguments);
};
}();
return {
getAdapters: getAdapters
};
};
var _excluded$9 = ["options"],
_excluded2$4 = ["excludeContractMethods", "includeContractMethods", "partner", "includeDEXS", "excludeDEXS", "excludePools"];
function normalizeRateOptions(_ref) {
var _ref$options = _ref.options,
options = _ref$options === void 0 ? {} : _ref$options,
restInput = _objectWithoutPropertiesLoose(_ref, _excluded$9);
var excludeContractMethods = options.excludeContractMethods,
includeContractMethods = options.includeContractMethods,
partner = options.partner,
includeDEXS = options.includeDEXS,
excludeDEXS = options.excludeDEXS,
excludePools = options.excludePools,
restOptions = _objectWithoutPropertiesLoose(options, _excluded2$4);
var _map = [includeDEXS, excludeDEXS, excludePools, excludeContractMethods, includeContractMethods
// no "" empty string
].map(function (array) {
return (array == null ? void 0 : array.join(',')) || undefined;
}),
_includeDEXS = _map[0],
_excludeDEXS = _map[1],
_excludePools = _map[2],
_excludeContractMethods = _map[3],
_includeContractMethods = _map[4];
var transformed = {
excludeContractMethods: _excludeContractMethods,
includeContractMethods: _includeContractMethods,
partner: partner,
includeDEXS: _includeDEXS,
excludeDEXS: _excludeDEXS,
excludePools: _excludePools
};
return _extends({}, transformed, restOptions, restInput);
}
var _excluded$8 = ["srcToken", "destToken"],
_excluded2$3 = ["route"];
var INVALID_ROUTE = 'Invalid Route';
var constructGetRate = function constructGetRate(_ref) {
var _ref$apiURL = _ref.apiURL,
apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
_ref$version = _ref.version,
version = _ref$version === void 0 ? DEFAULT_VERSION : _ref$version,
chainId = _ref.chainId,
fetcher = _ref.fetcher;
var pricesUrl = apiURL + "/prices";
var getRate = /*#__PURE__*/function () {
var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2, requestParams) {
var srcToken, destToken, rest, parsedOptions, search, fetchURL, data;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
srcToken = _ref2.srcToken, destToken = _ref2.destToken, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$8);
parsedOptions = normalizeRateOptions(rest); // always pass explicit type to make sure UrlSearchParams are correct
search = constructSearchString(_extends({
srcToken: srcToken,
destToken: destToken,
network: chainId,
version: version
}, parsedOptions));
fetchURL = pricesUrl + "/" + search;
_context.next = 6;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 6:
data = _context.sent;
return _context.abrupt("return", data.priceRoute);
case 8:
case "end":
return _context.stop();
}
}, _callee);
}));
return function getRate(_x, _x2) {
return _ref3.apply(this, arguments);
};
}();
var getRateByRoute = /*#__PURE__*/function () {
var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref4, requestParams) {
var route, rest, parsedOptions, _route, search, fetchURL, data;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
route = _ref4.route, rest = _objectWithoutPropertiesLoose(_ref4, _excluded2$3);
if (!(route.length < 2)) {
_context2.next = 3;
break;
}
throw new Error(INVALID_ROUTE);
case 3:
parsedOptions = normalizeRateOptions(rest);
_route = route.join('-');
search = constructSearchString(_extends({
route: _route,
// route can be used in place of srcToken+destToken
network: chainId,
version: version
}, parsedOptions));
fetchURL = pricesUrl + "/" + search;
_context2.next = 9;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 9:
data = _context2.sent;
return _context2.abrupt("return", data.priceRoute);
case 11:
case "end":
return _context2.stop();
}
}, _callee2);
}));
return function getRateByRoute(_x3, _x4) {
return _ref5.apply(this, arguments);
};
}();
return {
getRate: getRate,
getRateByRoute: getRateByRoute
};
};
var _excluded$7 = ["srcToken", "destToken", "amount", "route"];
var constructSwapTx = function constructSwapTx(_ref) {
var _ref$apiURL = _ref.apiURL,
apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
_ref$version = _ref.version,
version = _ref$version === void 0 ? DEFAULT_VERSION : _ref$version,
chainId = _ref.chainId,
fetcher = _ref.fetcher;
var pricesUrl = apiURL + "/swap";
var getSwapTxData = /*#__PURE__*/function () {
var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2, requestParams) {
var srcToken, destToken, amount, route, rest, parsedOptions, _route, search, fetchURL, data;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
srcToken = _ref2.srcToken, destToken = _ref2.destToken, amount = _ref2.amount, route = _ref2.route, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$7);
parsedOptions = normalizeRateOptions(rest);
_route = route == null ? void 0 : route.join('-'); // always pass explicit type to make sure UrlSearchParams are correct
search = constructSearchString(_extends({
amount: amount,
srcToken: srcToken,
destToken: destToken,
route: _route,
network: chainId,
version: version
}, parsedOptions));
fetchURL = pricesUrl + "/" + search;
_context.next = 7;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 7:
data = _context.sent;
return _context.abrupt("return", data);
case 9:
case "end":
return _context.stop();
}
}, _callee);
}));
return function getSwapTxData(_x, _x2) {
return _ref3.apply(this, arguments);
};
}();
return {
getSwapTxData: getSwapTxData
};
};
var constructGetTokens = function constructGetTokens(_ref) {
var _ref$apiURL = _ref.apiURL,
apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
chainId = _ref.chainId,
fetcher = _ref.fetcher;
var fetchURL = apiURL + "/tokens/" + chainId;
var getTokens = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(requestParams) {
var data, tokens;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 2:
data = _context.sent;
tokens = data.tokens.map(constructToken);
return _context.abrupt("return", tokens);
case 5:
case "end":
return _context.stop();
}
}, _callee);
}));
return function getTokens(_x) {
return _ref2.apply(this, arguments);
};
}();
return {
getTokens: getTokens
};
};
var name = 'AUGUSTUS RFQ';
var version = '1';
var ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
function baseFetchUrlGetterFactory(orderKind) {
return function constructBaseFetchUrlGetter(_ref) {
var chainId = _ref.chainId,
apiURL = _ref.apiURL;
function urlGetter(type) {
if (!type) return apiURL + "/" + orderKind + "/order";
if (type === 'fillablebalance') return apiURL + "/" + orderKind + "/fillablebalance/" + chainId;
var orderURLpart = type === 'LIMIT' ? 'orders' : 'p2p';
return apiURL + "/" + orderKind + "/" + orderURLpart + "/" + chainId;
}
return urlGetter;
};
}
function sanitizeOrderData$1(_ref) {
var nonceAndMeta = _ref.nonceAndMeta,
expiry = _ref.expiry,
makerAsset = _ref.makerAsset,
takerAsset = _ref.takerAsset,
maker = _ref.maker,
taker = _ref.taker,
makerAmount = _ref.makerAmount,
takerAmount = _ref.takerAmount;
return {
nonceAndMeta: nonceAndMeta,
expiry: expiry,
makerAsset: makerAsset,
takerAsset: takerAsset,
maker: maker,
taker: taker,
makerAmount: makerAmount,
takerAmount: takerAmount
};
}
var constructBaseFetchUrlGetter$1 = /*#__PURE__*/baseFetchUrlGetterFactory('ft');
var OrderNFT = [{
name: 'nonceAndMeta',
type: 'uint256'
}, {
name: 'expiry',
type: 'uint128'
}, {
name: 'makerAsset',
type: 'uint256'
}, {
name: 'makerAssetId',
type: 'uint256'
}, {
name: 'takerAsset',
type: 'uint256'
}, {
name: 'takerAssetId',
type: 'uint256'
}, {
name: 'maker',
type: 'address'
}, {
name: 'taker',
type: 'address'
}, {
name: 'makerAmount',
type: 'uint256'
}, {
name: 'takerAmount',
type: 'uint256'
}];
function buildOrderData$1(_ref) {
var chainId = _ref.chainId,
verifyingContract = _ref.verifyingContract,
_ref$nonce = _ref.nonce,
nonce = _ref$nonce === void 0 ? getRandomInt() : _ref$nonce,
expiry = _ref.expiry,
_makerAssetAddress = _ref.makerAsset,
_takerAssetAddress = _ref.takerAsset,
makerAmount = _ref.makerAmount,
takerAmount = _ref.takerAmount,
makerAssetId = _ref.makerAssetId,
_ref$takerAssetId = _ref.takerAssetId,
takerAssetId = _ref$takerAssetId === void 0 ? '0' : _ref$takerAssetId,
makerAssetType = _ref.makerAssetType,
takerAssetType = _ref.takerAssetType,
maker = _ref.maker,
AugustusAddress = _ref.AugustusAddress,
_ref$taker = _ref.taker,
takerInNonce = _ref$taker === void 0 ? ZERO_ADDRESS : _ref$taker;
// first 160 bits is taker address (for p2p orders),
// or 0 for limitOrders, so that anyone can be the taker of the Order
var nonceAndMeta = (BigInt(takerInNonce) + (BigInt(nonce) << BigInt(160))).toString(10);
var makerAsset = assetAddressToUint(_makerAssetAddress, makerAssetType);
var takerAsset = assetAddressToUint(_takerAssetAddress, takerAssetType);
var orderNFT = {
nonceAndMeta: nonceAndMeta,
expiry: expiry,
makerAsset: makerAsset,
takerAsset: takerAsset,
maker: maker,
taker: AugustusAddress,
makerAmount: makerAmount,
takerAmount: takerAmount,
makerAssetId: makerAssetId,
takerAssetId: takerAssetId
};
return {
types: {
OrderNFT: OrderNFT
},
domain: {
name: name,
version: version,
chainId: chainId,
verifyingContract: verifyingContract
},
data: orderNFT
};
}
// create a packed number that contains assetAddress and AssetType
function assetAddressToUint(assetAddress, assetType) {
return (BigInt(assetAddress) + (BigInt(assetType) << BigInt(160))).toString(10);
}
// any number can be assigned to AssetType enum
// https://github.com/Microsoft/TypeScript/issues/22311
// export enum AssetType {
// ERC20 = 0,
// ERC1155 = 1,
// ERC721 = 2,
// }
var AssetType = {
ERC20: 0,
ERC1155: 1,
ERC721: 2
};
function sanitizeOrderData(_ref) {
var nonceAndMeta = _ref.nonceAndMeta,
expiry = _ref.expiry,
_makerAsset = _ref.makerAsset,
_takerAsset = _ref.takerAsset,
maker = _ref.maker,
taker = _ref.taker,
makerAmount = _ref.makerAmount,
takerAmount = _ref.takerAmount,
makerAssetId = _ref.makerAssetId,
takerAssetId = _ref.takerAssetId,
makerAssetType = _ref.makerAssetType,
takerAssetType = _ref.takerAssetType;
var makerAsset = makerAssetType !== undefined && _makerAsset.startsWith('0x') ? assetAddressToUint(_makerAsset, makerAssetType) : _makerAsset;
var takerAsset = takerAssetType !== undefined && _takerAsset.startsWith('0x') ? assetAddressToUint(_takerAsset, takerAssetType) : _takerAsset;
return {
nonceAndMeta: nonceAndMeta,
expiry: expiry,
makerAsset: makerAsset,
takerAsset: takerAsset,
maker: maker,
taker: taker,
makerAmount: makerAmount,
takerAmount: takerAmount,
makerAssetId: makerAssetId,
takerAssetId: takerAssetId
};
}
var constructBaseFetchUrlGetter = /*#__PURE__*/baseFetchUrlGetterFactory('nft');
var constructBuildTx = function constructBuildTx(_ref) {
var _ref$apiURL = _ref.apiURL,
apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
chainId = _ref.chainId,
fetcher = _ref.fetcher;
var transactionsURL = apiURL + "/transactions/" + chainId;
var buildTx = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(params, options, requestParams) {
var _params$takeSurplus;
var priceRoute, side, AmountMismatchError, search, fetchURL, sanitizedParams, takeSurplus, fetchParams, builtTx;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
if (options === void 0) {
options = {};
}
if ('priceRoute' in params && 'destAmount' in params &&
// isn't provided together with `orders`
!('orders' in params) // when present, destAmount becomes sum(orders[].makerAmount)
) {
priceRoute = params.priceRoute, side = params.priceRoute.side;
AmountMismatchError = side === SwapSide.SELL ? 'Source Amount Mismatch' : 'Destination Amount Mismatch'; // user provides srcAmount or slippage but not both. so we only validate accordingly.
assert(areAmountsCorrect({
queryParams: params,
side: side,
priceRoute: priceRoute
}), AmountMismatchError);
}
// always pass explicit type to make sure UrlSearchParams are correct
search = constructSearchString(options);
fetchURL = transactionsURL + "/" + search;
sanitizedParams = 'orders' in params && params.orders.length > 0 ? _extends({}, params, {
// make sure we don't pass more with orders than API expects
orders: params.orders.map(function (order) {
var sanitizedOrderData = 'makerAssetId' in order ? sanitizeOrderData(order) // assetType is provided here, because Order.*Asset may be address
:
// if Order received from API by hash
sanitizeOrderData$1(order);
var sanitizedOrder = _extends({}, sanitizedOrderData, {
signature: order.signature
});
if (order.permitMakerAsset) {
sanitizedOrder.permitMakerAsset = order.permitMakerAsset;
}
return sanitizedOrder;
})
}) : params;
takeSurplus = (_params$takeSurplus = params.takeSurplus) != null ? _params$takeSurplus : params.positiveSlippageToUser !== undefined ? !params.positiveSlippageToUser : undefined;
if ('positiveSlippageToUser' in sanitizedParams) {
// positiveSlippageToUser & takeSurplus together will Error in API
delete sanitizedParams.positiveSlippageToUser;
}
if (takeSurplus !== undefined) {
sanitizedParams.takeSurplus = takeSurplus;
}
fetchParams = {
url: fetchURL,
method: 'POST',
data: sanitizedParams,
requestParams: requestParams
};
_context.next = 11;
return fetcher(fetchParams);
case 11:
builtTx = _context.sent;
return _context.abrupt("return", builtTx);
case 13:
case "end":
return _context.stop();
}
}, _callee);
}));
return function buildTx(_x, _x2, _x3) {
return _ref2.apply(this, arguments);
};
}();
return {
buildTx: buildTx
};
};
function areAmountsCorrect(_ref3) {
var queryParams = _ref3.queryParams,
side = _ref3.side,
priceRoute = _ref3.priceRoute;
// return early after a simpler check if the user was swapping before filling
if (queryParams.slippage) {
return side === SwapSide.BUY && queryParams.destAmount === priceRoute.destAmount || side === SwapSide.SELL && queryParams.srcAmount === priceRoute.srcAmount;
}
// provided amounts match the previously queried price route
var _ref4 = side === SwapSide.SELL ? [queryParams.srcAmount, priceRoute.srcAmount] : [queryParams.destAmount, priceRoute.destAmount],
inputAmount = _ref4[0],
priceRouteAmount = _ref4[1];
return inputAmount === priceRouteAmount;
}
var Order = [{
name: 'nonceAndMeta',
type: 'uint256'
}, {
name: 'expiry',
type: 'uint128'
}, {
name: 'makerAsset',
type: 'address'
}, {
name: 'takerAsset',
type: 'address'
}, {
name: 'maker',
type: 'address'
}, {
name: 'taker',
type: 'address'
}, {
name: 'makerAmount',
type: 'uint256'
}, {
name: 'takerAmount',
type: 'uint256'
}];
function buildOrderData(_ref) {
var chainId = _ref.chainId,
verifyingContract = _ref.verifyingContract,
_ref$nonce = _ref.nonce,
nonce = _ref$nonce === void 0 ? getRandomInt() : _ref$nonce,
expiry = _ref.expiry,
makerAsset = _ref.make