@kamino-finance/klend-sdk/dist/utils/userMetadata.js

Typescript SDK for interacting with the Kamino Lending (klend) protocol

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getUserLutAddressAndSetupIxns = void 0;
exports.getAllUserMetadatasWithFilter = getAllUserMetadatasWithFilter;
const web3_js_1 = require("@solana/web3.js");
const lib_1 = require("../lib");
const farms_sdk_1 = require("@kamino-finance/farms-sdk");
const getUserLutAddressAndSetupIxns = async (kaminoMarket, user, referrer = web3_js_1.PublicKey.default, withExtendLut = true, multiplyMints = [], leverageMints = [], repayWithCollObligation = undefined, payer = web3_js_1.PublicKey.default) => {
    const [userMetadataAddress, userMetadataState] = await kaminoMarket.getUserMetadata(user);
    const initUserMetadataIxs = [];
    let userLookupTableAddress;
    const referrerUserMetadata = referrer.equals(web3_js_1.PublicKey.default)
        ? kaminoMarket.programId
        : (await kaminoMarket.getUserMetadata(referrer))[0];
    if (!userMetadataState) {
        const [createLutIx, lookupTableAddress] = await (0, lib_1.createLookupTableIx)(kaminoMarket.getConnection(), user);
        userLookupTableAddress = lookupTableAddress;
        initUserMetadataIxs.push(createLutIx);
        initUserMetadataIxs.push((0, lib_1.initUserMetadata)({
            userLookupTable: lookupTableAddress,
        }, {
            owner: user,
            feePayer: payer.equals(web3_js_1.PublicKey.default) ? user : payer,
            userMetadata: userMetadataAddress,
            referrerUserMetadata: referrerUserMetadata,
            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
            systemProgram: web3_js_1.SystemProgram.programId,
        }, kaminoMarket.programId));
    }
    else {
        userLookupTableAddress = userMetadataState.userLookupTable;
    }
    const setupUserMetadataIxs = [initUserMetadataIxs];
    if (withExtendLut) {
        const dedupUserLutAddresses = await getDedupUserLookupTableAddresses(kaminoMarket, userLookupTableAddress, user, referrer, multiplyMints, leverageMints, userMetadataState !== null, repayWithCollObligation);
        const extendLookupTableChunkIxs = (0, lib_1.extendLookupTableIxs)(user, userLookupTableAddress, dedupUserLutAddresses, payer);
        for (const extendLutIx of extendLookupTableChunkIxs) {
            setupUserMetadataIxs.push([extendLutIx]);
        }
    }
    return [userLookupTableAddress, setupUserMetadataIxs];
};
exports.getUserLutAddressAndSetupIxns = getUserLutAddressAndSetupIxns;
const getDedupUserLookupTableAddresses = async (kaminoMarket, table_pk, user, referrer, multiplyMints = [], leverageMints = [], tableExists, repayWithCollObligation = undefined) => {
    const requiredAddresses = await getUserLookupTableAddresses(kaminoMarket, user, referrer, multiplyMints, leverageMints, repayWithCollObligation);
    if (tableExists) {
        const userLookupTable = (await kaminoMarket.getConnection().getAddressLookupTable(table_pk)).value?.state;
        const addressesAndLogsNotInLut = requiredAddresses.filter((addressAndLogs) => userLookupTable.addresses.filter((a) => a.equals(addressAndLogs.address)).length === 0);
        console.log('Addresses to be added in LUT:');
        const addressNotInLut = addressesAndLogsNotInLut.map((addressAndLogs) => {
            console.log(addressAndLogs.log);
            return addressAndLogs.address;
        });
        return new lib_1.PublicKeySet(addressNotInLut).toArray();
    }
    else {
        const addressNotInLut = requiredAddresses.map((addressAndLogs) => {
            console.log(addressAndLogs.log);
            return addressAndLogs.address;
        });
        return new lib_1.PublicKeySet(addressNotInLut).toArray();
    }
};
const getUserLookupTableAddresses = async (kaminoMarket, user, referrer, multiplyMints = [], leverageMints = [], repayWithCollObligation = undefined) => {
    const addresses = [];
    addresses.push({ address: user, log: 'user address' });
    const [userMetadataAddress] = (0, lib_1.userMetadataPda)(user, kaminoMarket.programId);
    addresses.push({ address: userMetadataAddress, log: 'userMetadata address' });
    const allMints = [];
    multiplyMints.forEach(({ coll: collMint, debt: debtMint }) => {
        allMints.push(collMint);
        allMints.push(debtMint);
    });
    leverageMints.forEach(({ coll: collMint, debt: debtMint }) => {
        allMints.push(collMint);
        allMints.push(debtMint);
    });
    if (repayWithCollObligation) {
        repayWithCollObligation.borrows.forEach((borrow) => {
            allMints.push(borrow.mintAddress);
        });
        repayWithCollObligation.deposits.forEach((deposit) => {
            allMints.push(deposit.mintAddress);
        });
    }
    const dedupMints = [...new lib_1.PublicKeySet(allMints).toArray()];
    const reserves = [];
    dedupMints.forEach((mint) => {
        const kaminoReserve = kaminoMarket.getReserveByMint(mint);
        if (kaminoReserve) {
            reserves.push(kaminoReserve);
        }
    });
    // reserve mint ATAs
    const mintsAtas = await Promise.all(dedupMints.map(async (mint) => {
        return { address: await (0, lib_1.getAssociatedTokenAddress)(mint, user), log: 'ata for mint ' + mint.toString() };
    }));
    addresses.push(...mintsAtas);
    // ctoken ATAs
    const ctokenMintsAtas = await Promise.all(reserves.map(async (reserve) => {
        const ctokenMint = reserve.getCTokenMint();
        return {
            address: await (0, lib_1.getAssociatedTokenAddress)(ctokenMint, user),
            log: 'ctoken ata for reserve ' + reserve.address.toString(),
        };
    }));
    addresses.push(...ctokenMintsAtas);
    // farm states
    const farmCollateralStates = reserves.map((reserve) => reserve.state.farmCollateral);
    const farmDebtStates = reserves.map((reserve) => reserve.state.farmDebt);
    const farmStates = new lib_1.PublicKeySet(farmCollateralStates.concat(farmDebtStates).filter((address) => (0, lib_1.isNotNullPubkey)(address)));
    const farmStatesAdressesAndLogs = farmStates.toArray().map((address) => {
        return { address: address, log: 'farm state' };
    });
    addresses.push(...farmStatesAdressesAndLogs);
    // referrer token states
    const referrerTokenStates = reserves.map((reserve) => {
        return {
            address: (0, lib_1.referrerTokenStatePda)(referrer, reserve.address, kaminoMarket.programId)[0],
            log: 'referrer token state for reserve ' + reserve.address,
        };
    });
    if (!referrer.equals(web3_js_1.PublicKey.default)) {
        addresses.push(...referrerTokenStates);
    }
    const [multiplyObligations, multiplyObligationsFarmUserStates] = getMultiplyObligationAndObligationFarmStateAddresses(kaminoMarket, user, multiplyMints);
    addresses.push(...multiplyObligations);
    addresses.push(...multiplyObligationsFarmUserStates);
    const [leverageObligations, leverageObligationsFarmUserStates] = getLeverageObligationAndObligationFarmStateAddresses(kaminoMarket, user, leverageMints);
    addresses.push(...leverageObligations);
    addresses.push(...leverageObligationsFarmUserStates);
    if (repayWithCollObligation) {
        const repayWithCollFarmUserStates = getRepayWithCollObligationFarmStateAddresses(kaminoMarket, repayWithCollObligation);
        addresses.push(...repayWithCollFarmUserStates);
        addresses.push({ address: repayWithCollObligation.obligationAddress, log: 'repay with coll obligation' });
    }
    return addresses;
};
function getMultiplyObligationAndObligationFarmStateAddresses(kaminoMarket, user, mints) {
    const obligationPdas = [];
    const farmUserStates = [];
    for (const { coll: collMint, debt: debtMint } of mints) {
        const collReserve = kaminoMarket.getReserveByMint(collMint);
        const debtReserve = kaminoMarket.getReserveByMint(debtMint);
        const collMintString = collMint.toString();
        const debtMintString = debtMint.toString();
        if (collReserve && debtReserve) {
            const multiplyObligation = new lib_1.MultiplyObligation(collMint, lib_1.WRAPPED_SOL_MINT, kaminoMarket.programId);
            obligationPdas.push({
                address: multiplyObligation.toPda(kaminoMarket.getAddress(), user),
                log: 'multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
            });
            if (!collReserve.state.farmCollateral.equals(web3_js_1.PublicKey.default)) {
                farmUserStates.push({
                    address: getPdaFarmsUserState(collReserve.state.farmCollateral, multiplyObligation.toPda(kaminoMarket.getAddress(), user)),
                    log: 'collReserve farmState for multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
                });
            }
            if (!debtReserve.state.farmDebt.equals(web3_js_1.PublicKey.default)) {
                farmUserStates.push({
                    address: getPdaFarmsUserState(debtReserve.state.farmDebt, multiplyObligation.toPda(kaminoMarket.getAddress(), user)),
                    log: 'debtReserve farmState for multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
                });
            }
        }
    }
    return [obligationPdas, farmUserStates];
}
function getLeverageObligationAndObligationFarmStateAddresses(kaminoMarket, user, mints) {
    const obligationPdas = [];
    const farmUserStates = [];
    for (const { coll: collMint, debt: debtMint } of mints) {
        const collReserve = kaminoMarket.getReserveByMint(collMint);
        const debtReserve = kaminoMarket.getReserveByMint(debtMint);
        const collMintString = collMint.toString();
        const debtMintString = debtMint.toString();
        if (collReserve && debtReserve) {
            const leverageObligation = new lib_1.LeverageObligation(collMint, debtMint, kaminoMarket.programId);
            obligationPdas.push({
                address: leverageObligation.toPda(kaminoMarket.getAddress(), user),
                log: 'leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
            });
            if (!collReserve.state.farmCollateral.equals(web3_js_1.PublicKey.default)) {
                farmUserStates.push({
                    address: getPdaFarmsUserState(collReserve.state.farmCollateral, leverageObligation.toPda(kaminoMarket.getAddress(), user)),
                    log: 'collReserve farmState for leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
                });
            }
            if (!debtReserve.state.farmDebt.equals(web3_js_1.PublicKey.default)) {
                farmUserStates.push({
                    address: getPdaFarmsUserState(debtReserve.state.farmDebt, leverageObligation.toPda(kaminoMarket.getAddress(), user)),
                    log: 'debtReserve farmState for leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
                });
            }
        }
    }
    return [obligationPdas, farmUserStates];
}
function getRepayWithCollObligationFarmStateAddresses(kaminoMarket, obligation) {
    const farmUserStates = [];
    const obligationString = obligation.obligationAddress.toString();
    obligation.borrows.forEach((borrow) => {
        const borrowReserve = kaminoMarket.getReserveByMint(borrow.mintAddress);
        if (!borrowReserve.state.farmDebt.equals(web3_js_1.PublicKey.default)) {
            farmUserStates.push({
                address: getPdaFarmsUserState(borrowReserve.state.farmDebt, obligation.obligationAddress),
                log: 'debtReserve farmState for vanilla obligation: ' + obligationString,
            });
        }
    });
    obligation.deposits.forEach((deposit) => {
        const depositReserve = kaminoMarket.getReserveByMint(deposit.mintAddress);
        if (!depositReserve.state.farmCollateral.equals(web3_js_1.PublicKey.default)) {
            farmUserStates.push({
                address: getPdaFarmsUserState(depositReserve.state.farmCollateral, obligation.obligationAddress),
                log: 'collReserve farmState for vanilla obligation' + obligationString,
            });
        }
    });
    return farmUserStates;
}
const BASE_SEED_USER_STATE = Buffer.from('user');
const getPdaFarmsUserState = (farm, obligation) => web3_js_1.PublicKey.findProgramAddressSync([BASE_SEED_USER_STATE, farm.toBytes(), obligation.toBytes()], farms_sdk_1.farmsId)[0];
async function getAllUserMetadatasWithFilter(connection, filter, programId) {
    const filters = [
        {
            dataSize: lib_1.UserMetadata.layout.span + 8,
        },
        ...filter,
    ];
    const userMetadatas = await connection.getProgramAccounts(programId, {
        filters,
    });
    return userMetadatas.map((userMetadata) => {
        if (userMetadata.account === null) {
            throw new Error('Invalid account');
        }
        if (!userMetadata.account.owner.equals(programId)) {
            throw new Error("account doesn't belong to this program");
        }
        const userMetadataAccount = lib_1.UserMetadata.decode(userMetadata.account.data);
        if (!userMetadataAccount) {
            throw Error('Could not parse user metadata.');
        }
        return { address: userMetadata.pubkey, state: userMetadataAccount };
    });
}
//# sourceMappingURL=userMetadata.js.map