@augustdigital/pools
Version:
External services interactions
633 lines • 28.3 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.isBadVault = exports.LOANS_APR_DECIMALS = exports.determineBlockSkipInternal = exports.determineBlockCutoff = void 0;
exports.getPoolsData = getPoolsData;
exports.getPoolLoans = getPoolLoans;
exports.getTokenizedPoolData = getTokenizedPoolData;
exports.getPoolLoansData = getPoolLoansData;
exports.getPoolBorrowerHealthFactor = getPoolBorrowerHealthFactor;
const utils_1 = require("@augustdigital/utils");
const abis_1 = require("@augustdigital/abis");
const utils_2 = require("@augustdigital/utils");
const ethers_1 = require("ethers");
const utils_3 = require("@augustdigital/utils");
const ethers_2 = require("ethers");
const filterOutBySize = (usdAmount) => usdAmount > 10000;
const determineBlockCutoff = (chain) => {
switch (chain) {
case 56:
return 120000;
case 43114:
return 120000;
default:
return 150000;
}
};
exports.determineBlockCutoff = determineBlockCutoff;
const determineBlockSkipInternal = (chain) => {
switch (chain) {
case 43114:
return 8000;
case 56:
return 8000;
default:
return 50000;
}
};
exports.determineBlockSkipInternal = determineBlockSkipInternal;
function addToTokenExposure(token, tokenExposure, isBorrow, protocol) {
const usdAmount = Number(token?.price || 0) * Number(token?.amount);
const foundTokenExposure = tokenExposure.find((t) => t.symbol === token?.symbol);
if (foundTokenExposure) {
foundTokenExposure.amount += usdAmount;
}
else {
const protoReturnObj = {
id: token?.id,
chain: token?.chain,
name: token?.name,
symbol: token?.optimized_symbol || token?.symbol,
decimals: token?.decimals,
logoUrl: token?.logo_url,
amount: usdAmount,
protocol: protocol,
};
tokenExposure.push(protoReturnObj);
}
}
function parseLoanLevelDebank(debankRes) {
let positions = [];
let exposure = [];
try {
const protocolExposures = debankRes?.subaccount?.positions || [];
positions = protocolExposures?.map((p) => ({
value: p.logo_url,
label: p.name,
}));
exposure = protocolExposures?.map((p) => p.portfolio_item_list?.map((li) => {
const extra = {
value: li.pool?.controller,
label: li.pool?.adapter_id,
usd: li?.stats?.asset_usd_value,
};
if (li.detail?.supply_token_list?.length) {
const returnArr = li.detail?.supply_token_list?.map((t) => ({
value: t?.id,
label: t?.symbol,
usd: t?.amount * t?.price,
}));
return [...returnArr, extra];
}
return extra;
}));
exposure = exposure?.flat()?.flat();
const uniqueExposure = [];
exposure?.forEach(function (a) {
if (!this[a.value]) {
if (a?.value === '0xa1290d69c65a6fe4df752f95823fae25cb99e5a7') {
this[a.value] = { ...a, label: 'rsETH' };
}
else {
this[a.value] = { ...a };
}
uniqueExposure.push(this[a.value]);
}
this[a.value].usd += a.usd;
}, Object.create(null));
exposure = uniqueExposure;
}
catch (err) {
console.error('#getPoolLoansData::strategies:', err);
}
return { exposure, positions };
}
function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure) {
const tokenMap = {};
const protocolTokenMap = {};
const protocolExposures = debankRes?.subaccount?.positions || [];
const tokenExposures = debankRes?.subaccount?.tokens || [];
protocolExposures.forEach((pos) => {
const protoReturnObj = {
id: pos?.id,
chain: pos?.chain,
protocol: pos?.name,
logoUrl: pos?.logo_url,
siteUrl: pos?.site_url,
assetUsdValue: 0,
debtUsdValue: 0,
netUsdValue: 0,
label: pos?.portfolio_item_list?.[0]?.name,
tokenExposure: tokenMap,
protocolExposure: protocolTokenMap,
address: '',
};
pos?.portfolio_item_list?.forEach((item) => {
protoReturnObj.assetUsdValue += item?.stats?.asset_usd_value || 0;
protoReturnObj.debtUsdValue += item?.stats?.debt_usd_value || 0;
protoReturnObj.netUsdValue += item?.stats?.net_usd_value || 0;
});
const foundExistingProtocolExposure = protocolExposure.find((exp) => exp.id === pos.id);
if (!foundExistingProtocolExposure &&
filterOutBySize(protoReturnObj.netUsdValue)) {
protocolExposure.push(protoReturnObj);
}
else if (foundExistingProtocolExposure) {
foundExistingProtocolExposure.netUsdValue += protoReturnObj.netUsdValue;
foundExistingProtocolExposure.debtUsdValue += protoReturnObj.debtUsdValue;
foundExistingProtocolExposure.assetUsdValue +=
protoReturnObj.assetUsdValue;
}
pos.portfolio_item_list.forEach((item) => {
item.detail.supply_token_list.forEach((sup) => {
if (sup?.protocol_id) {
const existingArray = protocolTokenMap[sup.protocol_id] || [];
if (!existingArray.includes(sup.symbol))
existingArray.push(sup.symbol);
}
addToTokenExposure(sup, tokenExposure, false, pos.id);
if (sup?.symbol && sup?.logo_url) {
tokenMap[sup.symbol] = sup.logo_url;
}
});
item.detail.borrow_token_list.forEach((bor) => {
addToTokenExposure(bor, tokenExposure, true, pos.id);
if (bor?.symbol && bor?.logo_url) {
tokenMap[bor.symbol] = bor.logo_url;
}
});
});
});
tokenExposures?.forEach((token) => {
addToTokenExposure(token, tokenExposure, false);
});
return { tokenMap, protocolTokenMap, protocolExposures, tokenExposures };
}
exports.LOANS_APR_DECIMALS = 2;
const isBadVault = (address) => {
switch (address.toLowerCase()) {
case '0x706162790b601A8514c18718d0c63C9D1268e89C'.toLowerCase():
return true;
case '0xd684AF965b1c17D628ee0d77cae94259c41260F4'.toLowerCase():
return true;
case '0xB78dAf3fD674B81ebeaaa88d711506fa069E1C5E'.toLowerCase():
return true;
case '0x4e2D90f0307A93b54ACA31dc606F93FE6b9132d2'.toLowerCase():
return true;
case '0x18a5a3D575F34e5eBa92ac99B0976dBe26f9F869'.toLowerCase():
return true;
default:
return false;
}
};
exports.isBadVault = isBadVault;
const functionsToCall = [
'decimals',
'asset',
'totalSupply',
'totalAssets',
'maxSupply',
'withdrawalFee',
];
async function getPoolsData({ env, pools, rpcUrl, tokenizedVaults, functions = functionsToCall, }) {
const provider = (0, utils_2.createProvider)(rpcUrl);
try {
const contracts = await Promise.all(pools.map((pool) => {
const contract = (0, utils_2.createContract)({
address: pool,
abi: abis_1.ABI_LENDING_POOLS,
provider,
});
return Promise.all(functions.map((f) => {
return contract[f]();
}));
}));
const formatted = contracts
.map((contract) => contract.reduce((acc, curr, i) => {
let val;
if (functions[i] === 'totalSupply' ||
functions[i] === 'totalAssets' ||
functions[i] === 'globalLoansAmount' ||
functions[i] === 'maxSupply') {
val = (0, utils_2.toNormalizedBn)(curr, contract[0]);
}
else if (functions[i] === 'getTotalLoansDeployed') {
val = (0, utils_2.toNormalizedBn)(curr, 0);
}
else if (functions[i] === 'withdrawalFee') {
val = (0, utils_2.toNormalizedBn)(curr, 2);
}
else if (functions[i] === 'decimals') {
val = Number(curr.toString());
}
else if (functions[i] === 'loansOperator') {
val = '0x4DCb388488622e47683EAd1a147947140a31e485';
}
else {
val = curr;
}
return { ...acc, [functions[i]]: val };
}, {}))
.reduce((acc, curr, i) => {
return { ...acc, [pools[i]]: curr };
}, {});
const withUnderlyingAsset = await Promise.all(Object.keys(formatted).map(async (key) => {
let symbol;
let decimals = 18;
const foundTokenizedVault = tokenizedVaults.find((tv) => tv.address === key);
if (!foundTokenizedVault) {
throw new Error(`Tokenized vault config not found for address: ${key}`);
}
let globalLoansAmount = (0, utils_2.toNormalizedBn)(0);
let getTotalLoansDeployed = (0, utils_2.toNormalizedBn)(0);
const isInternalTypeTokenizedVault = foundTokenizedVault.internal_type === 'tokenizedVault';
if (!isInternalTypeTokenizedVault) {
const contract = (0, utils_2.createContract)({
address: key,
abi: abis_1.ABI_LENDING_POOLS,
provider,
});
const globalLoansAmountRes = await contract.globalLoansAmount();
const totalLoansDeployedRes = await contract.getTotalLoansDeployed();
globalLoansAmount = (0, utils_2.toNormalizedBn)(globalLoansAmountRes, formatted?.[key]?.decimals);
getTotalLoansDeployed = (0, utils_2.toNormalizedBn)(totalLoansDeployedRes, 0);
}
if ((0, ethers_1.isAddress)(formatted?.[key]?.asset) &&
formatted[key].asset !== ethers_1.ZeroAddress) {
const [fetchedSymbol, fetchedDecimals] = await (0, utils_2.getTokenMetadata)(provider, formatted[key].asset, ['symbol', 'decimals']);
symbol = fetchedSymbol;
decimals = fetchedDecimals;
}
const isOldLendingPool = utils_2.OLD_LENDING_POOLS.includes(key);
let managementFee = undefined;
let idleAssets;
if (!isOldLendingPool) {
managementFee = await (0, utils_1.getManagementFeePercent)(provider, key);
idleAssets = await (0, utils_2.createContract)({
provider,
address: formatted[key].asset,
abi: abis_1.ABI_ERC20,
}).balanceOf(key);
}
else {
idleAssets =
BigInt(formatted[key].totalAssets.raw) -
BigInt(globalLoansAmount.raw);
}
const returnObj = {
...formatted[key],
idleAssets: (0, utils_2.toNormalizedBn)(idleAssets, formatted[key].decimals),
getTotalLoansDeployed,
globalLoansAmount,
chainId: Number((await provider.getNetwork()).chainId),
address: key,
managementFee: managementFee,
underlying: {
symbol: symbol,
decimals: Number(decimals.toString()),
address: formatted[key].asset,
chain: Number((await provider.getNetwork()).chainId),
},
};
const strategistAddress = foundTokenizedVault.subaccounts?.find((a) => !!a.strategist?.id)
?.address ?? foundTokenizedVault.subaccounts?.[0]?.address;
const strategist = foundTokenizedVault.hardcoded_strategists[0];
const upshiftPointRewards = foundTokenizedVault.rewards?.filter((r) => r.text === 'Upshift Points');
const sortedPointsMultipliers = upshiftPointRewards?.sort((a, b) => new Date(b.start_datetime).getTime() -
new Date(a.start_datetime).getTime());
const upshiftPointsMultipliers = sortedPointsMultipliers?.map((r) => ({
timestamp: new Date(r.start_datetime).getTime() / 1000,
multiplier: r.multiplier,
}));
const latestUpshiftPointMultiplier = upshiftPointsMultipliers?.[0]?.multiplier;
const formattedTokenizedVault = {
description: foundTokenizedVault.description,
rewards: {
upshift_points: !!upshiftPointRewards.length
? `${latestUpshiftPointMultiplier}x Upshift Points`
: '',
latestUpshiftPointMultiplier,
upshift_points_multipliers: upshiftPointsMultipliers,
additional_points: foundTokenizedVault.rewards.map((r) => `${r.multiplier !== 1 ? `${r.multiplier}x` : ''} ${r.text}`),
},
hardcodedStrategist: strategistAddress,
strategist,
symbol: foundTokenizedVault.receipt_token_symbol,
internalType: foundTokenizedVault.internal_type,
publicType: foundTokenizedVault.public_type,
...(foundTokenizedVault.platform_fee_override?.management_fee && {
managementFee: foundTokenizedVault.platform_fee_override?.management_fee,
}),
...(foundTokenizedVault.platform_fee_override?.is_fee_waived && {
isFeeWaived: foundTokenizedVault.platform_fee_override?.is_fee_waived,
}),
...(foundTokenizedVault.weekly_performance_fee_bps && {
performanceFee: foundTokenizedVault.weekly_performance_fee_bps,
}),
...(foundTokenizedVault.reported_apy?.apy && {
apy: foundTokenizedVault.reported_apy?.apy * 100,
}),
name: foundTokenizedVault.vault_name,
logoUrl: foundTokenizedVault.vault_logo_url,
isFeatured: foundTokenizedVault.is_featured,
isVisible: foundTokenizedVault.is_visible,
risk: foundTokenizedVault.risk,
};
return {
...returnObj,
...formattedTokenizedVault,
loansOperator: strategistAddress || returnObj?.loansOperator || '',
};
}));
if (env === 'DEV')
console.log('#getPoolsData:', withUnderlyingAsset);
return withUnderlyingAsset;
}
catch (e) {
console.error('#getPoolsData:', e);
}
}
async function getPoolLoans({ pool, rpcUrl, env, }) {
if (pool.internalType === 'tokenizedVault')
return [];
const provider = (0, utils_2.createProvider)(rpcUrl);
let loans = [];
if (BigInt(pool.getTotalLoansDeployed.raw) > BigInt(0)) {
const indexArray = [
...Array(Number(pool.getTotalLoansDeployed.raw)).keys(),
];
loans = await Promise.all(indexArray.map((i) => {
const poolContract = (0, utils_2.createContract)({
address: pool.address,
abi: abis_1.ABI_LENDING_POOLS,
provider,
});
const loansDeployed = poolContract.loansDeployed(BigInt(i));
return loansDeployed;
}));
}
if (pool?.chainId === 1) {
const loanToExclude1 = loans.findIndex((loan) => (0, ethers_2.getAddress)(loan) ===
(0, ethers_2.getAddress)('0xb1dAA4956821521b53E90BA44509534b934f647f'));
loans.splice(loanToExclude1, 1);
}
return loans;
}
async function getTokenizedPoolData({ pool, rpcUrl, env, strategies, apiKey, }) {
const provider = (0, utils_2.createProvider)(rpcUrl);
const network = await provider.getNetwork();
let returnObj = {
apy: 0,
collateral: [],
loans: [],
protocolExposure: [],
tokenExposure: [],
cefiExposure: [],
};
let protocolExposure = [];
let tokenExposure = [];
let cefiExposure = [];
try {
const tokenizedVault = (await (0, utils_1.fetchTokenizedVaults)(pool.address))?.[0];
const foundWhitelistedSubaccounts = tokenizedVault.internal_type === 'tokenizedVault'
? tokenizedVault.subaccounts?.map((s) => s.address)
: [];
if (foundWhitelistedSubaccounts?.length) {
const morphoApyResponses = await Promise.all(foundWhitelistedSubaccounts?.map((whitelistedSubaccount) => (0, utils_1.fetchAugustPublic)(`${utils_2.WEBSERVER_ENDPOINTS.public.integrations.morpho.apy(whitelistedSubaccount, pool.address)}&chain=${Number(network.chainId)}`)));
let cumulativeApy = 0;
let collateral = [];
if (morphoApyResponses?.length) {
for (const res of morphoApyResponses) {
if (res.status === 200) {
const jsonRes = (await res.json());
cumulativeApy += jsonRes.apy * 100;
collateral.push(jsonRes.token.address);
}
}
}
const uniqueBorrowers = foundWhitelistedSubaccounts;
let debankBorrowerResponses = {};
let cefiBorrowerResponses = {};
let otcPositions = {};
for (const b of uniqueBorrowers) {
const debankResponse = await (0, utils_2.fetchAugustWithKey)(apiKey, utils_2.WEBSERVER_ENDPOINTS.subaccount.debank(b));
console.log('#getTokenizedPoolData::defi:', debankResponse.status, debankResponse.statusText);
if (debankResponse.status === 200) {
const debankRes = await debankResponse.json();
debankBorrowerResponses[b] = debankRes;
parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure);
}
const cefiResponse = await (0, utils_2.fetchAugustWithKey)(apiKey, utils_2.WEBSERVER_ENDPOINTS.subaccount.cefi(b));
console.log('#getTokenizedPoolData::cefi:', cefiResponse.status, cefiResponse.statusText);
if (cefiResponse.status === 200) {
const cefiRes = (await cefiResponse.json());
cefiBorrowerResponses[b] = cefiRes;
cefiExposure = cefiRes;
}
const otcResponse = await (0, utils_2.fetchAugustWithKey)(apiKey, utils_2.WEBSERVER_ENDPOINTS.subaccount.otc_positions(b));
console.log('#getTokenizedPoolData::otc:', otcResponse.status, otcResponse.statusText);
if (otcResponse.status === 200) {
const otcRes = (await otcResponse.json());
otcPositions[b] = otcRes;
}
}
const tokenizedVaultApy = tokenizedVault?.reported_apy?.apy &&
tokenizedVault?.reported_apy?.apy * 100;
returnObj = {
apy: tokenizedVaultApy || cumulativeApy / morphoApyResponses?.length,
collateral,
loans: [],
tokenExposure: tokenExposure.filter((t) => filterOutBySize(t.amount)),
protocolExposure,
cefiExposure,
debankBorrowerResponses,
otcPositions,
vaultsSubAccWhitelist: foundWhitelistedSubaccounts || [],
};
}
if (env === 'DEV')
console.log('#getTokenizedPoolData:', returnObj);
return returnObj;
}
catch (e) {
return returnObj;
}
}
async function getPoolLoansData({ pool, loans, rpcUrl, env, strategies, apiKey, }) {
const provider = (0, utils_2.createProvider)(rpcUrl);
let returnObj = {
apy: 0,
collateral: [],
loans: [],
protocolExposure: [],
tokenExposure: [],
cefiExposure: [],
};
let protocolExposure = [];
let tokenExposure = [];
let cefiExposure = [];
let debankBorrowerResponses = {};
let cefiBorrowerResponses = {};
let otcPositions = {};
try {
if (pool.internalType === 'tokenizedVault') {
const tokenizedVaultData = await getTokenizedPoolData({
pool,
rpcUrl,
env,
strategies,
apiKey,
});
returnObj = tokenizedVaultData;
}
else {
const tokenizedVault = (await (0, utils_1.fetchTokenizedVaults)(pool.address))?.[0];
const foundWhitelistedSubaccounts = tokenizedVault.subaccounts?.map((s) => s.address);
let aggregateApr = BigInt(0);
const collateralTokens = [];
const activeLoans = (await Promise.all(loans.map(async (l) => {
const loanContract = (0, utils_2.createContract)({
provider,
address: l,
abi: abis_1.ABI_LOAN,
});
const loanState = await loanContract.loanState();
if ((0, utils_2.loanStateToReadable)(loanState) !== 'ACTIVE')
return;
return l;
}))).filter((l) => l !== undefined);
const formattedLoansArray = await Promise.all(activeLoans.map(async (l) => {
const loanContract = (0, utils_2.createContract)({
provider,
address: l,
abi: abis_1.ABI_LOAN,
});
return {
borrower: await loanContract.borrower(),
loan: l,
};
}));
const uniqueBorrowers = [
...new Set(formattedLoansArray.map((l) => l.borrower)),
];
for (const borrower of uniqueBorrowers) {
const debankResponse = await (0, utils_2.fetchAugustWithKey)(apiKey, utils_2.WEBSERVER_ENDPOINTS.subaccount.debank(borrower));
console.log('#getPoolLoansData::defi:', debankResponse.status, debankResponse.statusText);
if (debankResponse.status === 200) {
const debankRes = await debankResponse.json();
debankBorrowerResponses[borrower] = debankRes;
parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure);
}
const cefiResponse = await (0, utils_2.fetchAugustWithKey)(apiKey, utils_2.WEBSERVER_ENDPOINTS.subaccount.cefi(borrower));
console.log('#getPoolLoansData::cefi:', cefiResponse.status, cefiResponse.statusText);
if (cefiResponse.status === 200) {
const cefiRes = (await cefiResponse.json());
cefiBorrowerResponses[borrower] = cefiRes;
cefiExposure = cefiRes;
}
const otcResponse = await (0, utils_2.fetchAugustWithKey)(apiKey, utils_2.WEBSERVER_ENDPOINTS.subaccount.otc_positions(borrower));
console.log('#getPoolLoansData::otc:', otcResponse.status, otcResponse.statusText);
if (otcResponse.status === 200) {
const otcRes = (await otcResponse.json());
otcPositions[borrower] = otcRes;
}
}
const newLoans = (await Promise.all(formattedLoansArray?.map(async (loanObj) => {
const loanContract = (0, utils_2.createContract)({
provider,
address: loanObj.loan,
abi: abis_1.ABI_LOAN,
});
const borrower = loanObj.borrower;
const [_loanApr, _principalAmt, _collateral, _principalRepaid] = await Promise.all([
loanContract.currentApr(),
loanContract.principalAmount(),
loanContract.collateralToken(),
loanContract.principalRepaid(),
]);
aggregateApr += _loanApr || BigInt(0);
if (!collateralTokens.includes(_collateral))
collateralTokens.push(_collateral);
const allocation = Number((0, ethers_1.formatUnits)(_principalAmt, pool?.decimals)) /
Number((0, ethers_1.formatUnits)(pool?.totalSupply?.raw, pool?.decimals));
const loanFeeRate = await (0, utils_3.getLoanOracleFeeRate)(provider, 'LOAN.REPAY.INTERESTS', loanObj.loan, pool?.chainId);
const loanApr = Number(_loanApr || 0) / 100;
const loanAprAfterFees = loanApr * (1 - loanFeeRate / 100);
const isIdleCapital = utils_1.IDLE_CAPITAL_BORROWER_ADDRESS.includes(borrower);
const { positions, exposure } = parseLoanLevelDebank(debankBorrowerResponses[borrower]);
const newLoanObj = {
address: loanObj.loan,
apr: loanAprAfterFees,
collateral: _collateral,
principal: (0, utils_2.toNormalizedBn)(_principalAmt, pool?.underlying?.decimals),
repaid: (0, utils_2.toNormalizedBn)(_principalRepaid, pool?.chainId),
allocation,
positions,
exposure,
borrower,
augustFee: loanFeeRate,
idleCapital: isIdleCapital,
};
return newLoanObj;
}))).filter((l) => l !== undefined);
const weightedAverage = newLoans.reduce((acc, { apr, allocation }) => acc + apr * allocation, 0);
returnObj = {
apy: pool.apy ? pool.apy : weightedAverage,
collateral: collateralTokens,
loans: newLoans,
tokenExposure: tokenExposure.filter((t) => filterOutBySize(t.amount)),
protocolExposure,
cefiExposure,
debankBorrowerResponses,
otcPositions,
vaultsSubAccWhitelist: foundWhitelistedSubaccounts || [],
};
}
if (env === 'DEV')
console.log('#getPoolLoansData:', returnObj);
return returnObj;
}
catch (e) {
return returnObj;
}
}
async function getPoolBorrowerHealthFactor({ pool, rpcUrl, env, apiKey, }) {
const provider = (0, utils_2.createProvider)(rpcUrl);
const loans = await getPoolLoans({ pool, rpcUrl, env });
const activeLoans = (await Promise.all(loans.map(async (l) => {
const loanContract = (0, utils_2.createContract)({
provider,
address: l,
abi: abis_1.ABI_LOAN,
});
const loanState = await loanContract.loanState();
if ((0, utils_2.loanStateToReadable)(loanState) !== 'ACTIVE')
return;
return l;
}))).filter((l) => l !== undefined);
const formattedLoansArray = await Promise.all(activeLoans.map(async (l) => {
const loanContract = (0, utils_2.createContract)({
provider,
address: l,
abi: abis_1.ABI_LOAN,
});
return {
borrower: await loanContract.borrower(),
loan: l,
};
}));
const uniqueBorrowers = [
...new Set(formattedLoansArray.map((l) => l.borrower)),
];
let borrowerResponses = {};
for (const b of uniqueBorrowers) {
const response = await (0, utils_2.fetchAugustWithKey)(apiKey, utils_2.WEBSERVER_ENDPOINTS.subaccount.health_factor(b));
if (response.status === 200) {
borrowerResponses[b] = await response.json();
}
}
formattedLoansArray?.map((loan) => {
loan.health_factor = borrowerResponses[loan.borrower];
});
return formattedLoansArray;
}
//# sourceMappingURL=helpers.js.map