@velora-dex/sdk
Version:
1,376 lines (1,355 loc) • 227 kB
JavaScript
import { SwapSide, ContractMethod } from '@paraswap/core';
export { ContractMethod, ContractMethodV5, ContractMethodV6, SwapSide } from '@paraswap/core';
import { assert } from 'ts-essentials';
import { hashTypedData } from 'viem/utils';
function _OverloadYield(e, d) {
this.v = e, this.k = d;
}
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 (-1 !== e.indexOf(n)) continue;
t[n] = r[n];
}
return t;
}
function _regenerator() {
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
var e,
t,
r = "function" == typeof Symbol ? Symbol : {},
n = r.iterator || "@@iterator",
o = r.toStringTag || "@@toStringTag";
function i(r, n, o, i) {
var c = n && n.prototype instanceof Generator ? n : Generator,
u = Object.create(c.prototype);
return _regeneratorDefine(u, "_invoke", function (r, n, o) {
var i,
c,
u,
f = 0,
p = o || [],
y = !1,
G = {
p: 0,
n: 0,
v: e,
a: d,
f: d.bind(e, 4),
d: function (t, r) {
return i = t, c = 0, u = e, G.n = r, a;
}
};
function d(r, n) {
for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
var o,
i = p[t],
d = G.p,
l = i[2];
r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
}
if (o || r > 1) return a;
throw y = !0, n;
}
return function (o, p, l) {
if (f > 1) throw TypeError("Generator is already running");
for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
try {
if (f = 2, i) {
if (c || (o = "next"), t = i[o]) {
if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
if (!t.done) return t;
u = t.value, c < 2 && (c = 0);
} else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
i = e;
} else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
} catch (t) {
i = e, c = 1, u = t;
} finally {
f = 1;
}
}
return {
value: t,
done: y
};
};
}(r, o, i), !0), u;
}
var a = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
t = Object.getPrototypeOf;
var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
return this;
}), t),
u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
function f(e) {
return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
return this;
}), _regeneratorDefine(u, "toString", function () {
return "[object Generator]";
}), (_regenerator = function () {
return {
w: i,
m: f
};
})();
}
function _regeneratorAsync(n, e, r, t, o) {
var a = _regeneratorAsyncGen(n, e, r, t, o);
return a.next().then(function (n) {
return n.done ? n.value : a.next();
});
}
function _regeneratorAsyncGen(r, e, t, o, n) {
return new _regeneratorAsyncIterator(_regenerator().w(r, e, t, o), n || Promise);
}
function _regeneratorAsyncIterator(t, e) {
function n(r, o, i, f) {
try {
var c = t[r](o),
u = c.value;
return u instanceof _OverloadYield ? e.resolve(u.v).then(function (t) {
n("next", t, i, f);
}, function (t) {
n("throw", t, i, f);
}) : e.resolve(u).then(function (t) {
c.value = t, i(c);
}, function (t) {
return n("throw", t, i, f);
});
} catch (t) {
f(t);
}
}
var r;
this.next || (_regeneratorDefine(_regeneratorAsyncIterator.prototype), _regeneratorDefine(_regeneratorAsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function () {
return this;
})), _regeneratorDefine(this, "_invoke", function (t, o, i) {
function f() {
return new e(function (e, r) {
n(t, i, e, r);
});
}
return r = r ? r.then(f, f) : f();
}, !0);
}
function _regeneratorDefine(e, r, n, t) {
var i = Object.defineProperty;
try {
i({}, "", {});
} catch (e) {
i = 0;
}
_regeneratorDefine = function (e, r, n, t) {
function o(r, n) {
_regeneratorDefine(e, r, function (e) {
return this._invoke(r, n, e);
});
}
r ? i ? i(e, r, {
value: n,
enumerable: !t,
configurable: !t,
writable: !t
}) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
}, _regeneratorDefine(e, r, n, t);
}
function _regeneratorKeys(e) {
var n = Object(e),
r = [];
for (var t in n) r.unshift(t);
return function e() {
for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = !1, e;
return e.done = !0, e;
};
}
function _regeneratorValues(e) {
if (null != e) {
var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
r = 0;
if (t) return t.call(e);
if ("function" == typeof e.next) return e;
if (!isNaN(e.length)) return {
next: function () {
return e && r >= e.length && (e = void 0), {
value: e && e[r++],
done: !e
};
}
};
}
throw new TypeError(typeof e + " is not iterable");
}
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);
}
function _regeneratorRuntime() {
var r = _regenerator(),
e = r.m(_regeneratorRuntime),
t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;
function n(r) {
var e = "function" == typeof r && r.constructor;
return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name));
}
var o = {
throw: 1,
return: 2,
break: 3,
continue: 3
};
function a(r) {
var e, t;
return function (n) {
e || (e = {
stop: function () {
return t(n.a, 2);
},
catch: function () {
return n.v;
},
abrupt: function (r, e) {
return t(n.a, o[r], e);
},
delegateYield: function (r, o, a) {
return e.resultName = o, t(n.d, _regeneratorValues(r), a);
},
finish: function (r) {
return t(n.f, r);
}
}, t = function (r, t, o) {
n.p = e.prev, n.n = e.next;
try {
return r(t, o);
} finally {
e.next = n.n;
}
}), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n;
try {
return r.call(this, e);
} finally {
n.p = e.prev, n.n = e.next;
}
};
}
return (_regeneratorRuntime = function () {
return {
wrap: function (e, t, n, o) {
return r.w(a(e), t, n, o && o.reverse());
},
isGeneratorFunction: n,
mark: r.m,
awrap: function (r, e) {
return new _OverloadYield(r, e);
},
AsyncIterator: _regeneratorAsyncIterator,
async: function (r, e, t, o, u) {
return (n(e) ? _regeneratorAsyncGen : _regeneratorAsync)(a(r), e, t, o, u);
},
keys: _regeneratorKeys,
values: _regeneratorValues
};
})();
}
var API_URL = 'https://api.velora.xyz';
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({
chainId: 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);
};
}();
var getDelta = /*#__PURE__*/function () {
var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(requestParams) {
var _yield$getContracts4, ParaswapDelta;
return _regeneratorRuntime().wrap(function _callee5$(_context5) {
while (1) switch (_context5.prev = _context5.next) {
case 0:
_context5.next = 2;
return getContracts(requestParams);
case 2:
_yield$getContracts4 = _context5.sent;
ParaswapDelta = _yield$getContracts4.ParaswapDelta;
return _context5.abrupt("return", ParaswapDelta || null);
case 5:
case "end":
return _context5.stop();
}
}, _callee5);
}));
return function getDelta(_x5) {
return _ref6.apply(this, arguments);
};
}();
return {
getContracts: getContracts,
getSpender: getSpender,
getAugustusSwapper: getAugustusSwapper,
getAugustusRFQ: getAugustusRFQ,
getDelta: getDelta
};
};
// 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 ipfsRegEx = /^(ipfs|ipns):\/\/(.*)$/i;
var IPFStransformer = function IPFStransformer(uri) {
var match = uri.match(ipfsRegEx);
// likely http:// , https:// or // uri
if (!match) return null;
var protocol = match[1],
hash = match[2];
if (!protocol || !hash) return null;
// only append `/` to a bare root; a path segment (`.../logo.png`)
// must keep its exact ending or gateways may resolve it differently
var suffix = hash.includes('/') ? '' : '/';
// hash stays as-is: base58 CIDs (Qm…) are case-sensitive
return "https://ipfs.io/" + protocol.toLowerCase() + "/" + hash + suffix;
};
var createURItoHttpURLTransformer = function createURItoHttpURLTransformer() {
for (var _len = arguments.length, transformers = new Array(_len), _key = 0; _key < _len; _key++) {
transformers[_key] = arguments[_key];
}
return function (uri) {
// try each transformer
var httpURL = transformers.reduce(function (result, transformer) {
// as soon as transformer returns string, skip further transformers
if (result !== null) return result;
// no transformer returned string yet, so try current transformer
return transformer(uri);
}, null);
return httpURL || uri;
};
};
// uri can be
// IPFS ipfs://QmV8AfDE8GFSGQvt3vck8EwAzsPuNTmtP8VcQJE3qxRPaZ
// IPNS ipns://app.uniswap.org
// http, https or // (match current protocol)
var uriToHttpURL = /*#__PURE__*/createURItoHttpURLTransformer(IPFStransformer);
var _excluded$c = ["tokenType", "mainConnector", "connectors", "network", "sources", "categories", "tags"];
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,
_tokenProps$sources = tokenProps.sources,
sources = _tokenProps$sources === void 0 ? [] : _tokenProps$sources,
_tokenProps$categorie = tokenProps.categories,
categories = _tokenProps$categorie === void 0 ? [] : _tokenProps$categorie,
_tokenProps$tags = tokenProps.tags,
tags = _tokenProps$tags === void 0 ? [] : _tokenProps$tags,
rest = _objectWithoutPropertiesLoose(tokenProps, _excluded$c);
var connectors = connectorsInput.length > 0 ? connectorsInput : [mainConnector];
return _extends({
tokenType: tokenType,
connectors: connectors,
mainConnector: mainConnector,
network: network,
sources: sources,
categories: categories,
tags: tags
}, rest);
};
function constructApiToken(t) {
return constructToken({
address: t.address,
decimals: t.decimals,
symbol: t.symbol,
name: t.name,
network: t.chainId,
sources: t.sources,
categories: t.categories,
img: t.logoURI ? uriToHttpURL(t.logoURI) : undefined,
tags: t.tags
});
}
var isAllowance = function isAllowance(arg) {
return 'allowance' in arg;
};
var NOT_FOUND_RESPONSE = {
message: 'Not Found'
};
/** @deprecated Will be removed in the next major version. */
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, _x0, _x1) {
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({
chainId: 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$b = ["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$b);
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$a = ["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$a);
parsedOptions = normalizeRateOptions(rest); // always pass explicit type to make sure UrlSearchParams are correct
search = constructSearchString(_extends({
srcToken: srcToken,
destToken: destToken,
chainId: 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
chainId: 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$9 = ["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$9);
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,
chainId: 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 _excluded$8 = ["category"];
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 getTokens = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_temp, requestParams) {
var _ref3, category, _requestParams, query, fetchURL, data;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
_ref3 = _temp === void 0 ? {} : _temp, category = _ref3.category, _requestParams = _objectWithoutPropertiesLoose(_ref3, _excluded$8);
// always pass explicit type to make sure UrlSearchParams are correct
query = constructSearchString({
category: category
});
fetchURL = apiURL + "/fiat/tokens/" + chainId + query;
_context.next = 5;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: _extends({}, _requestParams, requestParams)
});
case 5:
data = _context.sent;
return _context.abrupt("return", data.tokens.map(constructApiToken));
case 7:
case "end":
return _context.stop();
}
}, _callee);
}));
return function getTokens(_x, _x2) {
return _ref2.apply(this, arguments);
};
}();
var getAllTokens = /*#__PURE__*/function () {
var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_temp2, requestParams) {
var _ref5, category, query, fetchURL, data;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
_ref5 = _temp2 === void 0 ? {} : _temp2, category = _ref5.category;
// always pass explicit type to make sure UrlSearchParams are correct
query = constructSearchString({
category: category
});
fetchURL = apiURL + "/fiat/tokens/all" + query;
_context2.next = 5;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 5:
data = _context2.sent;
return _context2.abrupt("return", data.tokens.map(constructApiToken));
case 7:
case "end":
return _context2.stop();
}
}, _callee2);
}));
return function getAllTokens(_x3, _x4) {
return _ref4.apply(this, arguments);
};
}();
var getTokenCategories = /*#__PURE__*/function () {
var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(requestParams) {
var fetchURL, data;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
fetchURL = apiURL + "/fiat/tokens/categories";
_context3.next = 3;
return fetcher({
url: fetchURL,
method: 'GET',
requestParams: requestParams
});
case 3:
data = _context3.sent;
return _context3.abrupt("return", data.categories);
case 5:
case "end":
return _context3.stop();
}
}, _callee3);
}));
return function getTokenCategories(_x5) {
return _ref6.apply(this, arguments);
};
}();
return {
getTokens: getTokens,
getAllTokens: getAllTokens,
getTokenCategories: getTokenCategories
};
};
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 = /*#__PURE__*/baseFetchUrlGetterFactory('ft');
// create a packed number that contains assetAddress and AssetType
function assetAddressToUint(assetAddress, assetType) {
return (BigInt(assetAddress) + (BigInt(assetType) << BigInt(160))).toString(10);
}
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 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, priceR