@pyron-finance/pyron-client 2.1.0 → 2.2.1

package/dist/index.cjs

@@ -1,4 +1,4 @@
-const require_common = require('./common-DPdmGMEV.cjs');
+const require_common = require('./common-C1TNbOrw.cjs');
 const __coral_xyz_anchor = require_common.__toESM(require("@coral-xyz/anchor"));
 const __solana_spl_token = require_common.__toESM(require("@solana/spl-token"));
 const __solana_web3_js = require_common.__toESM(require("@solana/web3.js"));
@@ -229,6 +229,7 @@ var FogoMetadataFetcher = class {
 
 //#endregion
 //#region src/config.ts
+require_common.init_constants();
 function getConfig({ environment = "production", overrides } = {}) {
 	return {
 		environment,
@@ -9880,6 +9881,7 @@ const LENDR_IDL = lendr_0_1_6_default;
 
 //#endregion
 //#region src/errors.ts
+require_common.init_constants();
 let ProcessTransactionErrorType = /* @__PURE__ */ function(ProcessTransactionErrorType$1) {
 	ProcessTransactionErrorType$1[ProcessTransactionErrorType$1["TransactionBuildingError"] = 0] = "TransactionBuildingError";
 	ProcessTransactionErrorType$1[ProcessTransactionErrorType$1["TransactionSendingError"] = 1] = "TransactionSendingError";
@@ -10485,6 +10487,7 @@ let AccountType = /* @__PURE__ */ function(AccountType$2) {
 
 //#endregion
 //#region src/services/bank/utils/deserialize.utils.ts
+require_common.init_constants();
 function decodeBankRaw(encoded, idl) {
 	const coder = new __coral_xyz_anchor.BorshCoder(idl);
 	return coder.accounts.decode(AccountType.Bank, encoded);
@@ -11150,554 +11153,576 @@ const getStakeAccount = (data) => {
 
 //#endregion
 //#region src/vendor/single-spl-pool/index.ts
-var SinglePoolInstructionType = /* @__PURE__ */ function(SinglePoolInstructionType$1) {
-	SinglePoolInstructionType$1[SinglePoolInstructionType$1["InitializePool"] = 0] = "InitializePool";
-	SinglePoolInstructionType$1[SinglePoolInstructionType$1["ReplenishPool"] = 1] = "ReplenishPool";
-	SinglePoolInstructionType$1[SinglePoolInstructionType$1["DepositStake"] = 2] = "DepositStake";
-	SinglePoolInstructionType$1[SinglePoolInstructionType$1["WithdrawStake"] = 3] = "WithdrawStake";
-	SinglePoolInstructionType$1[SinglePoolInstructionType$1["CreateTokenMetadata"] = 4] = "CreateTokenMetadata";
-	SinglePoolInstructionType$1[SinglePoolInstructionType$1["UpdateTokenMetadata"] = 5] = "UpdateTokenMetadata";
-	SinglePoolInstructionType$1[SinglePoolInstructionType$1["InitializeOnRamp"] = 6] = "InitializeOnRamp";
-	return SinglePoolInstructionType$1;
-}(SinglePoolInstructionType || {});
-const SinglePoolInstruction = {
-	initializePool: (voteAccount) => {
-		const pool = findPoolAddress(voteAccount);
-		const stake = findPoolStakeAddress(pool);
-		const mint = findPoolMintAddress(pool);
-		const stakeAuthority = findPoolStakeAuthorityAddress(pool);
-		const mintAuthority = findPoolMintAuthorityAddress(pool);
-		return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: voteAccount,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: pool,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: stake,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: mint,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: stakeAuthority,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: mintAuthority,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.SYSVAR_RENT_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.SYSVAR_CLOCK_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.SYSVAR_STAKE_HISTORY_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: __solana_web3_js.STAKE_CONFIG_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.SYSTEM_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: __solana_spl_token.TOKEN_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.STAKE_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			}
-		], Buffer.from([SinglePoolInstructionType.InitializePool]));
-	},
-	initializeOnRamp: (pool) => {
-		const onRamp = findPoolOnRampAddress(pool);
-		const stakeAuthority = findPoolStakeAuthorityAddress(pool);
-		return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: pool,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: onRamp,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: stakeAuthority,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.SYSVAR_RENT_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.SYSTEM_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.STAKE_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			}
-		], Buffer.from([SinglePoolInstructionType.InitializeOnRamp]));
-	},
-	depositStake: async (pool, userStakeAccount, userTokenAccount, userLamportAccount) => {
-		const stake = findPoolStakeAddress(pool);
-		const mint = findPoolMintAddress(pool);
-		const stakeAuthority = findPoolStakeAuthorityAddress(pool);
-		const mintAuthority = findPoolMintAuthorityAddress(pool);
-		return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: pool,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: stake,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: mint,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: stakeAuthority,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: mintAuthority,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: userStakeAccount,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: userTokenAccount,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: userLamportAccount,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: require_common.SYSVAR_CLOCK_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.SYSVAR_STAKE_HISTORY_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: __solana_spl_token.TOKEN_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: require_common.STAKE_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
+var single_spl_pool_exports = {};
+require_common.__export(single_spl_pool_exports, {
+	SinglePoolInstruction: () => SinglePoolInstruction,
+	createAccountIx: () => createAccountIx,
+	createPoolOnrampIx: () => createPoolOnrampIx,
+	findMplMetadataAddress: () => findMplMetadataAddress,
+	findPoolAddress: () => findPoolAddress,
+	findPoolMintAddress: () => findPoolMintAddress,
+	findPoolMintAddressByVoteAccount: () => findPoolMintAddressByVoteAccount,
+	findPoolMintAuthorityAddress: () => findPoolMintAuthorityAddress,
+	findPoolMplAuthorityAddress: () => findPoolMplAuthorityAddress,
+	findPoolOnRampAddress: () => findPoolOnRampAddress,
+	findPoolStakeAddress: () => findPoolStakeAddress,
+	findPoolStakeAuthorityAddress: () => findPoolStakeAuthorityAddress,
+	initializeStakedPoolIxs: () => initializeStakedPoolIxs,
+	initializeStakedPoolTx: () => initializeStakedPoolTx,
+	replenishPoolIx: () => replenishPoolIx
+});
+async function initializeStakedPoolTx(connection, payer, voteAccountAddress) {
+	const instructions$3 = await initializeStakedPoolIxs(connection, payer, voteAccountAddress);
+	const tx = new __solana_web3_js.Transaction().add(...instructions$3);
+	return tx;
+}
+async function initializeStakedPoolIxs(connection, payer, voteAccountAddress) {
+	const poolAddress = findPoolAddress(voteAccountAddress);
+	const stakeAddress = findPoolStakeAddress(poolAddress);
+	const mintAddress = findPoolMintAddress(poolAddress);
+	const onRampAddress = findPoolOnRampAddress(poolAddress);
+	const [poolRent, stakeRent, mintRent, minimumDelegationObj] = await Promise.all([
+		connection.getMinimumBalanceForRentExemption(Number(SINGLE_POOL_ACCOUNT_SIZE), "confirmed"),
+		connection.getMinimumBalanceForRentExemption(Number(STAKE_ACCOUNT_SIZE), "confirmed"),
+		connection.getMinimumBalanceForRentExemption(Number(MINT_SIZE), "confirmed"),
+		connection.getStakeMinimumDelegation()
+	]);
+	const minimumDelegation = minimumDelegationObj.value;
+	const instructions$3 = [];
+	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
+		fromPubkey: payer,
+		toPubkey: poolAddress,
+		lamports: poolRent
+	}));
+	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
+		fromPubkey: payer,
+		toPubkey: stakeAddress,
+		lamports: stakeRent + minimumDelegation + __solana_web3_js.LAMPORTS_PER_SOL * 1
+	}));
+	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
+		fromPubkey: payer,
+		toPubkey: onRampAddress,
+		lamports: stakeRent
+	}));
+	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
+		fromPubkey: payer,
+		toPubkey: mintAddress,
+		lamports: mintRent
+	}));
+	instructions$3.push(SinglePoolInstruction.initializePool(voteAccountAddress));
+	instructions$3.push(SinglePoolInstruction.initializeOnRamp(poolAddress));
+	instructions$3.push(await SinglePoolInstruction.createTokenMetadata(poolAddress, payer));
+	return instructions$3;
+}
+var SinglePoolInstructionType, SinglePoolInstruction, createTransactionInstruction, findPda, findPoolMintAddressByVoteAccount, findPoolAddress, findPoolMintAddress, findPoolStakeAddress, findPoolStakeAuthorityAddress, findPoolMintAuthorityAddress, findPoolMplAuthorityAddress, findPoolOnRampAddress, findMplMetadataAddress, SINGLE_POOL_ACCOUNT_SIZE, STAKE_ACCOUNT_SIZE, MINT_SIZE, createAccountIx, createPoolOnrampIx, replenishPoolIx;
+var init_single_spl_pool = require_common.__esm({ "src/vendor/single-spl-pool/index.ts"() {
+	require_common.init_constants();
+	SinglePoolInstructionType = /* @__PURE__ */ function(SinglePoolInstructionType$1) {
+		SinglePoolInstructionType$1[SinglePoolInstructionType$1["InitializePool"] = 0] = "InitializePool";
+		SinglePoolInstructionType$1[SinglePoolInstructionType$1["ReplenishPool"] = 1] = "ReplenishPool";
+		SinglePoolInstructionType$1[SinglePoolInstructionType$1["DepositStake"] = 2] = "DepositStake";
+		SinglePoolInstructionType$1[SinglePoolInstructionType$1["WithdrawStake"] = 3] = "WithdrawStake";
+		SinglePoolInstructionType$1[SinglePoolInstructionType$1["CreateTokenMetadata"] = 4] = "CreateTokenMetadata";
+		SinglePoolInstructionType$1[SinglePoolInstructionType$1["UpdateTokenMetadata"] = 5] = "UpdateTokenMetadata";
+		SinglePoolInstructionType$1[SinglePoolInstructionType$1["InitializeOnRamp"] = 6] = "InitializeOnRamp";
+		return SinglePoolInstructionType$1;
+	}(SinglePoolInstructionType || {});
+	SinglePoolInstruction = {
+		initializePool: (voteAccount) => {
+			const pool = findPoolAddress(voteAccount);
+			const stake = findPoolStakeAddress(pool);
+			const mint = findPoolMintAddress(pool);
+			const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+			const mintAuthority = findPoolMintAuthorityAddress(pool);
+			return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
+				{
+					pubkey: voteAccount,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: pool,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: stake,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: mint,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: stakeAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: mintAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSVAR_RENT_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSVAR_CLOCK_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSVAR_STAKE_HISTORY_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: __solana_web3_js.STAKE_CONFIG_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSTEM_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: __solana_spl_token.TOKEN_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.STAKE_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], Buffer.from([SinglePoolInstructionType.InitializePool]));
+		},
+		initializeOnRamp: (pool) => {
+			const onRamp = findPoolOnRampAddress(pool);
+			const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+			return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
+				{
+					pubkey: pool,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: onRamp,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: stakeAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSVAR_RENT_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSTEM_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.STAKE_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], Buffer.from([SinglePoolInstructionType.InitializeOnRamp]));
+		},
+		depositStake: async (pool, userStakeAccount, userTokenAccount, userLamportAccount) => {
+			const stake = findPoolStakeAddress(pool);
+			const mint = findPoolMintAddress(pool);
+			const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+			const mintAuthority = findPoolMintAuthorityAddress(pool);
+			return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
+				{
+					pubkey: pool,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: stake,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: mint,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: stakeAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: mintAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: userStakeAccount,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: userTokenAccount,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: userLamportAccount,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: require_common.SYSVAR_CLOCK_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSVAR_STAKE_HISTORY_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: __solana_spl_token.TOKEN_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.STAKE_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], Buffer.from([SinglePoolInstructionType.DepositStake]));
+		},
+		withdrawStake: async (pool, userStakeAccount, userStakeAuthority, userTokenAccount, tokenAmount) => {
+			const stake = findPoolStakeAddress(pool);
+			const mint = findPoolMintAddress(pool);
+			const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+			const mintAuthority = findPoolMintAuthorityAddress(pool);
+			const rawAmount = BigInt(tokenAmount.multipliedBy(1e9).toString());
+			const data = Buffer.concat([
+				Buffer.from([SinglePoolInstructionType.WithdrawStake]),
+				userStakeAuthority.toBuffer(),
+				Buffer.from(new bn_js.BN(rawAmount.toString()).toArray("le", 8))
+			]);
+			return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
+				{
+					pubkey: pool,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: stake,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: mint,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: stakeAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: mintAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: userStakeAccount,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: userTokenAccount,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: require_common.SYSVAR_CLOCK_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: __solana_spl_token.TOKEN_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.STAKE_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], data);
+		},
+		createTokenMetadata: async (pool, payer) => {
+			const mint = findPoolMintAddress(pool);
+			const [mintAuthority, mplAuthority, mplMetadata] = await Promise.all([
+				findPoolMintAuthorityAddress(pool),
+				findPoolMplAuthorityAddress(pool),
+				findMplMetadataAddress(mint)
+			]);
+			return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
+				{
+					pubkey: pool,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: mint,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: mintAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: mplAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: payer,
+					isSigner: true,
+					isWritable: true
+				},
+				{
+					pubkey: mplMetadata,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: require_common.MPL_METADATA_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: require_common.SYSTEM_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], Buffer.from([SinglePoolInstructionType.CreateTokenMetadata]));
+		},
+		updateTokenMetadata: async (voteAccount, authorizedWithdrawer, tokenName, tokenSymbol, tokenUri = "") => {
+			if (tokenName.length > 32) {
+				throw new Error("maximum token name length is 32 characters");
 			}
-		], Buffer.from([SinglePoolInstructionType.DepositStake]));
-	},
-	withdrawStake: async (pool, userStakeAccount, userStakeAuthority, userTokenAccount, tokenAmount) => {
-		const stake = findPoolStakeAddress(pool);
-		const mint = findPoolMintAddress(pool);
-		const stakeAuthority = findPoolStakeAuthorityAddress(pool);
-		const mintAuthority = findPoolMintAuthorityAddress(pool);
-		const rawAmount = BigInt(tokenAmount.multipliedBy(1e9).toString());
+			if (tokenSymbol.length > 10) {
+				throw new Error("maximum token symbol length is 10 characters");
+			}
+			if (tokenUri.length > 200) {
+				throw new Error("maximum token uri length is 200 characters");
+			}
+			const pool = findPoolAddress(voteAccount);
+			const [mint, mplAuthority] = await Promise.all([findPoolMintAddress(pool), findPoolMplAuthorityAddress(pool)]);
+			const mplMetadata = await findMplMetadataAddress(mint);
+			const data = Buffer.concat([
+				Buffer.from([SinglePoolInstructionType.UpdateTokenMetadata]),
+				Buffer.from(new Uint32Array([tokenName.length]).buffer),
+				Buffer.from(tokenName),
+				Buffer.from(new Uint32Array([tokenSymbol.length]).buffer),
+				Buffer.from(tokenSymbol),
+				Buffer.from(new Uint32Array([tokenUri.length]).buffer),
+				Buffer.from(tokenUri)
+			]);
+			return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
+				{
+					pubkey: voteAccount,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: pool,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: mplAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: authorizedWithdrawer,
+					isSigner: true,
+					isWritable: false
+				},
+				{
+					pubkey: mplMetadata,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: require_common.MPL_METADATA_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], data);
+		}
+	};
+	createTransactionInstruction = (programId, keys, data) => {
+		return {
+			programId,
+			keys,
+			data
+		};
+	};
+	findPda = (baseAddress, prefix, programId = require_common.SINGLE_POOL_PROGRAM_ID) => {
+		const [pda] = __solana_web3_js.PublicKey.findProgramAddressSync([Buffer.from(prefix), baseAddress.toBuffer()], programId);
+		return pda;
+	};
+	findPoolMintAddressByVoteAccount = (voteAccountAddress) => findPda(findPoolAddress(voteAccountAddress), "mint");
+	findPoolAddress = (voteAccountAddress) => findPda(voteAccountAddress, "pool");
+	findPoolMintAddress = (poolAddress) => findPda(poolAddress, "mint");
+	findPoolStakeAddress = (poolAddress) => findPda(poolAddress, "stake");
+	findPoolStakeAuthorityAddress = (poolAddress) => findPda(poolAddress, "stake_authority");
+	findPoolMintAuthorityAddress = (poolAddress) => findPda(poolAddress, "mint_authority");
+	findPoolMplAuthorityAddress = (poolAddress) => findPda(poolAddress, "mpl_authority");
+	findPoolOnRampAddress = (poolAddress) => findPda(poolAddress, "onramp");
+	findMplMetadataAddress = async (poolMintAddress) => {
+		const [pda] = __solana_web3_js.PublicKey.findProgramAddressSync([
+			Buffer.from("metadata"),
+			require_common.MPL_METADATA_PROGRAM_ID.toBuffer(),
+			poolMintAddress.toBuffer()
+		], require_common.MPL_METADATA_PROGRAM_ID);
+		return pda;
+	};
+	SINGLE_POOL_ACCOUNT_SIZE = BigInt(33);
+	STAKE_ACCOUNT_SIZE = BigInt(200);
+	MINT_SIZE = BigInt(82);
+	createAccountIx = (from, newAccount, lamports, space, programAddress) => {
 		const data = Buffer.concat([
-			Buffer.from([SinglePoolInstructionType.WithdrawStake]),
-			userStakeAuthority.toBuffer(),
-			Buffer.from(new bn_js.BN(rawAmount.toString()).toArray("le", 8))
+			Buffer.from([0]),
+			Buffer.from(new bn_js.BN(lamports).toArray("le", 8)),
+			Buffer.from(new bn_js.BN(space).toArray("le", 8)),
+			programAddress.toBuffer()
 		]);
-		return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
+		const accounts$2 = [{
+			pubkey: from,
+			isSigner: true,
+			isWritable: true
+		}, {
+			pubkey: newAccount,
+			isSigner: true,
+			isWritable: true
+		}];
+		return createTransactionInstruction(require_common.SYSTEM_PROGRAM_ID, accounts$2, data);
+	};
+	createPoolOnrampIx = (voteAccount) => {
+		const poolAccount = findPoolAddress(voteAccount);
+		const onRampAccount = findPoolOnRampAddress(poolAccount);
+		const poolStakeAuthority = findPoolStakeAuthorityAddress(poolAccount);
+		const keys = [
 			{
-				pubkey: pool,
+				pubkey: poolAccount,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: stake,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: mint,
+				pubkey: onRampAccount,
 				isSigner: false,
 				isWritable: true
 			},
 			{
-				pubkey: stakeAuthority,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: mintAuthority,
+				pubkey: poolStakeAuthority,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: userStakeAccount,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: userTokenAccount,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: require_common.SYSVAR_CLOCK_ID,
+				pubkey: __solana_web3_js.SYSVAR_RENT_PUBKEY,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: __solana_spl_token.TOKEN_PROGRAM_ID,
+				pubkey: __solana_web3_js.SystemProgram.programId,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: require_common.STAKE_PROGRAM_ID,
+				pubkey: __solana_web3_js.StakeProgram.programId,
 				isSigner: false,
 				isWritable: false
 			}
-		], data);
-	},
-	createTokenMetadata: async (pool, payer) => {
-		const mint = findPoolMintAddress(pool);
-		const [mintAuthority, mplAuthority, mplMetadata] = await Promise.all([
-			findPoolMintAuthorityAddress(pool),
-			findPoolMplAuthorityAddress(pool),
-			findMplMetadataAddress(mint)
-		]);
-		return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: pool,
-				isSigner: false,
-				isWritable: false
-			},
+		];
+		const data = Buffer.from(Uint8Array.of(6));
+		return new __solana_web3_js.TransactionInstruction({
+			keys,
+			programId: require_common.SINGLE_POOL_PROGRAM_ID,
+			data
+		});
+	};
+	replenishPoolIx = (voteAccount) => {
+		const poolAccount = findPoolAddress(voteAccount);
+		const stakePool = findPoolStakeAddress(poolAccount);
+		const onRampPool = findPoolOnRampAddress(poolAccount);
+		const authority = findPoolStakeAuthorityAddress(poolAccount);
+		const keys = [
 			{
-				pubkey: mint,
+				pubkey: voteAccount,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: mintAuthority,
+				pubkey: poolAccount,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: mplAuthority,
+				pubkey: stakePool,
 				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: payer,
-				isSigner: true,
 				isWritable: true
 			},
 			{
-				pubkey: mplMetadata,
+				pubkey: onRampPool,
 				isSigner: false,
 				isWritable: true
 			},
 			{
-				pubkey: require_common.MPL_METADATA_PROGRAM_ID,
+				pubkey: authority,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: require_common.SYSTEM_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			}
-		], Buffer.from([SinglePoolInstructionType.CreateTokenMetadata]));
-	},
-	updateTokenMetadata: async (voteAccount, authorizedWithdrawer, tokenName, tokenSymbol, tokenUri = "") => {
-		if (tokenName.length > 32) {
-			throw new Error("maximum token name length is 32 characters");
-		}
-		if (tokenSymbol.length > 10) {
-			throw new Error("maximum token symbol length is 10 characters");
-		}
-		if (tokenUri.length > 200) {
-			throw new Error("maximum token uri length is 200 characters");
-		}
-		const pool = findPoolAddress(voteAccount);
-		const [mint, mplAuthority] = await Promise.all([findPoolMintAddress(pool), findPoolMplAuthorityAddress(pool)]);
-		const mplMetadata = await findMplMetadataAddress(mint);
-		const data = Buffer.concat([
-			Buffer.from([SinglePoolInstructionType.UpdateTokenMetadata]),
-			Buffer.from(new Uint32Array([tokenName.length]).buffer),
-			Buffer.from(tokenName),
-			Buffer.from(new Uint32Array([tokenSymbol.length]).buffer),
-			Buffer.from(tokenSymbol),
-			Buffer.from(new Uint32Array([tokenUri.length]).buffer),
-			Buffer.from(tokenUri)
-		]);
-		return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: voteAccount,
+				pubkey: __solana_web3_js.SYSVAR_CLOCK_PUBKEY,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: pool,
+				pubkey: require_common.SYSVAR_STAKE_HISTORY_ID,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: mplAuthority,
+				pubkey: __solana_web3_js.STAKE_CONFIG_ID,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: authorizedWithdrawer,
-				isSigner: true,
-				isWritable: false
-			},
-			{
-				pubkey: mplMetadata,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: require_common.MPL_METADATA_PROGRAM_ID,
+				pubkey: __solana_web3_js.StakeProgram.programId,
 				isSigner: false,
 				isWritable: false
 			}
-		], data);
-	}
-};
-const createTransactionInstruction = (programId, keys, data) => {
-	return {
-		programId,
-		keys,
-		data
+		];
+		const data = Buffer.from(Uint8Array.of(1));
+		return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, keys, data);
 	};
-};
-const findPda = (baseAddress, prefix, programId = require_common.SINGLE_POOL_PROGRAM_ID) => {
-	const [pda] = __solana_web3_js.PublicKey.findProgramAddressSync([Buffer.from(prefix), baseAddress.toBuffer()], programId);
-	return pda;
-};
-const findPoolMintAddressByVoteAccount = (voteAccountAddress) => findPda(findPoolAddress(voteAccountAddress), "mint");
-const findPoolAddress = (voteAccountAddress) => findPda(voteAccountAddress, "pool");
-const findPoolMintAddress = (poolAddress) => findPda(poolAddress, "mint");
-const findPoolStakeAddress = (poolAddress) => findPda(poolAddress, "stake");
-const findPoolStakeAuthorityAddress = (poolAddress) => findPda(poolAddress, "stake_authority");
-const findPoolMintAuthorityAddress = (poolAddress) => findPda(poolAddress, "mint_authority");
-const findPoolMplAuthorityAddress = (poolAddress) => findPda(poolAddress, "mpl_authority");
-const findPoolOnRampAddress = (poolAddress) => findPda(poolAddress, "onramp");
-const findMplMetadataAddress = async (poolMintAddress) => {
-	const [pda] = __solana_web3_js.PublicKey.findProgramAddressSync([
-		Buffer.from("metadata"),
-		require_common.MPL_METADATA_PROGRAM_ID.toBuffer(),
-		poolMintAddress.toBuffer()
-	], require_common.MPL_METADATA_PROGRAM_ID);
-	return pda;
-};
-const SINGLE_POOL_ACCOUNT_SIZE = BigInt(33);
-const STAKE_ACCOUNT_SIZE = BigInt(200);
-const MINT_SIZE = BigInt(82);
-async function initializeStakedPoolTx(connection, payer, voteAccountAddress) {
-	const instructions$3 = await initializeStakedPoolIxs(connection, payer, voteAccountAddress);
-	const tx = new __solana_web3_js.Transaction().add(...instructions$3);
-	return tx;
-}
-async function initializeStakedPoolIxs(connection, payer, voteAccountAddress) {
-	const poolAddress = findPoolAddress(voteAccountAddress);
-	const stakeAddress = findPoolStakeAddress(poolAddress);
-	const mintAddress = findPoolMintAddress(poolAddress);
-	const onRampAddress = findPoolOnRampAddress(poolAddress);
-	const [poolRent, stakeRent, mintRent, minimumDelegationObj] = await Promise.all([
-		connection.getMinimumBalanceForRentExemption(Number(SINGLE_POOL_ACCOUNT_SIZE), "confirmed"),
-		connection.getMinimumBalanceForRentExemption(Number(STAKE_ACCOUNT_SIZE), "confirmed"),
-		connection.getMinimumBalanceForRentExemption(Number(MINT_SIZE), "confirmed"),
-		connection.getStakeMinimumDelegation()
-	]);
-	const minimumDelegation = minimumDelegationObj.value;
-	const instructions$3 = [];
-	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
-		fromPubkey: payer,
-		toPubkey: poolAddress,
-		lamports: poolRent
-	}));
-	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
-		fromPubkey: payer,
-		toPubkey: stakeAddress,
-		lamports: stakeRent + minimumDelegation + __solana_web3_js.LAMPORTS_PER_SOL * 1
-	}));
-	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
-		fromPubkey: payer,
-		toPubkey: onRampAddress,
-		lamports: stakeRent
-	}));
-	instructions$3.push(__solana_web3_js.SystemProgram.transfer({
-		fromPubkey: payer,
-		toPubkey: mintAddress,
-		lamports: mintRent
-	}));
-	instructions$3.push(SinglePoolInstruction.initializePool(voteAccountAddress));
-	instructions$3.push(SinglePoolInstruction.initializeOnRamp(poolAddress));
-	instructions$3.push(await SinglePoolInstruction.createTokenMetadata(poolAddress, payer));
-	return instructions$3;
-}
-const createAccountIx = (from, newAccount, lamports, space, programAddress) => {
-	const data = Buffer.concat([
-		Buffer.from([0]),
-		Buffer.from(new bn_js.BN(lamports).toArray("le", 8)),
-		Buffer.from(new bn_js.BN(space).toArray("le", 8)),
-		programAddress.toBuffer()
-	]);
-	const accounts$2 = [{
-		pubkey: from,
-		isSigner: true,
-		isWritable: true
-	}, {
-		pubkey: newAccount,
-		isSigner: true,
-		isWritable: true
-	}];
-	return createTransactionInstruction(require_common.SYSTEM_PROGRAM_ID, accounts$2, data);
-};
-const createPoolOnrampIx = (voteAccount) => {
-	const poolAccount = findPoolAddress(voteAccount);
-	const onRampAccount = findPoolOnRampAddress(poolAccount);
-	const poolStakeAuthority = findPoolStakeAuthorityAddress(poolAccount);
-	const keys = [
-		{
-			pubkey: poolAccount,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: onRampAccount,
-			isSigner: false,
-			isWritable: true
-		},
-		{
-			pubkey: poolStakeAuthority,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: __solana_web3_js.SYSVAR_RENT_PUBKEY,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: __solana_web3_js.SystemProgram.programId,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: __solana_web3_js.StakeProgram.programId,
-			isSigner: false,
-			isWritable: false
-		}
-	];
-	const data = Buffer.from(Uint8Array.of(6));
-	return new __solana_web3_js.TransactionInstruction({
-		keys,
-		programId: require_common.SINGLE_POOL_PROGRAM_ID,
-		data
-	});
-};
-const replenishPoolIx = (voteAccount) => {
-	const poolAccount = findPoolAddress(voteAccount);
-	const stakePool = findPoolStakeAddress(poolAccount);
-	const onRampPool = findPoolOnRampAddress(poolAccount);
-	const authority = findPoolStakeAuthorityAddress(poolAccount);
-	const keys = [
-		{
-			pubkey: voteAccount,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: poolAccount,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: stakePool,
-			isSigner: false,
-			isWritable: true
-		},
-		{
-			pubkey: onRampPool,
-			isSigner: false,
-			isWritable: true
-		},
-		{
-			pubkey: authority,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: __solana_web3_js.SYSVAR_CLOCK_PUBKEY,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: require_common.SYSVAR_STAKE_HISTORY_ID,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: __solana_web3_js.STAKE_CONFIG_ID,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: __solana_web3_js.StakeProgram.programId,
-			isSigner: false,
-			isWritable: false
-		}
-	];
-	const data = Buffer.from(Uint8Array.of(1));
-	return createTransactionInstruction(require_common.SINGLE_POOL_PROGRAM_ID, keys, data);
-};
+} });
 
 //#endregion
 //#region src/vendor/switchboard_legacy/account.ts
@@ -15995,9 +16020,11 @@ require_common.__export(vendor_exports, {
 	replenishPoolIx: () => replenishPoolIx,
 	switchboardAccountCoder: () => switchboardAccountCoder
 });
+init_single_spl_pool();
 
 //#endregion
 //#region src/utils.ts
+require_common.init_constants();
 function getBankVaultSeeds(type) {
 	switch (type) {
 		case BankVaultType.LiquidityVault: return require_common.PDA_BANK_LIQUIDITY_VAULT_SEED;
@@ -18729,6 +18756,7 @@ let PriceBias = /* @__PURE__ */ function(PriceBias$1) {
 
 //#endregion
 //#region src/services/price/utils/compute.utils.ts
+require_common.init_constants();
 function getPriceWithConfidence(oraclePrice, weighted) {
 	return weighted ? oraclePrice.priceWeighted : oraclePrice.priceRealtime;
 }
@@ -19355,15 +19383,89 @@ function computeInterestRates(bank) {
 		borrowingRate
 	};
 }
-function computeBaseInterestRate(bank) {
-	const { optimalUtilizationRate, plateauInterestRate, maxInterestRate } = bank.config.interestRateConfig;
-	const utilizationRate = computeUtilizationRate(bank);
+/**
+* Maximum value for u32
+*/
+const U32_MAX = 4294967295;
+/**
+* Convert u32 encoded rate to APR percentage (0.0 to 10.0)
+* Rate is encoded as: rate / u32::MAX * 1000%
+* Example: 100% APR = 0.1 * u32::MAX
+*/
+function rateFromU32(rate) {
+	const ratio = new bignumber_js.default(rate).div(U32_MAX);
+	return ratio.times(10);
+}
+/**
+* Convert u32 encoded utilization to percentage (0.0 to 1.0)
+* Util is encoded as: util / u32::MAX * 100%
+* Example: 50% = 0.5 * u32::MAX
+*/
+function utilFromU32(util) {
+	return new bignumber_js.default(util).div(U32_MAX);
+}
+/**
+* Linear interpolation between two points
+* Given points (startX, startY) and (endX, endY), find Y at targetX
+*/
+function calculateRateBetweenPoints(startX, startY, endX, endY, targetX) {
+	if (endX.lte(startX)) return startY;
+	if (targetX.lt(startX)) return startY;
+	if (targetX.gt(endX)) return endY;
+	if (endY.lt(startY)) return startY;
+	const deltaX = endX.minus(startX);
+	if (deltaX.isZero()) return startY;
+	const offset = targetX.minus(startX);
+	const proportion = offset.div(deltaX);
+	const deltaY = endY.minus(startY);
+	const scaledDelta = deltaY.times(proportion);
+	return startY.plus(scaledDelta);
+}
+/**
+* Compute base interest rate using the legacy 3-point curve
+*/
+function computeLegacyCurve(utilizationRate, optimalUtilizationRate, plateauInterestRate, maxInterestRate) {
 	if (utilizationRate.lte(optimalUtilizationRate)) {
 		return utilizationRate.times(plateauInterestRate).div(optimalUtilizationRate);
 	} else {
 		return utilizationRate.minus(optimalUtilizationRate).div(new bignumber_js.default(1).minus(optimalUtilizationRate)).times(maxInterestRate.minus(plateauInterestRate)).plus(plateauInterestRate);
 	}
 }
+/**
+* Compute base interest rate using the 7-point multipoint curve
+* Locates utilization on a linear function with up to 7 points:
+* - Point 1: (0%, zeroUtilRate)
+* - Points 2-6: Custom points from the points array
+* - Point 7: (100%, hundredUtilRate)
+*/
+function computeMultipointCurve(utilizationRate, zeroUtilRate, hundredUtilRate, points) {
+	const zeroRate = rateFromU32(zeroUtilRate);
+	const hundredRate = rateFromU32(hundredUtilRate);
+	const clampedUtilizationRate = bignumber_js.default.max(0, bignumber_js.default.min(1, utilizationRate));
+	const nonPaddingPoints = points.filter((point) => point.util !== 0);
+	let prevUtil = new bignumber_js.default(0);
+	let prevRate = zeroRate;
+	for (const point of nonPaddingPoints) {
+		const pointUtil = utilFromU32(point.util);
+		const pointRate = rateFromU32(point.rate);
+		if (clampedUtilizationRate.lte(pointUtil)) {
+			return calculateRateBetweenPoints(prevUtil, prevRate, pointUtil, pointRate, clampedUtilizationRate);
+		}
+		prevUtil = pointUtil;
+		prevRate = pointRate;
+	}
+	return calculateRateBetweenPoints(prevUtil, prevRate, new bignumber_js.default(1), hundredRate, clampedUtilizationRate);
+}
+function computeBaseInterestRate(bank) {
+	const interestRateConfig = bank.config.interestRateConfig;
+	const utilizationRate = computeUtilizationRate(bank);
+	const curveType = interestRateConfig.curveType;
+	if (curveType === 1) {
+		return computeMultipointCurve(utilizationRate, interestRateConfig.zeroUtilRate, interestRateConfig.hundredUtilRate, interestRateConfig.points);
+	} else {
+		return computeLegacyCurve(utilizationRate, interestRateConfig.optimalUtilizationRate, interestRateConfig.plateauInterestRate, interestRateConfig.maxInterestRate);
+	}
+}
 function computeUtilizationRate(bank) {
 	const assets = getTotalAssetQuantity(bank);
 	const liabilities = getTotalLiabilityQuantity(bank);
@@ -19696,6 +19798,7 @@ function bankConfigRawToDto(bankConfigRaw) {
 
 //#endregion
 //#region src/services/bank/bank.service.ts
+require_common.init_constants();
 async function freezeBankConfigIx(program, bankAddress, bankConfigOpt) {
 	if (!bankConfigOpt) {}
 	const bankConfigRaw = serializeBankConfigOpt(bankConfigOpt);
@@ -20067,6 +20170,7 @@ async function executeBundleSimulation(rpcEndpoint, encodedTransactions, config)
 
 //#endregion
 //#region src/services/transaction/transaction.service.ts
+require_common.init_constants();
 const DEFAULT_PROCESS_TX_OPTS = {
 	broadcastType: "RPC",
 	isSequentialTxs: true,
@@ -20663,6 +20767,7 @@ function addTransactionTxTags(transactions) {
 
 //#endregion
 //#region src/services/account/utils/compute.utils.ts
+init_single_spl_pool();
 /**
 * Lendr Account Computes
 * =========================
@@ -21614,6 +21719,8 @@ function getActiveStaleBanks(balances, banks, additionalBanks, oraclePrices, max
 
 //#endregion
 //#region src/services/group/group.service.ts
+require_common.init_constants();
+init_single_spl_pool();
 async function makePoolConfigureBankIx(program, bank, args) {
 	const ix = await instructions_default.makePoolConfigureBankIx(program, { bank }, { bankConfigOpt: args });
 	return {
@@ -21747,6 +21854,8 @@ function dtoToValidatorStakeGroup(validatorStakeGroupDto) {
 
 //#endregion
 //#region src/services/native-stake/utils/fetch.utils.ts
+require_common.init_constants();
+init_single_spl_pool();
 /**
 * Retrieves all active stake accounts associated with a given public key grouped by validator
 *
@@ -22654,7 +22763,7 @@ var LendrAccount = class LendrAccount {
 			keys: []
 		};
 	}
-	async prepareWithdrawInstruction(program, bankMap, mintDatas, bankAddress, withdrawAll = false, withdrawOpts = {}) {
+	async prepareWithdrawInstruction(program, bankMap, mintDatas, bankMetadataMap, bankAddress, withdrawAll = false, withdrawOpts = {}) {
 		const bank = bankMap.get(bankAddress.toBase58());
 		if (!bank) throw Error(`Bank ${bankAddress.toBase58()} not found`);
 		const mintData = mintDatas.get(bankAddress.toBase58());
@@ -22678,9 +22787,23 @@ var LendrAccount = class LendrAccount {
 		if (withdrawOpts.observationBanksOverride) {
 			remainingAccounts.push(...withdrawOpts.observationBanksOverride);
 		} else {
-			const accountMetas = computeHealthAccountMetas(healthAccounts);
+			const accountMetas = computeHealthAccountMetas(healthAccounts, bankMetadataMap);
 			remainingAccounts.push(...accountMetas);
 		}
+		if (withdrawAll) {
+			remainingAccounts.push(bank.address, bank.config.oracleKeys[0]);
+			if (bank.config.assetTag === 2) {
+				const bankMetadata = bankMetadataMap?.[bankAddress.toBase58()];
+				if (!bankMetadata?.validatorVoteAccount) {
+					throw Error(`No validator vote account for staked bank ${bankAddress.toBase58()}`);
+				}
+				const { findPoolAddress: findPoolAddress$1, findPoolStakeAddress: findPoolStakeAddress$1, findPoolMintAddress: findPoolMintAddress$1 } = (init_single_spl_pool(), require_common.__toCommonJS(single_spl_pool_exports));
+				const pool = findPoolAddress$1(new __solana_web3_js.PublicKey(bankMetadata.validatorVoteAccount));
+				const solPool = findPoolStakeAddress$1(pool);
+				const lstMint = findPoolMintAddress$1(pool);
+				remainingAccounts.push(lstMint, solPool);
+			}
+		}
 		return {
 			withdrawIxs,
 			wrapAndUnwrapSol,
@@ -22694,8 +22817,8 @@ var LendrAccount = class LendrAccount {
 			}))
 		};
 	}
-	async makeWithdrawIx(program, bankMap, mintDatas, amount, bankAddress, withdrawAll = false, withdrawOpts = {}) {
-		const { withdrawIxs, wrapAndUnwrapSol, userAta, mintData, bank, remainingAccounts } = await this.prepareWithdrawInstruction(program, bankMap, mintDatas, bankAddress, withdrawAll, withdrawOpts);
+	async makeWithdrawIx(program, bankMap, mintDatas, bankMetadataMap, amount, bankAddress, withdrawAll = false, withdrawOpts = {}) {
+		const { withdrawIxs, wrapAndUnwrapSol, userAta, mintData, bank, remainingAccounts } = await this.prepareWithdrawInstruction(program, bankMap, mintDatas, bankMetadataMap, bankAddress, withdrawAll, withdrawOpts);
 		const [bankLiquidityVaultAuthority] = getBankVaultAuthority(BankVaultType.LiquidityVault, bank.address, program.programId);
 		const withdrawIx = await instructions_default.makeWithdrawIx(program, {
 			lendrAccount: this.address,
@@ -22719,8 +22842,8 @@ var LendrAccount = class LendrAccount {
 			keys: []
 		};
 	}
-	async makeWithdrawWithSessionIx(program, bankMap, mintDatas, amount, bankAddress, session, withdrawAll = false, withdrawOpts = {}) {
-		const { withdrawIxs, wrapAndUnwrapSol, userAta, mintData, bank, remainingAccounts } = await this.prepareWithdrawInstruction(program, bankMap, mintDatas, bankAddress, withdrawAll, {
+	async makeWithdrawWithSessionIx(program, bankMap, mintDatas, bankMetadataMap, amount, bankAddress, session, withdrawAll = false, withdrawOpts = {}) {
+		const { withdrawIxs, wrapAndUnwrapSol, userAta, mintData, bank, remainingAccounts } = await this.prepareWithdrawInstruction(program, bankMap, mintDatas, bankMetadataMap, bankAddress, withdrawAll, {
 			...withdrawOpts,
 			createAtaPayer: session.payer
 		});
@@ -23038,6 +23161,7 @@ function isWeightedPrice(reqType) {
 
 //#endregion
 //#region src/models/account/wrapper.ts
+require_common.init_constants();
 var LendrAccountWrapper = class LendrAccountWrapper {
 	address;
 	_lendrAccount;
@@ -23945,7 +24069,8 @@ var LendrAccountWrapper = class LendrAccountWrapper {
 	async makeWithdrawIx(amount, bankAddress, withdrawAll = false, withdrawOpts = {}) {
 		const tokenProgramAddress = this.client.mintDatas.get(bankAddress.toBase58())?.tokenProgram;
 		if (!tokenProgramAddress) throw Error("Withdraw mint not found");
-		return this._lendrAccount.makeWithdrawIx(this._program, this.client.banks, this.client.mintDatas, amount, bankAddress, withdrawAll, withdrawOpts);
+		if (!this.client.bankMetadataMap) throw Error("Bank metadata map not found");
+		return this._lendrAccount.makeWithdrawIx(this._program, this.client.banks, this.client.mintDatas, this.client.bankMetadataMap, amount, bankAddress, withdrawAll, withdrawOpts);
 	}
 	/**
 	* Creates instructions for withdrawing tokens from a lendr bank account.
@@ -23961,7 +24086,8 @@ var LendrAccountWrapper = class LendrAccountWrapper {
 	async makeWithdrawWithSessionIx(amount, bankAddress, session, withdrawAll = false, withdrawOpts = {}) {
 		const tokenProgramAddress = this.client.mintDatas.get(bankAddress.toBase58())?.tokenProgram;
 		if (!tokenProgramAddress) throw Error("Withdraw mint not found");
-		return this._lendrAccount.makeWithdrawWithSessionIx(this._program, this.client.banks, this.client.mintDatas, amount, bankAddress, session, withdrawAll, withdrawOpts);
+		if (!this.client.bankMetadataMap) throw Error("Bank metadata map not found");
+		return this._lendrAccount.makeWithdrawWithSessionIx(this._program, this.client.banks, this.client.mintDatas, this.client.bankMetadataMap, amount, bankAddress, session, withdrawAll, withdrawOpts);
 	}
 	/**
 	* Creates a transaction for withdrawing tokens from a lendr bank account and staking them.
@@ -24787,6 +24913,7 @@ var LendrGroup = class LendrGroup {
 
 //#endregion
 //#region src/clients/client.ts
+require_common.init_constants();
 /**
 * Entrypoint to interact with the lendr contract.
 */
@@ -25698,6 +25825,10 @@ var EmodeSettings = class EmodeSettings {
 	}
 };
 
+//#endregion
+//#region src/index.ts
+init_constants();
+
 //#endregion
 exports.AccountFlags = AccountFlags;
 exports.AccountType = AccountType;