@kamino-finance/klend-sdk 5.15.2 → 5.15.3

package/dist/tests/tests/runner/setup_utils.js

@@ -0,0 +1,1004 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToNumberArray = exports.round = exports.reloadRefreshedMarket = exports.initUserMetadataAccounts = exports.getLocalKaminoSwapper = exports.repay = exports.borrow = exports.withdraw = exports.deposit = exports.balances = exports.balance = exports.newUser = exports.addReserveToMarket = exports.makeReserveConfig = exports.makeElevationGroupConfig = exports.DefaultConfigParams = void 0;
+exports.endpointFromCluster = endpointFromCluster;
+exports.getOracleConfigs = getOracleConfigs;
+exports.createMarketWithReserves = createMarketWithReserves;
+exports.setupTestMarket = setupTestMarket;
+exports.newBorrower = newBorrower;
+exports.getLocalSwapIxs = getLocalSwapIxs;
+exports.swapLocal = swapLocal;
+exports.setupStrategyAndMarketWithInitialLiquidity = setupStrategyAndMarketWithInitialLiquidity;
+exports.createMintAndReserve = createMintAndReserve;
+exports.testKaminoReserve = testKaminoReserve;
+exports.testCurve = testCurve;
+const bn_js_1 = __importDefault(require("bn.js"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const kit_1 = require("@solana/kit");
+const src_1 = require("../../src");
+const types_1 = require("../../src/@codegen/klend/types");
+const setup_operations_1 = require("./setup_operations");
+const token_utils_1 = require("./token_utils");
+const price_1 = require("./price");
+const utils_1 = require("./kamino/utils");
+const kamino_operations_1 = require("./kamino/kamino_operations");
+const scope_sdk_1 = require("@kamino-finance/scope-sdk");
+const types_2 = require("@kamino-finance/scope-sdk/dist/@codegen/scope/types");
+const scope_1 = require("./kamino/scope");
+const kliquidity_sdk_1 = require("@kamino-finance/kliquidity-sdk");
+const fraction_1 = require("../../src/classes/fraction");
+const token_1 = require("@solana-program/token");
+const tx_1 = require("./tx");
+const token_2022_1 = require("@solana-program/token-2022");
+const env_1 = require("./env");
+const airdrop_1 = require("./airdrop");
+const consts_1 = require("../../src/utils/consts");
+const lookupTable_1 = require("./lookupTable");
+function endpointFromCluster(cluster) {
+    if (cluster === 'localnet') {
+        return 'http://127.0.0.1:8899';
+    }
+    else if (cluster === 'devnet') {
+        return 'https://api.devnet.solana.com';
+    }
+    else if (cluster === 'mainnet-beta') {
+        return 'https://api.mainnet-beta.solana.com';
+    }
+    else {
+        return cluster;
+    }
+}
+exports.DefaultConfigParams = {
+    loanToValuePct: 75,
+    maxLiquidationBonusBps: 500,
+    minLiquidationBonusBps: 200,
+    badDebtLiquidationBonusBps: 10,
+    liquidationThreshold: 85,
+    borrowFeeSf: fraction_1.ZERO_FRACTION,
+    flashLoanFeeSf: fraction_1.ZERO_FRACTION,
+    protocolTakeRate: 0,
+    elevationGroups: new Array(20).fill(0),
+    priceFeed: null,
+    borrowLimit: new bn_js_1.default(10_000_000_000_000),
+    borrowFactorPct: 100,
+    borrowRateCurve: new types_1.BorrowRateCurve({
+        points: [
+            new types_1.CurvePoint({ utilizationRateBps: 0, borrowRateBps: 1 }),
+            new types_1.CurvePoint({ utilizationRateBps: 100, borrowRateBps: 100 }),
+            new types_1.CurvePoint({ utilizationRateBps: 10000, borrowRateBps: 100000 }),
+            ...Array(8).fill(new types_1.CurvePoint({ utilizationRateBps: 10000, borrowRateBps: 100000 })),
+        ],
+    }),
+};
+const makeElevationGroupConfig = (debtReserve, id, customizations = {}) => {
+    return {
+        maxLiquidationBonusBps: 100,
+        id,
+        ltvPct: 90,
+        liquidationThresholdPct: 95,
+        allowNewLoans: 1,
+        maxReservesAsCollateral: customizations.maxReservesAsCollateral ?? 1,
+        debtReserve,
+        padding0: 0,
+        padding1: new Array(4).fill(new bn_js_1.default(0)),
+    };
+};
+exports.makeElevationGroupConfig = makeElevationGroupConfig;
+const makeReserveConfig = (tokenName, params = exports.DefaultConfigParams, oraclePrices) => {
+    let priceFeed;
+    if (params.priceFeed) {
+        priceFeed = params.priceFeed;
+    }
+    else {
+        const priceToOracleMap = {
+            SOL: price_1.Price.SOL_USD_20,
+            STSOL: price_1.Price.STSOL_USD_20,
+            MSOL: price_1.Price.SOL_USD_20,
+            JITOSOL: price_1.Price.SOL_USD_20,
+            USDC: price_1.Price.USDC_USD_1,
+            PYUSD: price_1.Price.USDC_USD_1,
+            USDH: price_1.Price.USDC_USD_1,
+            USDT: price_1.Price.USDC_USD_1,
+            UXD: price_1.Price.USDC_USD_1,
+            DUST: price_1.Price.USDC_USD_1,
+        };
+        const price = priceToOracleMap[tokenName];
+        if (!price) {
+            throw new Error(`No price feed for token ${tokenName}`);
+        }
+        priceFeed = (0, price_1.getPriceAcc)(price);
+    }
+    const reserveConfig = {
+        status: 0,
+        loanToValuePct: params.loanToValuePct,
+        liquidationThresholdPct: params.liquidationThreshold,
+        minLiquidationBonusBps: params.minLiquidationBonusBps,
+        protocolLiquidationFeePct: 0,
+        protocolOrderExecutionFeePct: 0,
+        protocolTakeRatePct: params.protocolTakeRate,
+        assetTier: 0,
+        maxLiquidationBonusBps: params.maxLiquidationBonusBps,
+        badDebtLiquidationBonusBps: params.badDebtLiquidationBonusBps,
+        fees: {
+            borrowFeeSf: params.borrowFeeSf.getValue(),
+            flashLoanFeeSf: params.flashLoanFeeSf.getValue(),
+            padding: Array(6).fill(0),
+        },
+        depositLimit: new bn_js_1.default(10_000_000_100_000),
+        borrowLimit: params.borrowLimit,
+        tokenInfo: {
+            name: (0, src_1.encodeTokenName)(tokenName),
+            heuristic: new types_1.PriceHeuristic({
+                lower: new bn_js_1.default(0),
+                upper: new bn_js_1.default(0),
+                exp: new bn_js_1.default(0),
+            }),
+            maxTwapDivergenceBps: new bn_js_1.default(0),
+            maxAgePriceSeconds: new bn_js_1.default(1_000_000_000),
+            maxAgeTwapSeconds: new bn_js_1.default(0),
+            ...getOracleConfigs(priceFeed, oraclePrices),
+            padding: Array(20).fill(new bn_js_1.default(0)),
+        },
+        borrowRateCurve: params.borrowRateCurve,
+        depositWithdrawalCap: new types_1.WithdrawalCaps({
+            configCapacity: new bn_js_1.default(0),
+            currentTotal: new bn_js_1.default(0),
+            lastIntervalStartTimestamp: new bn_js_1.default(0),
+            configIntervalLengthSeconds: new bn_js_1.default(0),
+        }),
+        debtWithdrawalCap: new types_1.WithdrawalCaps({
+            configCapacity: new bn_js_1.default(0),
+            currentTotal: new bn_js_1.default(0),
+            lastIntervalStartTimestamp: new bn_js_1.default(0),
+            configIntervalLengthSeconds: new bn_js_1.default(0),
+        }),
+        deleveragingMarginCallPeriodSecs: new bn_js_1.default(259200), // 3 days
+        borrowFactorPct: new bn_js_1.default(params.borrowFactorPct),
+        elevationGroups: params.elevationGroups,
+        deleveragingThresholdDecreaseBpsPerDay: new bn_js_1.default(24), // 0.01% per hour
+        autodeleverageEnabled: 1,
+        deleveragingBonusIncreaseBpsPerDay: new bn_js_1.default(100),
+        disableUsageAsCollOutsideEmode: 0,
+        borrowLimitOutsideElevationGroup: new bn_js_1.default(src_1.U64_MAX),
+        borrowLimitAgainstThisCollateralInElevationGroup: [...Array(32)].map(() => new bn_js_1.default(0)),
+        utilizationLimitBlockBorrowingAbovePct: 0,
+        hostFixedInterestRateBps: 0,
+        reserved1: Array(1).fill(0),
+        reserved2: Array(9).fill(0),
+    };
+    return new types_1.ReserveConfig(reserveConfig);
+};
+exports.makeReserveConfig = makeReserveConfig;
+function getOracleConfigs(priceFeed, oraclePrices) {
+    let pythConfiguration = new types_1.PythConfiguration({
+        price: src_1.NULL_PUBKEY,
+    });
+    let switchboardConfiguration = new types_1.SwitchboardConfiguration({
+        priceAggregator: src_1.NULL_PUBKEY,
+        twapAggregator: src_1.NULL_PUBKEY,
+    });
+    let scopeConfiguration = new types_1.ScopeConfiguration({
+        priceFeed: src_1.NULL_PUBKEY,
+        priceChain: [65535, 65535, 65535, 65535],
+        twapChain: [65535, 65535, 65535, 65535],
+    });
+    const { type, price, chain } = priceFeed;
+    switch (type.kind) {
+        case new types_2.OracleType.PythPull().kind: {
+            if (oraclePrices) {
+                scopeConfiguration = new types_1.ScopeConfiguration({
+                    ...scopeConfiguration,
+                    priceFeed: oraclePrices,
+                    priceChain: chain.concat(Array(4 - chain.length).fill(scope_sdk_1.U16_MAX)),
+                });
+            }
+            else {
+                pythConfiguration = new types_1.PythConfiguration({ price });
+            }
+            break;
+        }
+        case new types_2.OracleType.SwitchboardV2().kind: {
+            if (oraclePrices) {
+                scopeConfiguration = new types_1.ScopeConfiguration({
+                    ...scopeConfiguration,
+                    priceFeed: oraclePrices,
+                    priceChain: chain.concat(Array(4 - chain.length).fill(scope_sdk_1.U16_MAX)),
+                });
+            }
+            else {
+                switchboardConfiguration = new types_1.SwitchboardConfiguration({
+                    ...switchboardConfiguration,
+                    priceAggregator: price,
+                });
+            }
+            break;
+        }
+        case new types_2.OracleType.PythPullEMA().kind:
+            if (!oraclePrices) {
+                throw new Error('Oracle prices are required for PythPullBasedEMA');
+            }
+            scopeConfiguration = new types_1.ScopeConfiguration({
+                ...scopeConfiguration,
+                priceFeed: oraclePrices,
+                twapChain: chain.concat(Array(4 - chain.length).fill(scope_sdk_1.U16_MAX)),
+            });
+            break;
+        case new types_2.OracleType.KToken().kind:
+        case new types_2.OracleType.FixedPrice().kind:
+        case new types_2.OracleType.JupiterLpCompute().kind:
+        case new types_2.OracleType.JupiterLpScope().kind:
+        case new types_2.OracleType.JupiterLpFetch().kind:
+        case new types_2.OracleType.SplStake().kind: {
+            if (!oraclePrices) {
+                throw new Error('Oracle prices are required for KToken, FixedPrice, JupiterLpCompute, JupiterLpScope, JupiterLpFetch, SplStake');
+            }
+            scopeConfiguration = new types_1.ScopeConfiguration({
+                ...scopeConfiguration,
+                priceFeed: oraclePrices,
+                priceChain: chain.concat(Array(4 - chain.length).fill(scope_sdk_1.U16_MAX)),
+            });
+            break;
+        }
+        // TODO: Add twaps and other types later
+        default:
+            throw new Error('Invalid oracle type');
+    }
+    return {
+        pythConfiguration,
+        switchboardConfiguration,
+        scopeConfiguration,
+    };
+}
+const addReserveToMarket = async (env, lendingMarket, reserveSpecification) => {
+    const reserveSpec = typeof reserveSpecification === 'string'
+        ? { symbol: reserveSpecification, tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS }
+        : reserveSpecification;
+    const mint = reserveSpec.symbol === 'SOL'
+        ? src_1.WRAPPED_SOL_MINT
+        : await (0, token_utils_1.createMint)(env, env.admin, 6, null, reserveSpec.tokenProgram);
+    const adminLiquiditySource = await (0, kamino_operations_1.mintToUser)(env, mint, env.admin, src_1.MIN_INITIAL_DEPOSIT, env.admin);
+    const reserveAddress = await (0, setup_operations_1.createReserve)(env, lendingMarket, adminLiquiditySource, mint, reserveSpec.tokenProgram);
+    const extraParams = {
+        ...exports.DefaultConfigParams,
+    };
+    const reserveConfig = (0, exports.makeReserveConfig)(reserveSpec.symbol, extraParams);
+    await (0, setup_operations_1.updateReserve)(env, reserveAddress, reserveConfig);
+    return { mint, reserve: reserveAddress };
+};
+exports.addReserveToMarket = addReserveToMarket;
+async function createMarketWithReserves({ marketConfig = {}, reserves, isScopeOracleSetup = false, }) {
+    const env = await (0, env_1.initEnv)();
+    let scope;
+    let configAccount;
+    if (isScopeOracleSetup) {
+        ({ scope, configAccount } = await (0, price_1.setupLocalScope)(env));
+    }
+    const lendingMarket = await (0, setup_operations_1.createMarket)(env);
+    const mints = [];
+    for (const [reserveSpec] of reserves) {
+        let mint;
+        if (reserveSpec.symbol === 'SOL') {
+            mint = src_1.WRAPPED_SOL_MINT;
+        }
+        else {
+            mint = await (0, token_utils_1.createMint)(env, env.admin, 6, await (0, kit_1.generateKeyPairSigner)(), reserveSpec.tokenProgram);
+        }
+        mints.push(mint);
+    }
+    const adminLiquiditySources = await Promise.all(mints.map(async (mint, i) => (0, kamino_operations_1.mintToUser)(env, mint, env.admin, src_1.MIN_INITIAL_DEPOSIT, env.admin, reserves[i][0].tokenProgram)));
+    const promises = mints.map(async (mint, i) => (0, setup_operations_1.createReserve)(env, lendingMarket, adminLiquiditySources[i], mint, reserves[i][0].tokenProgram));
+    const reservesAddresses = await Promise.all(promises);
+    const promisesConfig = reserves
+        .map(([reserveSpec, reserveConfigParams]) => {
+        const configParams = {
+            ...exports.DefaultConfigParams,
+            ...reserveConfigParams,
+            elevationGroups: new Array(20).fill(0),
+        };
+        return (0, exports.makeReserveConfig)(reserveSpec.symbol, configParams, configAccount?.oraclePrices);
+    })
+        .map((reserveConfig, i) => (0, setup_operations_1.updateReserve)(env, reservesAddresses[i], reserveConfig));
+    await Promise.all(promisesConfig);
+    const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, lendingMarket, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.klendProgramId));
+    await configureElevationGroups(env, kaminoMarket, marketConfig, reserves);
+    await kaminoMarket.reload();
+    return { env, kaminoMarket, scope };
+}
+async function setupTestMarket({ reserves = [], loan, marketConfig = {}, isScopeOracleSetup = false, }) {
+    const reserveSpecs = [];
+    for (const [reserveSpecOrSymbol, deposit, config] of reserves) {
+        let reserveSpec;
+        if (typeof reserveSpecOrSymbol === 'string') {
+            reserveSpec = { symbol: reserveSpecOrSymbol, tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS };
+        }
+        else {
+            reserveSpec = reserveSpecOrSymbol;
+        }
+        reserveSpecs.push([reserveSpec, new decimal_js_1.default(deposit), config ? config : {}]);
+    }
+    const { env, kaminoMarket, scope } = await createMarketWithReserves({
+        marketConfig,
+        reserves: reserveSpecs.map(([s, , p]) => [s, p]),
+        isScopeOracleSetup,
+    });
+    const balances = reserveSpecs.map(([reserveSpec, deposit]) => [
+        reserveSpec.symbol,
+        deposit.toString(),
+    ]);
+    const kamino = new kliquidity_sdk_1.Kamino('localnet', env.c.rpc, env.legacyConnection);
+    await newBorrower(env, kaminoMarket, kamino, {
+        deposits: balances,
+        borrows: [],
+    }, scope);
+    let borrower;
+    if (loan) {
+        borrower = await newBorrower(env, kaminoMarket, kamino, loan, scope);
+        await kaminoMarket.reload();
+    }
+    return { env, kaminoMarket, kamino, borrower, scope };
+}
+const newUser = async (env, kaminoMarket, balances = [], scope, kamino = null, mintIntoWsolAta = false, referrer) => {
+    const depositor = await (0, kit_1.generateKeyPairSigner)();
+    await (0, airdrop_1.solAirdrop)(env.c, depositor.address, 2);
+    const sumBalancesBySymbol = balances.reduce((acc, [symbol, amount]) => {
+        const amt = new decimal_js_1.default(amount);
+        const strAmt = acc.get(symbol) ?? '0';
+        const accAmt = new decimal_js_1.default(strAmt);
+        acc.set(symbol, accAmt.add(amt).toString());
+        return acc;
+    }, new Map());
+    const sumBalancesArray = Array.from(sumBalancesBySymbol.entries());
+    await kaminoMarket.loadReserves();
+    for (const [symbol, amount] of sumBalancesArray) {
+        const amt = new decimal_js_1.default(amount);
+        if (amt.gt(0)) {
+            const reserve = kaminoMarket.getReserveBySymbol(symbol);
+            if (!reserve) {
+                throw new Error(`Reserve ${symbol} not found`);
+            }
+            const mint = reserve.getLiquidityMint();
+            if (mint === src_1.WRAPPED_SOL_MINT) {
+                const [ata, ix] = await (0, src_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, mint, depositor.address, token_1.TOKEN_PROGRAM_ADDRESS);
+                await (0, airdrop_1.solAirdrop)(env.c, depositor.address, amt);
+                console.log(`Airdrop ${amount} SOL`, amt);
+                if (mintIntoWsolAta) {
+                    // Should never have to do this in fact
+                    // user simply has SOL
+                    const transferWsolIxs = (0, src_1.getTransferWsolIxs)(depositor, ata, (0, kit_1.lamports)(BigInt(new decimal_js_1.default(amount).mul(consts_1.LAMPORTS_PER_SOL).ceil().toString())));
+                    await (0, tx_1.sendAndConfirmTx)(env.c, depositor, [ix, ...transferWsolIxs], [], [], 'wsolAtaTopup');
+                }
+            }
+            else if ((0, utils_1.isKToken)(symbol)) {
+                const strategy = await kamino?.getStrategyByKTokenMint(mint);
+                await (0, kamino_operations_1.mintKTokenToUser)(env, kamino, depositor, env.admin, strategy.strategy.sharesMint);
+                const ktokenReserve = kaminoMarket.getReserveByMint(mint);
+                if (!ktokenReserve) {
+                    throw new Error('KToken reserve not found');
+                }
+                const priceFeedAddress = ktokenReserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
+                const chain = ktokenReserve.state.config.tokenInfo.scopeConfiguration.priceChain;
+                const priceFeed = {
+                    type: new types_2.OracleType.KToken(),
+                    price: priceFeedAddress,
+                    chain,
+                };
+                await (0, kamino_operations_1.crankStrategyScopePrices)(env, kamino, scope, strategy, symbol, priceFeed);
+            }
+            else {
+                const [ata, ix] = await (0, src_1.createAssociatedTokenAccountIdempotentInstruction)(env.admin, mint, depositor.address, reserve.getLiquidityTokenProgram());
+                await (0, token_utils_1.mintTo)(env, mint, ata, amt.mul(reserve.getMintFactor()).toNumber(), [ix], reserve.getLiquidityTokenProgram());
+            }
+        }
+    }
+    await (0, exports.initUserMetadataAccounts)(env, kaminoMarket, depositor, referrer);
+    return depositor;
+};
+exports.newUser = newUser;
+async function newBorrower(env, kaminoMarket, kamino, loan, scope) {
+    const allBalances = [...(loan?.additionalBalances ?? []), ...loan.deposits];
+    const owner = await (0, exports.newUser)(env, kaminoMarket, allBalances, scope, kamino, false);
+    const obligationType = getObligationType(loan, kaminoMarket);
+    for (const [token, depositAmount] of loan.deposits) {
+        const d = new decimal_js_1.default(depositAmount);
+        if (d.gt('0')) {
+            const reserve = kaminoMarket.getReserveBySymbol(token);
+            if (!reserve) {
+                throw new Error(`Reserve ${token} not found`);
+            }
+            await (0, exports.deposit)(env, kaminoMarket, owner, token, d, scope);
+        }
+    }
+    const obligation = await obligationType.toPda(kaminoMarket.getAddress(), owner.address);
+    if (loan.elevationGroup) {
+        const ob = (await src_1.KaminoObligation.load(kaminoMarket, obligation));
+        const elevationGroupAction = await src_1.KaminoAction.buildRequestElevationGroupTxns(kaminoMarket, owner, ob, loan.elevationGroup, 400_000);
+        // simulate underestimates this tx for some reason
+        // const pool = env.pool.cloneWithConfig({ ...env.pool.getConfig(), simulate: false });
+        await (0, tx_1.sendAndConfirmTx)(env.c, owner, src_1.KaminoAction.actionToIxs(elevationGroupAction), [], [], 'requestElevationGroup');
+    }
+    for (const [token, borrowAmount] of loan.borrows) {
+        const b = new decimal_js_1.default(borrowAmount);
+        const reserve = kaminoMarket.getReserveBySymbol(token);
+        if (!reserve) {
+            throw new Error(`Reserve ${token} not found`);
+        }
+        await (0, exports.borrow)(env, kaminoMarket, owner, token, b, scope);
+    }
+    return { owner, obligation };
+}
+function getObligationType(loan, kaminoMarket) {
+    const loanType = loan.type ?? src_1.ObligationTypeTag.Vanilla;
+    let obligationType;
+    // eslint-disable-next-line default-case
+    switch (loanType) {
+        case src_1.ObligationTypeTag.Vanilla:
+            obligationType = new src_1.VanillaObligation(kaminoMarket.programId);
+            break;
+        case src_1.ObligationTypeTag.Multiply:
+            const multiplyColl = kaminoMarket.getReserveBySymbol(loan.deposits[0][0]).getLiquidityMint();
+            const multiplyDebt = kaminoMarket.getReserveBySymbol(loan.borrows[0][0]).getLiquidityMint();
+            obligationType = new src_1.MultiplyObligation(multiplyColl, multiplyDebt, kaminoMarket.programId);
+            break;
+        case src_1.ObligationTypeTag.Lending:
+            const lendingColl = kaminoMarket.getReserveBySymbol(loan.deposits[0][0]).getLiquidityMint();
+            obligationType = new src_1.LendingObligation(lendingColl, kaminoMarket.programId);
+            break;
+        case src_1.ObligationTypeTag.Leverage:
+            const leverageColl = kaminoMarket.getReserveBySymbol(loan.deposits[0][0]).getLiquidityMint();
+            const leverageDebt = kaminoMarket.getReserveBySymbol(loan.borrows[0][0]).getLiquidityMint();
+            obligationType = new src_1.LeverageObligation(leverageColl, leverageDebt, kaminoMarket.programId);
+            break;
+    }
+    return obligationType;
+}
+const balance = async (env, user, kaminoMarket, symbol, ifSolGetWsolBalance = false) => {
+    const reserve = kaminoMarket.getReserveBySymbol(symbol);
+    if (!reserve) {
+        throw new Error(`Reserve ${symbol} not found`);
+    }
+    const mint = reserve.getLiquidityMint();
+    if (mint === src_1.WRAPPED_SOL_MINT && !ifSolGetWsolBalance) {
+        return new decimal_js_1.default((await env.c.rpc.getBalance(user).send()).value.toString()).div(consts_1.LAMPORTS_PER_SOL).toNumber();
+    }
+    const ata = await (0, src_1.getAssociatedTokenAddress)(mint, user, reserve.getLiquidityTokenProgram());
+    const accInfo = await (0, token_2022_1.fetchMaybeToken)(env.c.rpc, ata);
+    if (!accInfo.exists) {
+        return 0;
+    }
+    return new decimal_js_1.default(accInfo.data.amount.toString()).div(reserve.getMintFactor()).toNumber();
+};
+exports.balance = balance;
+const balances = async (env, user, kaminoMarket, symbols) => {
+    const balances = await Promise.all(symbols.map((symbol) => (0, exports.balance)(env, user, kaminoMarket, symbol)));
+    return balances;
+};
+exports.balances = balances;
+const deposit = async (env, kaminoMarket, user, symbol, amount, scope = undefined, obligationType = new src_1.VanillaObligation(env.klendProgramId), ixnsOnly = false, // TODO: remove this
+requestElevationGroup = undefined, overrideElevationGroupRequest = undefined) => {
+    const reserve = kaminoMarket.getReserveBySymbol(symbol);
+    if (!reserve) {
+        throw new Error(`Reserve ${symbol} not found`);
+    }
+    console.log('Depositing', (0, src_1.numberToLamportsDecimal)(amount, reserve.stats.decimals).floor().toString(), symbol, reserve.address.toString());
+    const kaminoAction = await src_1.KaminoAction.buildDepositTxns(kaminoMarket, (0, src_1.numberToLamportsDecimal)(amount, reserve.stats.decimals).floor().toString(), reserve.getLiquidityMint(), user, obligationType, env.useV2Ixs, scope ? { scope, scopeFeed: env.testCase } : undefined, undefined, undefined, requestElevationGroup, undefined, undefined, undefined, overrideElevationGroupRequest);
+    const ixs = src_1.KaminoAction.actionToIxs(kaminoAction);
+    if (ixnsOnly) {
+        return ixs;
+    }
+    else {
+        return (0, tx_1.sendAndConfirmTx)(env.c, user, ixs, [], [], 'deposit');
+    }
+};
+exports.deposit = deposit;
+const withdraw = async (env, kaminoMarket, scope, user, symbol, amount, obligationType = new src_1.VanillaObligation(env.klendProgramId)) => {
+    const reserve = kaminoMarket.getReserveBySymbol(symbol);
+    if (!reserve) {
+        throw new Error(`Reserve ${symbol} not found`);
+    }
+    console.log('Withdrawing', (0, src_1.numberToLamportsDecimal)(amount, reserve.stats.decimals).floor().toString(), symbol, reserve.address.toString());
+    const kaminoAction = await src_1.KaminoAction.buildWithdrawTxns(kaminoMarket, (0, src_1.numberToLamportsDecimal)(amount, reserve.stats.decimals).floor().toString(), reserve.getLiquidityMint(), user, obligationType, env.useV2Ixs, scope ? { scope, scopeFeed: env.testCase } : undefined, undefined, undefined, false, undefined, undefined, undefined);
+    const ixs = src_1.KaminoAction.actionToIxs(kaminoAction);
+    return (0, tx_1.sendAndConfirmTx)(env.c, user, ixs, [], [], 'withdraw');
+};
+exports.withdraw = withdraw;
+const borrow = async (env, kaminoMarket, user, symbol, amount, scope = undefined, referrer = (0, kit_1.none)(), requestElevationGroup = false, obligationType = new src_1.VanillaObligation(env.klendProgramId), overrideElevationGroupRequest = undefined, includeLookupTable = false) => {
+    const reserve = kaminoMarket.getReserveBySymbol(symbol);
+    if (!reserve) {
+        throw new Error(`Reserve ${symbol} not found`);
+    }
+    const kaminoAction = await src_1.KaminoAction.buildBorrowTxns(kaminoMarket, (0, src_1.numberToLamportsDecimal)(amount, reserve.stats.decimals).floor().toString(), reserve.getLiquidityMint(), user, obligationType, env.useV2Ixs, scope ? { scope, scopeFeed: env.testCase } : undefined, undefined, undefined, requestElevationGroup, undefined, referrer, undefined, overrideElevationGroupRequest);
+    let userLookupTable = [];
+    if (includeLookupTable) {
+        userLookupTable = [await (0, lookupTable_1.createLutForIxs)(env, src_1.KaminoAction.actionToIxs(kaminoAction))];
+    }
+    await (0, src_1.sleep)(2000);
+    await (0, tx_1.sendAndConfirmTx)(env.c, user, src_1.KaminoAction.actionToIxs(kaminoAction), [], userLookupTable, 'borrow');
+};
+exports.borrow = borrow;
+const repay = async (env, kaminoMarket, user, symbol, amount, scope = undefined, obligationType = new src_1.VanillaObligation(env.klendProgramId)) => {
+    const reserve = kaminoMarket.getReserveBySymbol(symbol);
+    if (!reserve) {
+        throw new Error(`Reserve ${symbol} not found`);
+    }
+    const slot = await env.c.rpc.getSlot().send();
+    const kaminoAction = await src_1.KaminoAction.buildRepayTxns(kaminoMarket, (0, src_1.numberToLamportsDecimal)(amount, reserve.stats.decimals).floor().toString(), reserve.getLiquidityMint(), user, obligationType, env.useV2Ixs, scope ? { scope, scopeFeed: env.testCase } : undefined, slot);
+    await (0, tx_1.sendAndConfirmTx)(env.c, user, src_1.KaminoAction.actionToIxs(kaminoAction), [], [], 'repay');
+};
+exports.repay = repay;
+async function getLocalSwapIxs(env, inputMintAmount, outputMintAmount, inputMint, outputMint, user) {
+    const inputMintAddress = inputMint.address;
+    const outputMintAddress = outputMint.address;
+    const inputMintTokenProgram = inputMint.programAddress;
+    const outputMintTokenProgram = outputMint.programAddress;
+    const [tokenAAta, tokenBAta] = await Promise.all([
+        (0, src_1.getAssociatedTokenAddress)(inputMintAddress, user.address, inputMintTokenProgram),
+        (0, src_1.getAssociatedTokenAddress)(outputMintAddress, user.address, outputMintTokenProgram),
+    ]);
+    const inputMintDecimals = inputMint.data.decimals;
+    const outputMintDecimals = outputMint.data.decimals;
+    const inputAmountToBurnLamports = inputMintAmount.mul(new decimal_js_1.default(10).pow(inputMintDecimals));
+    const outputAmountToMintLamports = outputMintAmount.mul(new decimal_js_1.default(10).pow(outputMintDecimals));
+    const burnFromIxs = [];
+    if (inputMintAddress === src_1.WRAPPED_SOL_MINT) {
+        // When it comes to SOL
+        // going to assume the swap is always wsol ata -> new wsol ata
+        // therefore burn == send that amount to a new random user newly created
+        // If we're 'selling' 'sol' it means we actually need to transfer wsols to the admin
+        const sourceWsolAta = await (0, src_1.getAssociatedTokenAddress)(src_1.WRAPPED_SOL_MINT, user.address);
+        const [wsolAtaForAdmin, createWSOLAccountIx] = await (0, src_1.createAssociatedTokenAccountIdempotentInstruction)(env.admin, src_1.WRAPPED_SOL_MINT, env.admin.address, token_1.TOKEN_PROGRAM_ADDRESS);
+        const transferIx = (0, token_2022_1.getTransferCheckedInstruction)({
+            mint: src_1.WRAPPED_SOL_MINT,
+            amount: BigInt(inputAmountToBurnLamports.floor().toString()),
+            decimals: 9,
+            authority: user,
+            source: sourceWsolAta,
+            destination: wsolAtaForAdmin,
+        }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+        const closeWsolAccountIx = (0, token_2022_1.getCloseAccountInstruction)({
+            account: wsolAtaForAdmin,
+            destination: env.admin.address,
+            owner: env.admin,
+        }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+        console.log('Swapping in', inputMintAddress.toString(), 'as wsol', inputAmountToBurnLamports.floor().toNumber());
+        burnFromIxs.push(createWSOLAccountIx, transferIx, closeWsolAccountIx);
+    }
+    else {
+        console.log('Swapping in', inputMintAddress.toString(), inputAmountToBurnLamports.floor().toNumber(), 'from ata', tokenAAta.toString());
+        burnFromIxs.push((0, token_utils_1.getBurnFromIx)(user, inputMintAddress, tokenAAta, inputAmountToBurnLamports.floor().toNumber(), inputMintTokenProgram));
+    }
+    const mintToIxs = [];
+    if (outputMintAddress === src_1.WRAPPED_SOL_MINT) {
+        // We need to receive sol, so we're just going to transfer into the user's wsol ata
+        // from the admin's wsol ata
+        await (0, airdrop_1.solAirdrop)(env.c, env.admin.address, outputAmountToMintLamports.div(new decimal_js_1.default(10).pow(outputMintDecimals)).ceil());
+        const userWsolAta = await (0, src_1.getAssociatedTokenAddress)(src_1.WRAPPED_SOL_MINT, user.address);
+        // create wsol ata for admin
+        const [wsolAtaForAdmin, createWSOLAccountIx] = await (0, src_1.createAssociatedTokenAccountIdempotentInstruction)(env.admin, src_1.WRAPPED_SOL_MINT, env.admin.address, token_1.TOKEN_PROGRAM_ADDRESS);
+        const closeWsolAccountIx = (0, token_2022_1.getCloseAccountInstruction)({
+            owner: env.admin,
+            account: wsolAtaForAdmin,
+            destination: env.admin.address,
+        }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+        const transferWsolIxs = (0, src_1.getTransferWsolIxs)(env.admin, wsolAtaForAdmin, (0, kit_1.lamports)(BigInt(outputAmountToMintLamports.ceil().toString())));
+        const transferIx = (0, token_2022_1.getTransferCheckedInstruction)({
+            mint: src_1.WRAPPED_SOL_MINT,
+            amount: BigInt(outputAmountToMintLamports.floor().toString()),
+            source: wsolAtaForAdmin,
+            destination: userWsolAta,
+            decimals: 9,
+            authority: env.admin,
+        }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+        console.log('Swapping out', outputMintAddress.toString(), 'as wsol', outputAmountToMintLamports.floor().toNumber(), 'ata', userWsolAta.toString());
+        mintToIxs.push(createWSOLAccountIx, ...transferWsolIxs, transferIx, closeWsolAccountIx);
+    }
+    else {
+        console.log('Swapping out', outputMintAddress.toString(), outputAmountToMintLamports.floor().toNumber(), 'ata', tokenBAta.toString());
+        mintToIxs.push((0, token_utils_1.getMintToIx)(env.admin, outputMintAddress, tokenBAta, outputAmountToMintLamports.floor().toNumber(), outputMintTokenProgram));
+    }
+    return [[...mintToIxs, ...burnFromIxs], []];
+}
+async function swapLocal(env, inputMintAmount, outputMintAmount, inputMintAddress, outputMintAddress, user) {
+    const inputMint = await (0, token_utils_1.getMint)(env.c.rpc, inputMintAddress);
+    const outputMint = await (0, token_utils_1.getMint)(env.c.rpc, outputMintAddress);
+    const [swapIxs] = await getLocalSwapIxs(env, inputMintAmount, outputMintAmount, inputMint, outputMint, user);
+    await (0, tx_1.sendAndConfirmTx)(env.c, user, swapIxs, [], [], 'swap');
+}
+const getLocalKaminoSwapper = async (env) => {
+    return async (input, tokenAMint, tokenBMint, owner, _slippage, _allKeys) => {
+        const inputMint = await (0, token_utils_1.getMint)(env.c.rpc, tokenAMint);
+        const outputMint = await (0, token_utils_1.getMint)(env.c.rpc, tokenBMint);
+        const aDecimals = inputMint.data.decimals;
+        const bDecimals = outputMint.data.decimals;
+        console.log('Calling getLocalKaminoSwapper', (0, src_1.toJson)(input), tokenAMint.toString(), tokenBMint.toString(), owner.toString(), input.tokenBToSwapAmount.lt(0), input.tokenAToSwapAmount.lt(0));
+        if (input.tokenBToSwapAmount.lt(0)) {
+            return await getLocalSwapIxs(env, (0, src_1.lamportsToNumberDecimal)(input.tokenBToSwapAmount.abs(), bDecimals), (0, src_1.lamportsToNumberDecimal)(input.requiredAAmountToDeposit.abs(), aDecimals), outputMint, inputMint, owner);
+        }
+        else if (input.tokenAToSwapAmount.lt(0)) {
+            return await getLocalSwapIxs(env, (0, src_1.lamportsToNumberDecimal)(input.tokenAToSwapAmount.abs().floor(), aDecimals), (0, src_1.lamportsToNumberDecimal)(input.requiredBAmountToDeposit.abs().floor(), bDecimals), inputMint, outputMint, owner);
+        }
+        else {
+            console.log('Edge case');
+            return [[], []];
+        }
+    };
+};
+exports.getLocalKaminoSwapper = getLocalKaminoSwapper;
+const initUserMetadataAccounts = async (env, kaminoMarket, user, referrer) => {
+    const referrerKey = referrer ? (0, kit_1.some)(referrer) : (0, kit_1.none)();
+    // Create user metadata
+    const [, initUserMetadataIx] = await (0, src_1.getUserLutAddressAndSetupIxs)(kaminoMarket, user, referrerKey, false);
+    await (0, tx_1.sendAndConfirmTx)(env.c, user, initUserMetadataIx[0], [], [], 'initUserMetadata');
+};
+exports.initUserMetadataAccounts = initUserMetadataAccounts;
+const reloadRefreshedMarket = async (env, kaminoMarket) => {
+    const reserves = [...kaminoMarket.reserves.keys()];
+    const refreshIxs = src_1.KaminoAction.getRefreshAllReserves(kaminoMarket, reserves);
+    await (0, tx_1.sendAndConfirmTx)(env.c, env.admin, refreshIxs, [], [], 'refresh');
+    await kaminoMarket.reload();
+};
+exports.reloadRefreshedMarket = reloadRefreshedMarket;
+const round = (value, precision) => {
+    const multiplier = Math.pow(10, precision);
+    return Math.round(value * multiplier) / multiplier;
+};
+exports.round = round;
+/**
+ * Sorts kTokens to the end of the list so that dependent mints are created first
+ * @param a
+ * @param b
+ */
+const kTokenComparator = ([a], [b]) => {
+    if ((0, utils_1.isKToken)(a) && (0, utils_1.isKToken)(b)) {
+        return 0;
+    }
+    if ((0, utils_1.isKToken)(a)) {
+        return 1;
+    }
+    if ((0, utils_1.isKToken)(b)) {
+        return -1;
+    }
+    return a.localeCompare(b);
+};
+async function setupStrategyAndMarketWithInitialLiquidity({ reserves = [
+    ['USDH', '0'],
+    ['USDC', '0'],
+], prices = {
+    SOL: price_1.Price.SOL_USD_20,
+    USDH: price_1.Price.USDC_USD_1,
+    USDC: price_1.Price.USDC_USD_1,
+    STSOL: price_1.Price.STSOL_USD_20,
+    MSOL: price_1.Price.SOL_USD_20,
+}, mintOverrides = {}, } = {}) {
+    const env = await (0, env_1.initEnv)();
+    const firstDepositor = await (0, kit_1.generateKeyPairSigner)();
+    await (0, airdrop_1.solAirdrop)(env.c, firstDepositor.address, 1);
+    const lendingMarket = await (0, setup_operations_1.createMarket)(env);
+    const kamino = (0, kamino_operations_1.createKaminoClient)(env);
+    const scope = new scope_sdk_1.Scope('localnet', env.c.rpc);
+    const scopeFeed = await (0, scope_1.createScopeFeed)(env, scope);
+    await (0, kamino_operations_1.setUpGlobalConfig)(env, kamino, scopeFeed);
+    await (0, kamino_operations_1.setUpCollateralInfo)(env, kamino);
+    const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, lendingMarket, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, env.klendProgramId));
+    // 1. Create reserves with initial liquidity
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [symbol, initialLiquidity] of reserves.sort(kTokenComparator)) {
+        // Give all SOL derivatives 9 dp or else the kamino dex pools will be 1:1000 - weird pricing
+        const decimals = symbol.endsWith('SOL') ? 9 : 6;
+        const initialLiquidityLamports = (0, src_1.numberToLamportsDecimal)(initialLiquidity, decimals).toNumber();
+        console.log(`Creating ${symbol} reserve with ${initialLiquidityLamports} lamports initial liquidity (${initialLiquidity})`);
+        const override = mintOverrides[symbol] || null;
+        if (override) {
+            console.log(`Overriding ${symbol} mint with ${override.address}`);
+        }
+        const [, reserve] = await createMintAndReserve(env, kaminoMarket, kamino, symbol, initialLiquidityLamports, firstDepositor, decimals, prices, scope, override);
+        console.log(`Created ${symbol} reserve with address: ${reserve}`);
+    }
+    await kaminoMarket.reload();
+    return {
+        env,
+        kaminoMarket,
+        kamino,
+        scope,
+    };
+}
+async function createMintAndReserve(env, kaminoMarket, kamino, symbol, initialSupplyLamports, initialDepositor, decimals, prices, scope, mintOverride = null) {
+    let mint;
+    let priceFeed;
+    let oraclePrices;
+    let adminLiquiditySource;
+    if ((0, utils_1.isKToken)(symbol)) {
+        await kaminoMarket.reload();
+        const strategy = await (0, kamino_operations_1.createKTokenStrategy)(env, kamino, kaminoMarket, symbol, prices);
+        priceFeed = await (0, scope_1.addKTokenScopePriceMapping)(env, scope, kamino, symbol, strategy);
+        const [, configAccount] = await scope.getFeedConfiguration({ feed: env.testCase });
+        oraclePrices = configAccount.oraclePrices;
+        mint = strategy.strategy.sharesMint;
+        if (initialSupplyLamports > 0) {
+            await (0, kamino_operations_1.mintKTokenToUser)(env, kamino, initialDepositor, env.admin, strategy.strategy.sharesMint);
+        }
+        adminLiquiditySource = await (0, kamino_operations_1.mintKTokenToUser)(env, kamino, env.admin, env.admin, strategy.strategy.sharesMint);
+        await (0, kamino_operations_1.crankStrategyScopePrices)(env, kamino, scope, strategy, symbol, priceFeed);
+    }
+    else {
+        priceFeed = (0, price_1.getPriceAcc)(prices[symbol]);
+        if (symbol === 'SOL') {
+            mint = src_1.WRAPPED_SOL_MINT;
+            if (initialSupplyLamports > 0) {
+                await (0, airdrop_1.solAirdrop)(env.c, initialDepositor.address, initialSupplyLamports / consts_1.LAMPORTS_PER_SOL);
+            }
+        }
+        else {
+            mint = await (0, token_utils_1.createMint)(env, env.admin, decimals, mintOverride);
+            if (initialSupplyLamports > 0) {
+                await (0, kamino_operations_1.mintToUser)(env, mint, initialDepositor, initialSupplyLamports, env.admin);
+            }
+        }
+        adminLiquiditySource = await (0, kamino_operations_1.mintToUser)(env, mint, env.admin, src_1.MIN_INITIAL_DEPOSIT, env.admin);
+    }
+    const reserve = await (0, setup_operations_1.createReserve)(env, kaminoMarket.getAddress(), adminLiquiditySource, mint);
+    const config = !(0, utils_1.isKToken)(symbol)
+        ? (0, exports.makeReserveConfig)(symbol, { ...exports.DefaultConfigParams, priceFeed })
+        : (0, exports.makeReserveConfig)(symbol, { ...exports.DefaultConfigParams, priceFeed, borrowLimit: new bn_js_1.default(0) }, oraclePrices);
+    await (0, setup_operations_1.updateReserve)(env, reserve, config);
+    await kaminoMarket.reload();
+    if (initialSupplyLamports > 0) {
+        const depositAction = await src_1.KaminoAction.buildDepositReserveLiquidityTxns(kaminoMarket, initialSupplyLamports.toString(), mint, initialDepositor, new src_1.VanillaObligation(env.klendProgramId), { scope, scopeFeed: env.testCase }, 1_000_000, true, false, (0, kit_1.none)(), 0n);
+        await (0, tx_1.sendAndConfirmTx)(env.c, initialDepositor, src_1.KaminoAction.actionToIxs(depositAction), [], [], 'deposit');
+    }
+    return [mint, reserve, config];
+}
+async function configureElevationGroups(env, kaminoMarket, marketConfig, reserves) {
+    if (marketConfig?.elevationGroups) {
+        for (let i = 0; i < marketConfig.elevationGroups.length; i++) {
+            const elevationGroupArg = marketConfig.elevationGroups[i];
+            const id = i + 1;
+            let debtReserve;
+            let collateralReserveCount = 0;
+            for (const [rSpec, res] of reserves) {
+                if (res?.elevationGroups) {
+                    const symbol = rSpec.symbol;
+                    for (const { id: eId, isDebt } of res.elevationGroups) {
+                        if (id === eId) {
+                            collateralReserveCount++;
+                            if (isDebt) {
+                                if (!debtReserve) {
+                                    debtReserve = symbol;
+                                }
+                                else {
+                                    throw new Error(`Multiple debt reserves cannot be assigned to the same elevation group, found both ${debtReserve} and ${symbol} for group ${id}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (!debtReserve) {
+                // this fails in the SC so we fail early here
+                throw new Error(`No debt reserve found for elevation group ${id} from member reserves ${reserves
+                    .filter(([, rConf]) => rConf.elevationGroups && rConf.elevationGroups.findIndex((c) => c.id === id) !== -1)
+                    .map(([{ symbol }]) => symbol)}`);
+            }
+            if (collateralReserveCount === 0) {
+                throw new Error(`No collateral reserves found for elevation group ${id}, only debt reserve ${debtReserve}`);
+            }
+            if (elevationGroupArg.maxReservesAsCollateral === undefined) {
+                elevationGroupArg.maxReservesAsCollateral = collateralReserveCount; // test data has not explicitly specified it
+            }
+            const elevationGroup = getElevationGroupFromConfig(id, elevationGroupArg, kaminoMarket.getReserveBySymbol(debtReserve).address);
+            await (0, setup_operations_1.updateElevationGroup)(env, kaminoMarket, elevationGroup);
+        }
+        for (const [rSpec, args] of reserves) {
+            if (args?.elevationGroups) {
+                const symbol = rSpec.symbol;
+                const elevationGroupCollLimit = Array(32).fill(new bn_js_1.default(0));
+                for (const { id, borrowLimitAgainstThisCollateralInElevationGroup } of args.elevationGroups) {
+                    elevationGroupCollLimit[id - 1] = new bn_js_1.default(borrowLimitAgainstThisCollateralInElevationGroup || src_1.U64_MAX);
+                }
+                const res = kaminoMarket.getReserveBySymbol(symbol);
+                await (0, setup_operations_1.updateReserve)(env, res.address, new types_1.ReserveConfig({
+                    ...res.state.config,
+                    borrowLimitAgainstThisCollateralInElevationGroup: elevationGroupCollLimit,
+                    elevationGroups: [...args.elevationGroups.map((e) => e.id)].concat(Array(20 - args.elevationGroups.length).fill(0)),
+                }));
+            }
+        }
+    }
+}
+function getElevationGroupFromConfig(id, marketElevationGroupConfig, debtReserve) {
+    const elevationGroup = {
+        id,
+        debtReserve,
+        maxLiquidationBonusBps: 100,
+        maxReservesAsCollateral: marketElevationGroupConfig.maxReservesAsCollateral,
+        padding0: 0,
+        padding1: new Array(4).fill(new bn_js_1.default(0)),
+        allowNewLoans: 1,
+        liquidationThresholdPct: marketElevationGroupConfig.liquidationLtv,
+        ltvPct: marketElevationGroupConfig.maxLtv,
+    };
+    return new types_1.ElevationGroup(elevationGroup);
+}
+const bufferToNumberArray = (buffer) => {
+    return Array.from(new Uint8Array(buffer));
+};
+exports.bufferToNumberArray = bufferToNumberArray;
+function testKaminoReserve(args) {
+    const state = testReserve(args);
+    const rpc = (0, env_1.initRpc)();
+    return new src_1.KaminoReserve(state, src_1.DEFAULT_PUBLIC_KEY, {
+        price: new decimal_js_1.default(args.price ? args.price : 1),
+        timestamp: BigInt(0),
+        decimals: new decimal_js_1.default(0),
+        mintAddress: src_1.DEFAULT_PUBLIC_KEY,
+        valid: true,
+    }, rpc, src_1.DEFAULT_RECENT_SLOT_DURATION_MS);
+}
+function testReserve({ lastUpdateSlot, collTotalSupply, liquidityAvailableAmount, borrowedAmount, accumulatedProtocolFees, accumulatedReferrerFeesSf, pendingReferrerFeesSf, borrowRateCurve, protocolTakeRatePct, hostFixedInterestRateBps, }) {
+    const r = getDefaultReserveFields();
+    r.lastUpdate.slot = lastUpdateSlot ? new bn_js_1.default(lastUpdateSlot) : r.lastUpdate.slot;
+    r.collateral.mintTotalSupply = collTotalSupply || r.collateral.mintTotalSupply;
+    r.liquidity.availableAmount = liquidityAvailableAmount || r.liquidity.availableAmount;
+    r.liquidity.borrowedAmountSf = borrowedAmount || r.liquidity.borrowedAmountSf;
+    r.liquidity.accumulatedProtocolFeesSf = accumulatedProtocolFees || r.liquidity.accumulatedProtocolFeesSf;
+    r.liquidity.accumulatedReferrerFeesSf = accumulatedReferrerFeesSf || r.liquidity.accumulatedReferrerFeesSf;
+    r.liquidity.pendingReferrerFeesSf = pendingReferrerFeesSf || r.liquidity.pendingReferrerFeesSf;
+    r.config.borrowRateCurve.points = borrowRateCurve || r.config.borrowRateCurve.points;
+    r.config.protocolTakeRatePct = protocolTakeRatePct || r.config.protocolTakeRatePct;
+    r.config.hostFixedInterestRateBps = hostFixedInterestRateBps || r.config.hostFixedInterestRateBps;
+    return new src_1.Reserve(r);
+}
+function getDefaultReserveFields() {
+    return {
+        collateral: {
+            mintPubkey: src_1.DEFAULT_PUBLIC_KEY,
+            mintTotalSupply: new bn_js_1.default(0),
+            padding1: [],
+            padding2: [],
+            supplyVault: src_1.DEFAULT_PUBLIC_KEY,
+        },
+        config: {
+            assetTier: 0,
+            badDebtLiquidationBonusBps: 0,
+            borrowFactorPct: new bn_js_1.default(0),
+            borrowLimit: new bn_js_1.default(0),
+            borrowRateCurve: {
+                points: [],
+            },
+            debtWithdrawalCap: {
+                configCapacity: new bn_js_1.default(0),
+                configIntervalLengthSeconds: new bn_js_1.default(0),
+                currentTotal: new bn_js_1.default(0),
+                lastIntervalStartTimestamp: new bn_js_1.default(0),
+            },
+            deleveragingMarginCallPeriodSecs: new bn_js_1.default(0),
+            deleveragingThresholdDecreaseBpsPerDay: new bn_js_1.default(0),
+            autodeleverageEnabled: 0,
+            deleveragingBonusIncreaseBpsPerDay: new bn_js_1.default(0),
+            depositLimit: new bn_js_1.default(0),
+            depositWithdrawalCap: {
+                configCapacity: new bn_js_1.default(0),
+                configIntervalLengthSeconds: new bn_js_1.default(0),
+                currentTotal: new bn_js_1.default(0),
+                lastIntervalStartTimestamp: new bn_js_1.default(0),
+            },
+            elevationGroups: [],
+            fees: {
+                borrowFeeSf: new bn_js_1.default(0),
+                flashLoanFeeSf: new bn_js_1.default(0),
+                padding: [],
+            },
+            disableUsageAsCollOutsideEmode: 0,
+            liquidationThresholdPct: 0,
+            loanToValuePct: 0,
+            maxLiquidationBonusBps: 0,
+            minLiquidationBonusBps: 0,
+            protocolLiquidationFeePct: 0,
+            protocolOrderExecutionFeePct: 0,
+            protocolTakeRatePct: 0,
+            reserved1: [],
+            reserved2: [],
+            hostFixedInterestRateBps: 0,
+            utilizationLimitBlockBorrowingAbovePct: 0,
+            borrowLimitOutsideElevationGroup: new bn_js_1.default(0),
+            borrowLimitAgainstThisCollateralInElevationGroup: new Array(32).fill(new bn_js_1.default(0)),
+            status: 0,
+            tokenInfo: {
+                heuristic: {
+                    exp: new bn_js_1.default(0),
+                    lower: new bn_js_1.default(0),
+                    upper: new bn_js_1.default(0),
+                },
+                maxAgePriceSeconds: new bn_js_1.default(0),
+                maxAgeTwapSeconds: new bn_js_1.default(0),
+                maxTwapDivergenceBps: new bn_js_1.default(0),
+                name: [],
+                padding: [],
+                pythConfiguration: {
+                    price: src_1.DEFAULT_PUBLIC_KEY,
+                },
+                scopeConfiguration: {
+                    priceChain: [],
+                    priceFeed: src_1.DEFAULT_PUBLIC_KEY,
+                    twapChain: [],
+                },
+                switchboardConfiguration: {
+                    priceAggregator: src_1.DEFAULT_PUBLIC_KEY,
+                    twapAggregator: src_1.DEFAULT_PUBLIC_KEY,
+                },
+                blockPriceUsage: 0,
+                reserved: [],
+            },
+        },
+        configPadding: [],
+        farmCollateral: src_1.DEFAULT_PUBLIC_KEY,
+        farmDebt: src_1.DEFAULT_PUBLIC_KEY,
+        lastUpdate: {
+            placeholder: [],
+            priceStatus: 0,
+            slot: new bn_js_1.default(0),
+            stale: 0,
+        },
+        lendingMarket: src_1.DEFAULT_PUBLIC_KEY,
+        liquidity: {
+            absoluteReferralRateSf: new bn_js_1.default(0),
+            accumulatedProtocolFeesSf: new bn_js_1.default(0),
+            accumulatedReferrerFeesSf: new bn_js_1.default(0),
+            availableAmount: new bn_js_1.default(0),
+            borrowLimitCrossedTimestamp: new bn_js_1.default(0),
+            borrowedAmountSf: new bn_js_1.default(0),
+            cumulativeBorrowRateBsf: {
+                padding: [],
+                value: [],
+            },
+            depositLimitCrossedTimestamp: new bn_js_1.default(0),
+            feeVault: src_1.DEFAULT_PUBLIC_KEY,
+            marketPriceLastUpdatedTs: new bn_js_1.default(0),
+            marketPriceSf: new bn_js_1.default(0),
+            mintDecimals: new bn_js_1.default(6),
+            mintPubkey: src_1.DEFAULT_PUBLIC_KEY,
+            padding2: [],
+            padding3: [],
+            pendingReferrerFeesSf: new bn_js_1.default(0),
+            supplyVault: src_1.DEFAULT_PUBLIC_KEY,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+        },
+        padding: [],
+        reserveCollateralPadding: [],
+        reserveLiquidityPadding: [],
+        version: new bn_js_1.default(0),
+        borrowedAmountOutsideElevationGroup: new bn_js_1.default(0),
+        borrowedAmountsAgainstThisReserveInElevationGroups: new Array(32).fill(new bn_js_1.default(0)),
+    };
+}
+function testCurve() {
+    return [
+        {
+            utilizationRateBps: 0,
+            borrowRateBps: 1,
+        },
+        {
+            utilizationRateBps: 8000,
+            borrowRateBps: 300,
+        },
+        {
+            utilizationRateBps: 8500,
+            borrowRateBps: 670,
+        },
+        {
+            utilizationRateBps: 9000,
+            borrowRateBps: 1500,
+        },
+        {
+            utilizationRateBps: 9500,
+            borrowRateBps: 3354,
+        },
+        {
+            utilizationRateBps: 10000,
+            borrowRateBps: 7500,
+        },
+    ];
+}
+//# sourceMappingURL=setup_utils.js.map