@algofi/v1
Version:
The official JavaScript SDK for the V2 Algofi Lending Market
1,379 lines (1,185 loc) • 214 kB
JavaScript
import algosdk, { LogicSigAccount, assignGroupID, encodeAddress, getApplicationAddress, encodeUint64, decodeUint64, bytesToBigInt, makeAssetTransferTxnWithSuggestedParamsFromObject, makeApplicationNoOpTxnFromObject, makePaymentTxnWithSuggestedParamsFromObject, makeApplicationOptInTxnFromObject } from 'algosdk';
var Base64Encoder = {
_keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
/**
* Function to encode an arbitrary string
*
* @param string e String to be encoded
* @return string t Encoded string e
*/
encode: function encode(e) {
var t = "";
var n, r, i, s, o, u, a;
var f = 0;
e = Base64Encoder._utf8_encode(e);
while (f < e.length) {
n = e.charCodeAt(f++);
r = e.charCodeAt(f++);
i = e.charCodeAt(f++);
s = n >> 2;
o = (n & 3) << 4 | r >> 4;
u = (r & 15) << 2 | i >> 6;
a = i & 63;
if (isNaN(r)) {
u = a = 64;
} else if (isNaN(i)) {
a = 64;
}
t = t + this._keyStr.charAt(s) + this._keyStr.charAt(o) + this._keyStr.charAt(u) + this._keyStr.charAt(a);
}
return t;
},
/**
* Function to decode a string encoded by Base64Encoder.encode
*
* @param string e String to be decoded
* @return string t Decoded string e
*/
decode: function decode(e) {
var t = "";
var n, r, i;
var s, o, u, a;
var f = 0;
e = e.replace(/[^A-Za-z0-9\+\/\=]/g, "");
while (f < e.length) {
s = this._keyStr.indexOf(e.charAt(f++));
o = this._keyStr.indexOf(e.charAt(f++));
u = this._keyStr.indexOf(e.charAt(f++));
a = this._keyStr.indexOf(e.charAt(f++));
n = s << 2 | o >> 4;
r = (o & 15) << 4 | u >> 2;
i = (u & 3) << 6 | a;
t = t + String.fromCharCode(n);
if (u != 64) {
t = t + String.fromCharCode(r);
}
if (a != 64) {
t = t + String.fromCharCode(i);
}
}
t = Base64Encoder._utf8_decode(t);
return t;
},
/**
* Function to perfom utf8 encoding on an arbitrary string
*
* @param string e String to be utf8 encoded
* @return string t Encoded string e
*/
_utf8_encode: function _utf8_encode(e) {
e = e.replace(/\r\n/g, "\n");
var t = "";
for (var n = 0; n < e.length; n++) {
var r = e.charCodeAt(n);
if (r < 128) {
t += String.fromCharCode(r);
} else if (r > 127 && r < 2048) {
t += String.fromCharCode(r >> 6 | 192);
t += String.fromCharCode(r & 63 | 128);
} else {
t += String.fromCharCode(r >> 12 | 224);
t += String.fromCharCode(r >> 6 & 63 | 128);
t += String.fromCharCode(r & 63 | 128);
}
}
return t;
},
/**
* Function to decode a string encoded by Base64Encoder._utf8_encode
*
* @param string e String to be utf8 decoded
* @return string t Decoded string e
*/
_utf8_decode: function _utf8_decode(e) {
var t = "";
var n = 0;
var r = 0;
var c2 = 0;
var c3 = 0;
while (n < e.length) {
r = e.charCodeAt(n);
if (r < 128) {
t += String.fromCharCode(r);
n++;
} else if (r > 191 && r < 224) {
c2 = e.charCodeAt(n + 1);
t += String.fromCharCode((r & 31) << 6 | c2 & 63);
n += 2;
} else {
c2 = e.charCodeAt(n + 1);
c3 = e.charCodeAt(n + 2);
t += String.fromCharCode((r & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
n += 3;
}
}
return t;
}
};
// external imports
var FIXED_3_SCALE_FACTOR = 1000;
var FIXED_6_SCALE_FACTOR = 1000000;
var FIXED_18_SCALE_FACTOR = /*#__PURE__*/BigInt(1000000000000000000);
var ALGO_ASSET_ID = 1; // requires NoOp, ApplicationCall, No Rekey, No CloseRemainderTo (assits ledger users)
var PERMISSIONLESS_SENDER_LOGIC_SIG = /*#__PURE__*/new LogicSigAccount( /*#__PURE__*/new Uint8Array([6, 49, 16, 129, 6, 18, 68, 49, 25, 129, 0, 18, 68, 49, 9, 50, 3, 18, 68, 49, 32, 50, 3, 18, 68, 129, 1, 67]));
var TEXT_ENCODER = /*#__PURE__*/new TextEncoder();
var Network;
(function (Network) {
Network[Network["MAINNET"] = 0] = "MAINNET";
Network[Network["MAINNET_CLONE"] = 1] = "MAINNET_CLONE";
Network[Network["MAINNET_CLONE2"] = 2] = "MAINNET_CLONE2";
Network[Network["TESTNET"] = 3] = "TESTNET";
Network[Network["MAINNET_CLONE3"] = 4] = "MAINNET_CLONE3";
})(Network || (Network = {}));
function _regeneratorRuntime() {
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
_regeneratorRuntime = function () {
return exports;
};
var exports = {},
Op = Object.prototype,
hasOwn = Op.hasOwnProperty,
$Symbol = "function" == typeof Symbol ? Symbol : {},
iteratorSymbol = $Symbol.iterator || "@@iterator",
asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
function define(obj, key, value) {
return Object.defineProperty(obj, key, {
value: value,
enumerable: !0,
configurable: !0,
writable: !0
}), obj[key];
}
try {
define({}, "");
} catch (err) {
define = function (obj, key, value) {
return obj[key] = value;
};
}
function wrap(innerFn, outerFn, self, tryLocsList) {
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
generator = Object.create(protoGenerator.prototype),
context = new Context(tryLocsList || []);
return generator._invoke = function (innerFn, self, context) {
var state = "suspendedStart";
return function (method, arg) {
if ("executing" === state) throw new Error("Generator is already running");
if ("completed" === state) {
if ("throw" === method) throw arg;
return doneResult();
}
for (context.method = method, context.arg = arg;;) {
var delegate = context.delegate;
if (delegate) {
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult) {
if (delegateResult === ContinueSentinel) continue;
return delegateResult;
}
}
if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
if ("suspendedStart" === state) throw state = "completed", context.arg;
context.dispatchException(context.arg);
} else "return" === context.method && context.abrupt("return", context.arg);
state = "executing";
var record = tryCatch(innerFn, self, context);
if ("normal" === record.type) {
if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
return {
value: record.arg,
done: context.done
};
}
"throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
}
};
}(innerFn, self, context), generator;
}
function tryCatch(fn, obj, arg) {
try {
return {
type: "normal",
arg: fn.call(obj, arg)
};
} catch (err) {
return {
type: "throw",
arg: err
};
}
}
exports.wrap = wrap;
var ContinueSentinel = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var IteratorPrototype = {};
define(IteratorPrototype, iteratorSymbol, function () {
return this;
});
var getProto = Object.getPrototypeOf,
NativeIteratorPrototype = getProto && getProto(getProto(values([])));
NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
function defineIteratorMethods(prototype) {
["next", "throw", "return"].forEach(function (method) {
define(prototype, method, function (arg) {
return this._invoke(method, arg);
});
});
}
function AsyncIterator(generator, PromiseImpl) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if ("throw" !== record.type) {
var result = record.arg,
value = result.value;
return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
invoke("next", value, resolve, reject);
}, function (err) {
invoke("throw", err, resolve, reject);
}) : PromiseImpl.resolve(value).then(function (unwrapped) {
result.value = unwrapped, resolve(result);
}, function (error) {
return invoke("throw", error, resolve, reject);
});
}
reject(record.arg);
}
var previousPromise;
this._invoke = function (method, arg) {
function callInvokeWithMethodAndArg() {
return new PromiseImpl(function (resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
};
}
function maybeInvokeDelegate(delegate, context) {
var method = delegate.iterator[context.method];
if (undefined === method) {
if (context.delegate = null, "throw" === context.method) {
if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
}
return ContinueSentinel;
}
var record = tryCatch(method, delegate.iterator, context.arg);
if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
var info = record.arg;
return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
}
function pushTryEntry(locs) {
var entry = {
tryLoc: locs[0]
};
1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal", delete record.arg, entry.completion = record;
}
function Context(tryLocsList) {
this.tryEntries = [{
tryLoc: "root"
}], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
}
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) return iteratorMethod.call(iterable);
if ("function" == typeof iterable.next) return iterable;
if (!isNaN(iterable.length)) {
var i = -1,
next = function next() {
for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
return next.value = undefined, next.done = !0, next;
};
return next.next = next;
}
}
return {
next: doneResult
};
}
function doneResult() {
return {
value: undefined,
done: !0
};
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
var ctor = "function" == typeof genFun && genFun.constructor;
return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
}, exports.mark = function (genFun) {
return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
}, exports.awrap = function (arg) {
return {
__await: arg
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
return this;
}), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
void 0 === PromiseImpl && (PromiseImpl = Promise);
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
return result.done ? result.value : iter.next();
});
}, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
return this;
}), define(Gp, "toString", function () {
return "[object Generator]";
}), exports.keys = function (object) {
var keys = [];
for (var key in object) keys.push(key);
return keys.reverse(), function next() {
for (; keys.length;) {
var key = keys.pop();
if (key in object) return next.value = key, next.done = !1, next;
}
return next.done = !0, next;
};
}, exports.values = values, Context.prototype = {
constructor: Context,
reset: function (skipTempReset) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
},
stop: function () {
this.done = !0;
var rootRecord = this.tryEntries[0].completion;
if ("throw" === rootRecord.type) throw rootRecord.arg;
return this.rval;
},
dispatchException: function (exception) {
if (this.done) throw exception;
var context = this;
function handle(loc, caught) {
return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i],
record = entry.completion;
if ("root" === entry.tryLoc) return handle("end");
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc"),
hasFinally = hasOwn.call(entry, "finallyLoc");
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
} else if (hasCatch) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
} else {
if (!hasFinally) throw new Error("try statement without catch or finally");
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
}
}
}
},
abrupt: function (type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
var record = finallyEntry ? finallyEntry.completion : {};
return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
},
complete: function (record, afterLoc) {
if ("throw" === record.type) throw record.arg;
return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
},
finish: function (finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
}
},
catch: function (tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if ("throw" === record.type) {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
}
throw new Error("illegal catch attempt");
},
delegateYield: function (iterable, resultName, nextLoc) {
return this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
}, "next" === this.method && (this.arg = undefined), ContinueSentinel;
}
}, exports;
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function () {
var self = this,
args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _extends() {
_extends = Object.assign ? Object.assign.bind() : function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _createForOfIteratorHelperLoose(o, allowArrayLike) {
var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
if (it) return (it = it.call(o)).next.bind(it);
if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
if (it) o = it;
var i = 0;
return function () {
if (i >= o.length) return {
done: true
};
return {
done: false,
value: o[i++]
};
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function concatArrays(arrays) {
// sum of individual array lengths
var totalLength = arrays.reduce(function (acc, value) {
return acc + value.length;
}, 0);
if (!arrays.length) return null;
var result = new Uint8Array(totalLength); // for each array - copy it over result
// next array is copied right after the previous one
var length = 0;
for (var _iterator = _createForOfIteratorHelperLoose(arrays), _step; !(_step = _iterator()).done;) {
var array = _step.value;
result.set(array, length);
length += array.length;
}
return result;
}
function formatPrefixState(state) {
var formattedState = {};
for (var _i = 0, _Object$entries = Object.entries(state); _i < _Object$entries.length; _i++) {
var _Object$entries$_i = _Object$entries[_i],
key = _Object$entries$_i[0],
value = _Object$entries$_i[1];
var indexUnderScore = key.indexOf("_"); // case when it is a prefix term
if (indexUnderScore > 0) {
var prefix = key.substring(0, indexUnderScore + 1);
var hex = key.substring(indexUnderScore + 1);
var formatted = Uint8Array.from(hex, function (e) {
return e.charCodeAt(0);
});
var number = formatted[7];
formattedState[prefix + number.toString()] = value;
} else {
formattedState[key] = value;
}
}
return formattedState;
}
function parseAddressBytes(bytes) {
return encodeAddress(Buffer.from(bytes, "base64"));
}
function decodeBytes(bytes) {
var result = new Uint8Array(bytes.length);
for (var i = 0; i < bytes.length; ++i) {
result[i] = bytes.charCodeAt(i);
}
return result;
}
function addressEquals(a, b) {
return a.publicKey.length == b.publicKey.length && a.publicKey.every(function (val, index) {
return val == b.publicKey[index];
}) && a.checksum.length == b.checksum.length && a.checksum.every(function (val, index) {
return val == b.checksum[index];
});
}
function composeTransactions(txnsToCompose) {
var txns = [];
for (var _iterator2 = _createForOfIteratorHelperLoose(txnsToCompose), _step2; !(_step2 = _iterator2()).done;) {
var txnGroup = _step2.value;
for (var _iterator3 = _createForOfIteratorHelperLoose(txnGroup), _step3; !(_step3 = _iterator3()).done;) {
var _txn = _step3.value;
txns.push(_txn);
}
}
for (var _i2 = 0, _txns = txns; _i2 < _txns.length; _i2++) {
var txn = _txns[_i2];
txn.group = undefined;
}
return assignGroupID(txns);
}
var _AssetConfigs;
var AssetConfig = function AssetConfig(name, assetId, decimals) {
this.name = name;
this.assetId = assetId;
this.decimals = decimals;
};
var AssetConfigs = (_AssetConfigs = {}, _AssetConfigs[Network.MAINNET] = {
1: /*#__PURE__*/new AssetConfig("ALGO", 1, 6)
}, _AssetConfigs[Network.MAINNET_CLONE] = {
1: /*#__PURE__*/new AssetConfig("ALGO", 1, 6),
785578010: /*#__PURE__*/new AssetConfig("m0", 785578010, 0),
785579415: /*#__PURE__*/new AssetConfig("m1", 785579415, 0),
785579619: /*#__PURE__*/new AssetConfig("m2", 785579619, 0),
785580502: /*#__PURE__*/new AssetConfig("m3", 785580502, 0),
753117075: /*#__PURE__*/new AssetConfig("AF-BANK-ALGO-STANDARD", 753117075, 6),
753101315: /*#__PURE__*/new AssetConfig("USDC", 753101315, 6),
753119272: /*#__PURE__*/new AssetConfig("AF-BANK-USDC-STANDARD", 753119272, 6),
753101485: /*#__PURE__*/new AssetConfig("USDT", 753101485, 6),
753119789: /*#__PURE__*/new AssetConfig("AF-BANK-USDT-STANDARD", 753119789, 6),
753102180: /*#__PURE__*/new AssetConfig("goBTC", 753102180, 8),
753120742: /*#__PURE__*/new AssetConfig("AF-BANK-GOBTC-STANDARD", 753120742, 6),
753102376: /*#__PURE__*/new AssetConfig("goETH", 753102376, 8),
753121086: /*#__PURE__*/new AssetConfig("AF-BANK-GOETH-STANDARD", 753121086, 6),
753103963: /*#__PURE__*/new AssetConfig("WETH", 753103963, 6),
753121726: /*#__PURE__*/new AssetConfig("AF-BANK-WETH-STANDARD", 753121726, 6),
753103642: /*#__PURE__*/new AssetConfig("WBTC", 753103642, 6),
753121416: /*#__PURE__*/new AssetConfig("AF-BANK-WBTC-STANDARD", 753121416, 6),
753104158: /*#__PURE__*/new AssetConfig("WSOL", 753104158, 6),
753122003: /*#__PURE__*/new AssetConfig("AF-BANK-WSOL-STANDARD", 753122003, 6),
753122631: /*#__PURE__*/new AssetConfig("AF-BANK-ALGO-VAULT", 753122631, 6),
753101784: /*#__PURE__*/new AssetConfig("STBL", 753101784, 6),
753120193: /*#__PURE__*/new AssetConfig("AF-BANK-STBL-STBL", 753120193, 6),
753104718: /*#__PURE__*/new AssetConfig("BANK", 753104718, 6),
753122293: /*#__PURE__*/new AssetConfig("AF-BANK-BANK-STANDARD", 753122293, 6)
}, _AssetConfigs[Network.MAINNET_CLONE2] = {
1: /*#__PURE__*/new AssetConfig("ALGO", 1, 6),
802887010: /*#__PURE__*/new AssetConfig("AF-BANK-ALGO-STANDARD", 802887010, 6),
802871797: /*#__PURE__*/new AssetConfig("USDC", 802871797, 6),
802887476: /*#__PURE__*/new AssetConfig("AF-BANK-USDC-STANDARD", 802887476, 6),
802873705: /*#__PURE__*/new AssetConfig("goBTC", 802873705, 8),
802888469: /*#__PURE__*/new AssetConfig("AF-BANK-GOBTC-STANDARD", 802888469, 6),
802874445: /*#__PURE__*/new AssetConfig("goETH", 802874445, 8),
802888853: /*#__PURE__*/new AssetConfig("AF-BANK-GOETH-STANDARD", 802888853, 6),
802872834: /*#__PURE__*/new AssetConfig("STBL2", 802872834, 6),
802887973: /*#__PURE__*/new AssetConfig("AF-BANK-STBL-STBL2", 802887973, 6)
}, _AssetConfigs[Network.TESTNET] = {
1: /*#__PURE__*/new AssetConfig("ALGO", 1, 6),
91638233: /*#__PURE__*/new AssetConfig("AF-BANK-ALGO-STANDARD", 91638233, 6),
91634316: /*#__PURE__*/new AssetConfig("USDC", 91634316, 6),
91638306: /*#__PURE__*/new AssetConfig("AF-BANK-USDC-STANDARD", 91638306, 6),
91634828: /*#__PURE__*/new AssetConfig("USDT", 91634828, 6),
91638392: /*#__PURE__*/new AssetConfig("AF-BANK-USDT-STANDARD", 91638392, 6),
91634454: /*#__PURE__*/new AssetConfig("goBTC", 91634454, 8),
91638538: /*#__PURE__*/new AssetConfig("AF-BANK-GOBTC-STANDARD", 91638538, 6),
91634487: /*#__PURE__*/new AssetConfig("goETH", 91634487, 8),
91638603: /*#__PURE__*/new AssetConfig("AF-BANK-GOETH-STANDARD", 91638603, 6),
91634534: /*#__PURE__*/new AssetConfig("WETH", 91634534, 6),
91638687: /*#__PURE__*/new AssetConfig("AF-BANK-WETH-STANDARD", 91638687, 6),
91634562: /*#__PURE__*/new AssetConfig("WBTC", 91634562, 6),
91638794: /*#__PURE__*/new AssetConfig("AF-BANK-WBTC-STANDARD", 91638794, 6),
91634691: /*#__PURE__*/new AssetConfig("WSOL", 91634691, 6),
91638864: /*#__PURE__*/new AssetConfig("AF-BANK-WSOL-STANDARD", 91638864, 6),
91639146: /*#__PURE__*/new AssetConfig("AF-BANK-ALGO-VAULT", 91639146, 6),
91634578: /*#__PURE__*/new AssetConfig("STBL", 91634578, 6),
91638952: /*#__PURE__*/new AssetConfig("AF-BANK-STBL-STBL", 91638952, 6),
91634736: /*#__PURE__*/new AssetConfig("BANK", 91634736, 6),
91639074: /*#__PURE__*/new AssetConfig("AF-BANK-BANK-STANDARD", 91639074, 6)
}, _AssetConfigs);
/**
* Function to get global state of an application
*
* @param {Algodv2} algodClient
*
* @return {dict<string,any>} dictionary of global state
*/
function getApplicationGlobalState(_x, _x2) {
return _getApplicationGlobalState.apply(this, arguments);
}
/**
* Function to get local state for a given address and application
*
* @param {Algodv2} algodClient
* @param {string} address
*
* @return {dict<number,dict{string:any}>} dictionary of user local states
*/
function _getApplicationGlobalState() {
_getApplicationGlobalState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(algodClient, applicationId) {
var response, results;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_context2.next = 2;
return algodClient.getApplicationByID(applicationId)["do"]();
case 2:
response = _context2.sent;
results = {};
_context2.next = 6;
return Promise.all(response.params["global-state"].map( /*#__PURE__*/function () {
var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(x) {
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (x.value.type == 1) {
results[Base64Encoder.decode(x.key)] = x.value.bytes;
} else {
results[Base64Encoder.decode(x.key)] = x.value.uint;
}
case 1:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function (_x10) {
return _ref.apply(this, arguments);
};
}()));
case 6:
return _context2.abrupt("return", results);
case 7:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
return _getApplicationGlobalState.apply(this, arguments);
}
function getLocalStates(_x3, _x4, _x5) {
return _getLocalStates.apply(this, arguments);
}
/**
* Function to get balances for an account
*
* @param {Algodv2} algodClient
* @param {string} address
*
* @return {dict<string,int>} dictionary of assets to amounts
*/
function _getLocalStates() {
_getLocalStates = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(algodClient, address, addressFields) {
var results, accountInfo;
return _regeneratorRuntime().wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
results = {};
_context5.next = 4;
return algodClient.accountInformation(address)["do"]();
case 4:
accountInfo = _context5.sent;
_context5.next = 7;
return Promise.all(accountInfo["apps-local-state"].map( /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(appLocalState) {
var localState;
return _regeneratorRuntime().wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
if (!appLocalState["key-value"]) {
_context4.next = 5;
break;
}
localState = {};
_context4.next = 4;
return Promise.all(appLocalState["key-value"].map( /*#__PURE__*/function () {
var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(x) {
var key;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
key = Base64Encoder.decode(x.key);
if (x.value.type == 1) {
localState[key] = x.value.bytes;
} else {
localState[key] = x.value.uint;
}
case 2:
case "end":
return _context3.stop();
}
}
}, _callee3);
}));
return function (_x12) {
return _ref3.apply(this, arguments);
};
}()));
case 4:
results[appLocalState.id] = localState;
case 5:
case "end":
return _context4.stop();
}
}
}, _callee4);
}));
return function (_x11) {
return _ref2.apply(this, arguments);
};
}()));
case 7:
return _context5.abrupt("return", results);
case 8:
case "end":
return _context5.stop();
}
}
}, _callee5);
}));
return _getLocalStates.apply(this, arguments);
}
function getAccountBalances(_x6, _x7) {
return _getAccountBalances.apply(this, arguments);
}
/**
* Function to get min balance for an account
*
* @param {Algodv2} algodClient
* @param {string} address
*
* @return {number} min algo balance for an account
*/
function _getAccountBalances() {
_getAccountBalances = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(algodClient, address) {
var results, accountInfo;
return _regeneratorRuntime().wrap(function _callee7$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
results = {};
_context7.next = 3;
return algodClient.accountInformation(address)["do"]();
case 3:
accountInfo = _context7.sent;
results[1] = accountInfo["amount"];
_context7.next = 7;
return Promise.all(accountInfo["assets"].map( /*#__PURE__*/function () {
var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(x) {
return _regeneratorRuntime().wrap(function _callee6$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
results[x["asset-id"]] = x["amount"];
case 1:
case "end":
return _context6.stop();
}
}
}, _callee6);
}));
return function (_x13) {
return _ref4.apply(this, arguments);
};
}()));
case 7:
return _context7.abrupt("return", results);
case 8:
case "end":
return _context7.stop();
}
}
}, _callee7);
}));
return _getAccountBalances.apply(this, arguments);
}
function getAccountMinBalance(_x8, _x9) {
return _getAccountMinBalance.apply(this, arguments);
}
function _getAccountMinBalance() {
_getAccountMinBalance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(algodClient, address) {
var accountInfo;
return _regeneratorRuntime().wrap(function _callee8$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
_context8.next = 2;
return algodClient.accountInformation(address)["do"]();
case 2:
accountInfo = _context8.sent;
return _context8.abrupt("return", accountInfo["min-balance"]);
case 4:
case "end":
return _context8.stop();
}
}
}, _callee8);
}));
return _getAccountMinBalance.apply(this, arguments);
}
function getTransferDetails(txn) {
var assetId = 0;
var amount = 0;
if (txn["tx-type"] == "pay") {
assetId = ALGO_ASSET_ID;
amount = txn['payment-transaction']['amount'];
} else if (txn["tx-type"] == "axfer") {
assetId = txn['asset-transfer-transaction']['asset-id'];
amount = txn['asset-transfer-transaction']['amount'];
}
return [assetId, amount];
}
var TxnLoadMode;
(function (TxnLoadMode) {
TxnLoadMode[TxnLoadMode["REFRESH"] = 0] = "REFRESH";
TxnLoadMode[TxnLoadMode["REVERSE"] = 1] = "REVERSE";
})(TxnLoadMode || (TxnLoadMode = {})); // INTERFACE
var AlgofiUser = /*#__PURE__*/function () {
function AlgofiUser(algofiClient, address) {
// account state
this.balances = {};
this.algofiClient = algofiClient;
this.algod = this.algofiClient.algod;
this.indexer = this.algofiClient.indexer;
this.address = address; // lending
this.lending = this.algofiClient.lending.getUser(this.address); // staking
this.staking = this.algofiClient.staking.getUser(this.address); // v1staking
this.v1Staking = this.algofiClient.v1Staking.getUser(this.address); // governance
this.governance = this.algofiClient.governance.getUser(this.address);
}
var _proto = AlgofiUser.prototype;
_proto.loadState = /*#__PURE__*/function () {
var _loadState = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
var localStates;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return getAccountBalances(this.algod, this.address);
case 2:
this.balances = _context.sent;
_context.next = 5;
return getAccountMinBalance(this.algod, this.address);
case 5:
this.minBalance = _context.sent;
_context.next = 8;
return getLocalStates(this.algod, this.address);
case 8:
localStates = _context.sent;
_context.next = 11;
return this.lending.loadState(localStates);
case 11:
_context.next = 13;
return this.staking.loadState(localStates);
case 13:
_context.next = 15;
return this.v1Staking.loadState(localStates);
case 15:
_context.next = 17;
return this.governance.loadState(localStates);
case 17:
case "end":
return _context.stop();
}
}
}, _callee, this);
}));
function loadState() {
return _loadState.apply(this, arguments);
}
return loadState;
}();
_proto.isOptedInToAsset = function isOptedInToAsset(assetId) {
if (assetId in this.balances) {
return true;
} else {
return false;
}
};
_proto.getTransactionHistory = /*#__PURE__*/function () {
var _getTransactionHistory = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(mode) {
var accountTxns, txnIdx, txn;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
accountTxns = {};
if (mode == TxnLoadMode.REFRESH) {
// clear transactions
this.transactions = [];
}
if (!(mode == TxnLoadMode.REVERSE && this.transactions.length > 0)) {
_context2.next = 9;
break;
}
_context2.next = 6;
return this.indexer.lookupAccountTransactions(this.address).maxRound(this.transactions.slice(-1)[0].block).limit(100)["do"]();
case 6:
accountTxns = _context2.sent;
_context2.next = 12;
break;
case 9:
_context2.next = 11;
return this.indexer.lookupAccountTransactions(this.address).limit(100)["do"]();
case 11:
accountTxns = _context2.sent;
case 12:
for (txnIdx = 0; txnIdx < accountTxns["transactions"].length; txnIdx++) {
txn = accountTxns["transactions"][txnIdx];
if (txn["tx-type"] == "appl") {
if (this.algofiClient.lending.isLendingTransaction(txn)) {
this.lending.parseTransaction(accountTxns["transactions"], txnIdx, this.transactions);
}
}
}
case 13:
case "end":
return _context2.stop();
}
}
}, _callee2, this);
}));
function getTransactionHistory(_x) {
return _getTransactionHistory.apply(this, arguments);
}
return getTransactionHistory;
}();
return AlgofiUser;
}();
var _ManagerConfigs;
var ManagerConfig = function ManagerConfig(appId) {
this.appId = appId;
};
var ManagerConfigs = (_ManagerConfigs = {}, _ManagerConfigs[Network.MAINNET] = /*#__PURE__*/new ManagerConfig(0), _ManagerConfigs[Network.MAINNET_CLONE] = /*#__PURE__*/new ManagerConfig(753081696), _ManagerConfigs[Network.MAINNET_CLONE2] = /*#__PURE__*/new ManagerConfig(802875339), _ManagerConfigs[Network.MAINNET_CLONE3] = /*#__PURE__*/new ManagerConfig(812891680), _ManagerConfigs[Network.TESTNET] = /*#__PURE__*/new ManagerConfig(91633688), _ManagerConfigs);
// ENUMS
var MarketType;
(function (MarketType) {
MarketType[MarketType["STANDARD"] = 0] = "STANDARD";
MarketType[MarketType["STBL"] = 1] = "STBL";
MarketType[MarketType["VAULT"] = 2] = "VAULT";
})(MarketType || (MarketType = {})); // STRING CONSTANTS
var MANAGER_STRINGS = {
// USER STATE
storage_account: "sa",
user_account: "ua",
opted_in_market_count: "omc",
opted_in_markets_page_prefix: "om_",
// APPLICATION CALLS
calculate_user_position: "cup",
farm_ops: "fo",
send_governance_txn: "sgt",
send_keyreg_txn: "skt",
send_keyreg_offline_txn: "skot",
set_market_oracle_parameters: "smop",
storage_account_opt_in: "saoi",
user_asset_opt_in: "uaoi",
user_market_close_out: "umco",
user_market_opt_in: "umoi",
user_opt_in: "uoi",
validate_storage_account_txn: "vsat",
validate_market: "vm"
};
var MARKET_STRINGS = {
// GLOBAL STATE
// static
underlying_asset_id: "uai",
b_asset_id: "bai",
market_type: "mt",
// parameters
borrow_factor: "bf",
collateral_factor: "cf",
flash_loan_fee: "flf",
flash_loan_protocol_fee: "flpf",
max_flash_loan_ratio: "mflr",
liquidation_incentive: "li",
liquidation_fee: "lf",
reserve_factor: "rf",
underlying_supply_cap: "usc",
underlying_borrow_cap: "ubc",
// interest rate model
base_interest_rate: "bir",
base_interest_slope: "bis",
quadratic_interest_amplification_factor: "eiaf",
target_utilization_ratio: "tur",
// oracle
oracle_app_id: "oai",
oracle_price_field_name: "opfn",
oracle_price_scale_factor: "opsf",
// balance
underlying_cash: "uc",
underlying_borrowed: "ub",
underlying_reserves: "ur",
borrow_share_circulation: "bsc",
b_asset_circulation: "bac",
active_b_asset_collateral: "ac",
// interest
latest_time: "lt",
borrow_index: "bi",
implied_borrow_index: "ibi",
// rewards
rewards_admin_prefix: "ra_",
rewards_program_state_prefix: "rps_",
rewards_index_prefix: "ri_",
rewards_escrow_account: "rea",
// stbl market
underlying_protocol_reserve: "upr",
// vault market
opt_in_enabled: "oie",
// USER STATE
user_active_b_asset_collateral: "ubac",
user_borrow_shares: "ubs",
user_rewards_program_number_prefix: "urpn_",
user_latest_rewards_index_prefix: "ulri_",
user_unclaimed_rewards_prefix: "uur_",
// APPLICATION CALLS
farm_ops: "fo",
flash_loan: "fl",
mint_b_asset: "mba",
add_underlying_collateral: "auc",
add_b_asset_collateral: "abc",
burn_b_asset: "br",
remove_underlying_collateral: "ruc",
remove_b_asset_collateral: "rbc",
borrow: "b",
repay_borrow: "rb",
liquidate: "l",
seize_collateral: "sc",
claim_rewards: "cr",
// vault market
sync_vault: "sv"
};
var _MarketConfigs;
var MarketConfig = function MarketConfig(appId, underlyingAssetId, bAssetId, marketType) {
this.appId = appId;
this.underlyingAssetId = underlyingAssetId;
this.bAssetId = bAssetId;
this.marketType = marketType;
};
var MarketConfigs = (_MarketConfigs = {}, _MarketConfigs[Network.MAINNET] = [/*#__PURE__*/new MarketConfig(0, 1, 0, MarketType.STANDARD) // ALGO
], _MarketConfigs[Network.MAINNET_CLONE] = [/*#__PURE__*/new MarketConfig(753107352, 1, 753117075, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753108247, 753101315, 753119272, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753108576, 753101485, 753119789, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753109347, 753101784, 753120193, MarketType.STBL), /*#__PURE__*/new MarketConfig(753110308, 753102180, 753120742, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753110704, 753102376, 753121086, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753110470, 753103642, 753121416, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753110943, 753103963, 753121726, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753111321, 753104158, 753122003, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753111740, 753104718, 753122293, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(753112308, 1, 753122631, MarketType.VAULT) // vALGO
], _MarketConfigs[Network.MAINNET_CLONE2] = [/*#__PURE__*/new MarketConfig(802880734, 1, 802887010, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(802881530, 802871797, 802887476, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(802882874, 802872834, 802887973, MarketType.STBL), /*#__PURE__*/new MarketConfig(802881983, 802873705, 802888469, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(802882365, 802874445, 802888853, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(802883364, 1, 802889344, MarketType.VAULT) // vALGO
], _MarketConfigs[Network.MAINNET_CLONE3] = [/*#__PURE__*/new MarketConfig(812905712, 1, 812910520, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(812916046, 812915205, 812916935, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(812930890, 812930638, 812931295, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(812935796, 812932283, 812936076, MarketType.STBL), /*#__PURE__*/new MarketConfig(812919965, 812919854, 812920370, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(812923132, 812922836, 812924856, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(812928007, 1, 812928844, MarketType.VAULT) // vALGO
], _MarketConfigs[Network.TESTNET] = [/*#__PURE__*/new MarketConfig(91635808, 1, 91638233, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91636097, 91634316, 91638306, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91636162, 91634828, 91638392, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91636638, 91634454, 91638538, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91636680, 91634487, 91638603, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91636742, 91634534, 91638687, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91636787, 91634562, 91638794, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91636896, 91634691, 91638864, MarketType.STANDARD), /*#__PURE__*/new MarketConfig(91637209, 1, 91639146, MarketType.VAULT), /*#__PURE__*/new MarketConfig(91637110, 91634578, 91638952, MarketType.STBL), /*#__PURE__*/new MarketConfig(91636998, 91634736, 91639074, MarketType.STANDARD)], _MarketConfigs);
/**
* Function that returns standard transaction parameters
*
* @param {Algodv2} algodClient
*
* @return params
*/
function getParams(_x) {
return _getParams.apply(this, arguments);
}
/**
* Function to generate payment or asset transfer transactions
*
* @param {SuggestedParams} params
* @param {string} sender
* @param {string} receiver
* @param {int} assetId
* @param {int} amount
*
* @return {Payment or AssetTransfer Transaction}
*/
function _getParams() {
_getParams = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(algodClient) {
var params;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return algodClient.getTransactionParams()["do"]();
case 2:
params = _context.sent;
params.fee = 1000;
params.flatFee = true;
return _context.abrupt("return", params);
case 6:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return _getParams.apply(this, arguments);
}
function getPaymentTxn(params, sender, receiver, assetId, amount) {
if (assetId == 1) {
// send algos
var algoPayment = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
from: sender,
to: receiver,
amount: amount,
suggestedParams: params,
rekeyTo: undefined
});
return algoPayment;
} else {
var asaPayment = algosdk.makeAssetTransferTxnWithSuggestedParamsFromObject({
from: sender,
to: receiver,
amount: amount,
assetIndex: assetId,
suggestedParams: params,
rekeyTo: undefined,
revocationTarget: undefined
});
return asaPayment;
}
}
var Manager = /*#__PURE__*/function () {
function Manager(algod, appId) {
// constatns
this.localMinBalance = 614000;
this.algod = algod;
this.appId = appId;
this.address = getApplicationAddress(this.appId);
}
var _proto = Manager.prototype;
_proto.getOptInTxns = /*#__PURE__*/function () {