@kamino-finance/farms-sdk
Version:
237 lines • 11 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.noOpLogger = void 0;
exports.getAllFarmConfigsAndStates = getAllFarmConfigsAndStates;
exports.getFarmConfigType = getFarmConfigType;
const decimal_js_1 = __importDefault(require("decimal.js"));
const types_1 = require("../@codegen/farms/types");
const utils_1 = require("./utils");
const consts_1 = require("./consts");
const pubkey_1 = require("./pubkey");
exports.noOpLogger = {
log: () => { },
debug: () => { },
warn: () => { },
error: () => { },
};
function getAllFarmConfigsAndStates({ allFarms, logger, markets, strategies, vaults, }) {
const fetchedFarmsForStratsAndReserves = new Set([]);
const collateralFarms = [];
const debtFarms = [];
const strategyFarms = [];
const earnVaultFarms = [];
const standaloneFarms = [];
for (const market of markets) {
for (const reserve of market.reserves) {
if (reserve.farmCollateral !== pubkey_1.DEFAULT_PUBLIC_KEY) {
fetchedFarmsForStratsAndReserves.add(reserve.farmCollateral);
const farmStateCollateral = allFarms.find((farm) => farm.key === reserve.farmCollateral)?.farmState;
if (farmStateCollateral) {
const farmConfig = getFarmConfigType(reserve.farmCollateral, farmStateCollateral, {
type: "reserve",
reserve: reserve.address,
reserveSymbol: reserve.symbol,
market: market.address,
marketName: market.marketName,
strategy: undefined,
vault: undefined,
});
if (farmConfig.scopePrices !== pubkey_1.DEFAULT_PUBLIC_KEY) {
logger.log(`farmPk: ${farmConfig.farmPubkey} scopePrice: ${farmConfig.scopePrices}`);
}
collateralFarms.push({
config: farmConfig,
state: farmStateCollateral,
});
}
else {
logger.log("Could not fetch farm", reserve.farmCollateral);
}
}
if (reserve.farmDebt !== pubkey_1.DEFAULT_PUBLIC_KEY) {
fetchedFarmsForStratsAndReserves.add(reserve.farmDebt);
const farmStateDebt = allFarms.find((farm) => farm.key === reserve.farmDebt)?.farmState;
if (farmStateDebt) {
const farmConfig = getFarmConfigType(reserve.farmDebt, farmStateDebt, {
type: "reserve",
reserve: reserve.address,
reserveSymbol: reserve.symbol,
market: market.address,
marketName: market.marketName,
strategy: undefined,
vault: undefined,
});
if (farmConfig.scopePrices !== pubkey_1.DEFAULT_PUBLIC_KEY) {
logger.log(`farmPk: ${farmConfig.farmPubkey} scopePrice: ${farmConfig.scopePrices}`);
}
debtFarms.push({
config: farmConfig,
state: farmStateDebt,
});
}
else {
logger.log("Could not fetch farm", reserve.farmDebt);
}
}
}
}
for (const strategy of strategies) {
const farmAddress = strategy.farm;
if (farmAddress !== pubkey_1.DEFAULT_PUBLIC_KEY) {
fetchedFarmsForStratsAndReserves.add(farmAddress);
const farmState = allFarms.find((farm) => farm.key === farmAddress)?.farmState;
if (farmState) {
const farmConfig = getFarmConfigType(farmAddress, farmState, {
type: "strategy",
reserve: undefined,
reserveSymbol: undefined,
market: undefined,
marketName: undefined,
strategy: strategy.address,
vault: undefined,
});
// in case strategy is not set on farm side, we override value so we set on next upsert
farmConfig.strategyId = strategy.address;
if (farmConfig.scopePrices !== pubkey_1.DEFAULT_PUBLIC_KEY) {
logger.log(`farmPk: ${farmConfig.farmPubkey} scopePrice: ${farmConfig.scopePrices}`);
}
strategyFarms.push({
config: farmConfig,
state: farmState,
});
}
else {
logger.log("Could not fetch farm", farmAddress);
}
}
}
for (const vault of vaults) {
const farmAddress = vault.vaultFarm;
if (farmAddress !== pubkey_1.DEFAULT_PUBLIC_KEY) {
fetchedFarmsForStratsAndReserves.add(farmAddress);
const farmState = allFarms.find((farm) => farm.key === farmAddress)?.farmState;
if (farmState) {
const farmConfig = getFarmConfigType(farmAddress, farmState, {
type: "earnVault",
reserve: undefined,
reserveSymbol: undefined,
market: undefined,
marketName: undefined,
strategy: undefined,
vault: vault.address,
});
// in case vaultId is not set on farm side, we override value so we set on next upsert
farmConfig.vaultId = vault.address;
if (farmConfig.scopePrices !== pubkey_1.DEFAULT_PUBLIC_KEY) {
logger.log(`farmPk: ${farmConfig.farmPubkey} scopePrice: ${farmConfig.scopePrices}`);
}
earnVaultFarms.push({
config: farmConfig,
state: farmState,
});
}
else {
logger.log("Could not fetch farm", farmAddress);
}
}
}
for (const farmAndKey of allFarms) {
// skip farms already processed as part of reserves, strategies, or vaults
if (fetchedFarmsForStratsAndReserves.has(farmAndKey.key)) {
continue;
}
const farmConfig = getFarmConfigType(farmAndKey.key, farmAndKey.farmState, {
type: "standalone",
reserve: undefined,
reserveSymbol: undefined,
market: undefined,
marketName: undefined,
strategy: undefined,
vault: undefined,
});
if (farmConfig.scopePrices !== pubkey_1.DEFAULT_PUBLIC_KEY) {
logger.log(`farmPk: ${farmConfig.farmPubkey} scopePrice: ${farmConfig.scopePrices}`);
}
standaloneFarms.push({
config: farmConfig,
state: farmAndKey.farmState,
});
}
return {
collateralFarms,
debtFarms,
strategyFarms,
earnVaultFarms,
standaloneFarms,
};
}
function getRewardType(rewardType) {
const name = types_1.RewardType[rewardType];
if (name === undefined) {
throw new Error(`Invalid reward type: ${rewardType}`);
}
return name;
}
function getFarmConfigType(farmKey, farmState, farmMetadata) {
return {
farmMetadata,
farmPubkey: farmKey,
stakingTokenMint: farmState.token.mint,
withdrawAuthority: farmState.withdrawAuthority,
globalConfig: farmState.globalConfig,
strategyId: farmState.strategyId, // reserve farm
vaultId: farmState.vaultId,
depositCapAmount: new decimal_js_1.default(farmState.depositCapAmount.toString()).toNumber(),
rewards: farmState.rewardInfos
.map((rewardInfo) => {
if (rewardInfo.token.mint !== pubkey_1.DEFAULT_PUBLIC_KEY) {
return {
rewardTokenMint: rewardInfo.token.mint,
rewardType: getRewardType(rewardInfo.rewardType),
rewardPerSecondDecimals: rewardInfo.rewardsPerSecondDecimals,
minClaimDurationSeconds: new decimal_js_1.default(rewardInfo.minClaimDurationSeconds.toString()).toNumber(),
rewardCurve: rewardInfo.rewardScheduleCurve.points
.map((point) => {
if (new decimal_js_1.default(point.rewardPerTimeUnit.toString()).toNumber() !==
0 ||
point.tsStart.toString() !== consts_1.U64_MAX) {
return {
startTs: new decimal_js_1.default(point.tsStart.toString()).toNumber(),
rps: new decimal_js_1.default(point.rewardPerTimeUnit.toString()).toNumber(),
};
}
return undefined;
})
.filter((point) => point !== undefined),
rewardAvailable: (0, utils_1.lamportsToCollDecimal)(new decimal_js_1.default(rewardInfo.rewardsAvailable.toString()), Number(rewardInfo.token.decimals))
.floor()
.toNumber(),
rewardToTopUp: 0,
rewardToTopUpDurationDays: 0,
};
}
return undefined;
})
.filter((rewardInfoConfig) => rewardInfoConfig !== undefined),
farmAdmin: farmState.farmAdmin,
pendingFarmAdmin: farmState.pendingFarmAdmin,
delegateAuthority: farmState.delegateAuthority,
isRewardUserOnceEnabled: farmState.isRewardUserOnceEnabled,
scopePrices: farmState.scopePrices,
scopePriceOracleId: farmState.scopeOraclePriceId.toString(),
scopeOracleMaxAge: new decimal_js_1.default(farmState.scopeOracleMaxAge.toString()).toNumber(),
lockingMode: new decimal_js_1.default(farmState.lockingMode.toString()).toNumber(),
lockingStart: new decimal_js_1.default(farmState.lockingStartTimestamp.toString()).toNumber(),
lockingDuration: new decimal_js_1.default(farmState.lockingDuration.toString()).toNumber(),
lockingEarlyWithdrawalPenaltyBps: new decimal_js_1.default(farmState.lockingEarlyWithdrawalPenaltyBps.toString()).toNumber(),
depositWarmupPeriod: farmState.depositWarmupPeriod,
withdrawCooldownPeriod: farmState.withdrawalCooldownPeriod,
slashedAmountSpillAddress: farmState.slashedAmountSpillAddress,
delegatedRpsAdmin: farmState.delegatedRpsAdmin,
secondDelegatedAuthority: farmState.secondDelegatedAuthority,
};
}
//# sourceMappingURL=farms.js.map