@pyron-finance/pyron-client 2.0.1 → 2.2.0

package/dist/index.js

@@ -1,15 +1,15 @@
-import { __export } from "./chunk-Cl8Af3a2.js";
-import { BUNDLE_TX_SIZE, DEFAULT_CLUSTER, DEFAULT_COMMITMENT, DEFAULT_CONFIRM_OPTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_SEND_OPTS, DISABLED_FLAG, DUMMY_USDC_MINT, FLASHLOAN_ENABLED_FLAG, GROUP_PK, HOURS_PER_YEAR, JUPITER_V6_PROGRAM, LENDR_PROGRAM, LST_MINT, LUT_PROGRAM_AUTHORITY_INDEX, MAX_ACCOUNT_KEYS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PRIORITY_TX_SIZE, PROGRAM_ID, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, SINGLE_POOL_PROGRAM_ID, SKIP_SIMULATION, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_EXTENDED_METADATA, WSOL_MINT, addTransactionMetadata, aprToApy, bigNumberToWrappedI80F48, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, composeRemainingAccounts, decodeInstruction, decompileV0Transaction, fetchBanksExtendedMetadata, getAccountKeys, getComputeBudgetUnits, getTxSize, isV0Tx, legacyTxToV0Tx, microLamportsToUi, nativeToUi, setTimeoutPromise, shortenAddress, sleep, splitInstructionsToFitTransactions, toBigNumber, uiToMicroLamports, uiToNative, updateV0Tx, wrappedI80F48toBigNumber } from "./common-CpLJbZfZ.js";
+import { __esm, __export, __toCommonJS } from "./chunk-BaU5PcSi.js";
+import { BUNDLE_TX_SIZE, DEFAULT_CLUSTER, DEFAULT_COMMITMENT, DEFAULT_CONFIRM_OPTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_SEND_OPTS, DISABLED_FLAG, DUMMY_USDC_MINT, FLASHLOAN_ENABLED_FLAG, GROUP_PK, HOURS_PER_YEAR, JUPITER_V6_PROGRAM, LENDR_PROGRAM, LST_MINT, LUT_PROGRAM_AUTHORITY_INDEX, MAX_ACCOUNT_KEYS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PRIORITY_TX_SIZE, PROGRAM_ID, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, SINGLE_POOL_PROGRAM_ID, SKIP_SIMULATION, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionType, USDC_DECIMALS, USDC_MINT, WSOL_EXTENDED_METADATA, WSOL_MINT, addTransactionMetadata, aprToApy, bigNumberToWrappedI80F48, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, composeRemainingAccounts, decodeInstruction, decompileV0Transaction, fetchBanksExtendedMetadata, getAccountKeys, getComputeBudgetUnits, getTxSize, init_constants, isV0Tx, legacyTxToV0Tx, microLamportsToUi, nativeToUi, setTimeoutPromise, shortenAddress, sleep, splitInstructionsToFitTransactions, toBigNumber, uiToMicroLamports, uiToNative, updateV0Tx, wrappedI80F48toBigNumber } from "./common-BDgJX75H.js";
 import * as anchor from "@coral-xyz/anchor";
 import { AnchorProvider, BorshAccountsCoder, BorshCoder, BorshInstructionCoder, LangErrorMessage, Program, translateAddress } from "@coral-xyz/anchor";
-import { MintLayout, NATIVE_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, createApproveInstruction, createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction, createCloseAccountInstruction, createSyncNativeInstruction, createTransferInstruction, getAssociatedTokenAddressSync } from "@solana/spl-token";
+import { MintLayout, NATIVE_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, createApproveInstruction, createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction, createCloseAccountInstruction, createSyncNativeInstruction, getAssociatedTokenAddressSync } from "@solana/spl-token";
 import { ComputeBudgetProgram, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, STAKE_CONFIG_ID as STAKE_CONFIG_ID$1, SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY, SolanaJSONRPCError, StakeAuthorizationLayout, StakeProgram, SystemProgram, Transaction, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
 import BigNumber from "bignumber.js";
-import BN$1, { BN } from "bn.js";
 import bs58 from "bs58";
 import { createStorage, prefixStorage } from "unstorage";
 import * as z$1 from "zod/v4-mini";
 import { z } from "zod/v4-mini";
+import BN$1, { BN } from "bn.js";
 import { findMetadataPda, mplTokenMetadata, safeFetchAllMetadata } from "@metaplex-foundation/mpl-token-metadata";
 import { publicKey } from "@metaplex-foundation/umi";
 import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
@@ -232,6 +232,7 @@ var FogoMetadataFetcher = class {
 
 //#endregion
 //#region src/config.ts
+init_constants();
 function getConfig({ environment = "production", overrides } = {}) {
 	return {
 		environment,
@@ -9883,6 +9884,7 @@ const LENDR_IDL = lendr_0_1_6_default;
 
 //#endregion
 //#region src/errors.ts
+init_constants();
 let ProcessTransactionErrorType = /* @__PURE__ */ function(ProcessTransactionErrorType$1) {
 	ProcessTransactionErrorType$1[ProcessTransactionErrorType$1["TransactionBuildingError"] = 0] = "TransactionBuildingError";
 	ProcessTransactionErrorType$1[ProcessTransactionErrorType$1["TransactionSendingError"] = 1] = "TransactionSendingError";
@@ -10106,8 +10108,17 @@ async function makeInitLendrAccountIx(ldProgram, accounts$2) {
 	return ldProgram.methods.lendrAccountInitialize().accounts(accounts$2).instruction();
 }
 async function makeInitLendrAccountWithSessionIx(ldProgram, { lendrGroup, session, feePayer }, accountIndex, thirdPartyId) {
+	const thirdPartyIdValue = thirdPartyId ?? 0;
+	const [lendrAccount] = PublicKey.findProgramAddressSync([
+		Buffer.from("lendr_account"),
+		lendrGroup.toBuffer(),
+		session.walletPublicKey.toBuffer(),
+		Buffer.from(new Uint16Array([accountIndex]).buffer),
+		Buffer.from(new Uint16Array([thirdPartyIdValue]).buffer)
+	], ldProgram.programId);
 	return ldProgram.methods.lendrAccountInitializeWithSession(session.walletPublicKey, accountIndex, thirdPartyId ?? null).accounts({
 		lendrGroup,
+		lendrAccount,
 		sessionKey: session.sessionPublicKey,
 		feePayer
 	}).instruction();
@@ -10479,6 +10490,7 @@ let AccountType = /* @__PURE__ */ function(AccountType$2) {
 
 //#endregion
 //#region src/services/bank/utils/deserialize.utils.ts
+init_constants();
 function decodeBankRaw(encoded, idl) {
 	const coder = new BorshCoder(idl);
 	return coder.accounts.decode(AccountType.Bank, encoded);
@@ -11144,554 +11156,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(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: SYSVAR_RENT_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: SYSVAR_CLOCK_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: SYSVAR_STAKE_HISTORY_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: STAKE_CONFIG_ID$1,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: SYSTEM_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: TOKEN_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: STAKE_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			}
-		], Buffer.from([SinglePoolInstructionType.InitializePool]));
-	},
-	initializeOnRamp: (pool) => {
-		const onRamp = findPoolOnRampAddress(pool);
-		const stakeAuthority = findPoolStakeAuthorityAddress(pool);
-		return createTransactionInstruction(SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: pool,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: onRamp,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: stakeAuthority,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: SYSVAR_RENT_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: SYSTEM_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: 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(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: SYSVAR_CLOCK_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: SYSVAR_STAKE_HISTORY_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: TOKEN_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
-			},
-			{
-				pubkey: STAKE_PROGRAM_ID,
-				isSigner: false,
-				isWritable: false
+var single_spl_pool_exports = {};
+__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 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(SystemProgram.transfer({
+		fromPubkey: payer,
+		toPubkey: poolAddress,
+		lamports: poolRent
+	}));
+	instructions$3.push(SystemProgram.transfer({
+		fromPubkey: payer,
+		toPubkey: stakeAddress,
+		lamports: stakeRent + minimumDelegation + LAMPORTS_PER_SOL * 1
+	}));
+	instructions$3.push(SystemProgram.transfer({
+		fromPubkey: payer,
+		toPubkey: onRampAddress,
+		lamports: stakeRent
+	}));
+	instructions$3.push(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 = __esm({ "src/vendor/single-spl-pool/index.ts"() {
+	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(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: SYSVAR_RENT_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: SYSVAR_CLOCK_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: SYSVAR_STAKE_HISTORY_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: STAKE_CONFIG_ID$1,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: SYSTEM_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: TOKEN_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: STAKE_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], Buffer.from([SinglePoolInstructionType.InitializePool]));
+		},
+		initializeOnRamp: (pool) => {
+			const onRamp = findPoolOnRampAddress(pool);
+			const stakeAuthority = findPoolStakeAuthorityAddress(pool);
+			return createTransactionInstruction(SINGLE_POOL_PROGRAM_ID, [
+				{
+					pubkey: pool,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: onRamp,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: stakeAuthority,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: SYSVAR_RENT_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: SYSTEM_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: 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(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: SYSVAR_CLOCK_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: SYSVAR_STAKE_HISTORY_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: TOKEN_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: 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(rawAmount.toString()).toArray("le", 8))
+			]);
+			return createTransactionInstruction(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: SYSVAR_CLOCK_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: TOKEN_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: 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(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: MPL_METADATA_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: 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(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: MPL_METADATA_PROGRAM_ID,
+					isSigner: false,
+					isWritable: false
+				}
+			], data);
+		}
+	};
+	createTransactionInstruction = (programId, keys, data) => {
+		return {
+			programId,
+			keys,
+			data
+		};
+	};
+	findPda = (baseAddress, prefix, programId = SINGLE_POOL_PROGRAM_ID) => {
+		const [pda] = 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] = PublicKey.findProgramAddressSync([
+			Buffer.from("metadata"),
+			MPL_METADATA_PROGRAM_ID.toBuffer(),
+			poolMintAddress.toBuffer()
+		], 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(rawAmount.toString()).toArray("le", 8))
+			Buffer.from([0]),
+			Buffer.from(new BN(lamports).toArray("le", 8)),
+			Buffer.from(new BN(space).toArray("le", 8)),
+			programAddress.toBuffer()
 		]);
-		return createTransactionInstruction(SINGLE_POOL_PROGRAM_ID, [
+		const accounts$2 = [{
+			pubkey: from,
+			isSigner: true,
+			isWritable: true
+		}, {
+			pubkey: newAccount,
+			isSigner: true,
+			isWritable: true
+		}];
+		return createTransactionInstruction(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,
+				pubkey: onRampAccount,
 				isSigner: false,
 				isWritable: true
 			},
 			{
-				pubkey: mint,
-				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: SYSVAR_CLOCK_ID,
+				pubkey: SYSVAR_RENT_PUBKEY,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: TOKEN_PROGRAM_ID,
+				pubkey: SystemProgram.programId,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: STAKE_PROGRAM_ID,
+				pubkey: 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(SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: pool,
-				isSigner: false,
-				isWritable: false
-			},
+		];
+		const data = Buffer.from(Uint8Array.of(6));
+		return new TransactionInstruction({
+			keys,
+			programId: 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: MPL_METADATA_PROGRAM_ID,
+				pubkey: authority,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: 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(SINGLE_POOL_PROGRAM_ID, [
-			{
-				pubkey: voteAccount,
+				pubkey: SYSVAR_CLOCK_PUBKEY,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: pool,
+				pubkey: SYSVAR_STAKE_HISTORY_ID,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: mplAuthority,
+				pubkey: STAKE_CONFIG_ID$1,
 				isSigner: false,
 				isWritable: false
 			},
 			{
-				pubkey: authorizedWithdrawer,
-				isSigner: true,
-				isWritable: false
-			},
-			{
-				pubkey: mplMetadata,
-				isSigner: false,
-				isWritable: true
-			},
-			{
-				pubkey: MPL_METADATA_PROGRAM_ID,
+				pubkey: 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(SINGLE_POOL_PROGRAM_ID, keys, data);
 	};
-};
-const findPda = (baseAddress, prefix, programId = SINGLE_POOL_PROGRAM_ID) => {
-	const [pda] = 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] = PublicKey.findProgramAddressSync([
-		Buffer.from("metadata"),
-		MPL_METADATA_PROGRAM_ID.toBuffer(),
-		poolMintAddress.toBuffer()
-	], 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 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(SystemProgram.transfer({
-		fromPubkey: payer,
-		toPubkey: poolAddress,
-		lamports: poolRent
-	}));
-	instructions$3.push(SystemProgram.transfer({
-		fromPubkey: payer,
-		toPubkey: stakeAddress,
-		lamports: stakeRent + minimumDelegation + LAMPORTS_PER_SOL * 1
-	}));
-	instructions$3.push(SystemProgram.transfer({
-		fromPubkey: payer,
-		toPubkey: onRampAddress,
-		lamports: stakeRent
-	}));
-	instructions$3.push(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(lamports).toArray("le", 8)),
-		Buffer.from(new BN(space).toArray("le", 8)),
-		programAddress.toBuffer()
-	]);
-	const accounts$2 = [{
-		pubkey: from,
-		isSigner: true,
-		isWritable: true
-	}, {
-		pubkey: newAccount,
-		isSigner: true,
-		isWritable: true
-	}];
-	return createTransactionInstruction(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: SYSVAR_RENT_PUBKEY,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: SystemProgram.programId,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: StakeProgram.programId,
-			isSigner: false,
-			isWritable: false
-		}
-	];
-	const data = Buffer.from(Uint8Array.of(6));
-	return new TransactionInstruction({
-		keys,
-		programId: 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: SYSVAR_CLOCK_PUBKEY,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: SYSVAR_STAKE_HISTORY_ID,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: STAKE_CONFIG_ID$1,
-			isSigner: false,
-			isWritable: false
-		},
-		{
-			pubkey: StakeProgram.programId,
-			isSigner: false,
-			isWritable: false
-		}
-	];
-	const data = Buffer.from(Uint8Array.of(1));
-	return createTransactionInstruction(SINGLE_POOL_PROGRAM_ID, keys, data);
-};
+} });
 
 //#endregion
 //#region src/vendor/switchboard_legacy/account.ts
@@ -15989,9 +16023,11 @@ __export(vendor_exports, {
 	replenishPoolIx: () => replenishPoolIx,
 	switchboardAccountCoder: () => switchboardAccountCoder
 });
+init_single_spl_pool();
 
 //#endregion
 //#region src/utils.ts
+init_constants();
 function getBankVaultSeeds(type) {
 	switch (type) {
 		case BankVaultType.LiquidityVault: return PDA_BANK_LIQUIDITY_VAULT_SEED;
@@ -18723,6 +18759,7 @@ let PriceBias = /* @__PURE__ */ function(PriceBias$1) {
 
 //#endregion
 //#region src/services/price/utils/compute.utils.ts
+init_constants();
 function getPriceWithConfidence(oraclePrice, weighted) {
 	return weighted ? oraclePrice.priceWeighted : oraclePrice.priceRealtime;
 }
@@ -19690,6 +19727,7 @@ function bankConfigRawToDto(bankConfigRaw) {
 
 //#endregion
 //#region src/services/bank/bank.service.ts
+init_constants();
 async function freezeBankConfigIx(program, bankAddress, bankConfigOpt) {
 	if (!bankConfigOpt) {}
 	const bankConfigRaw = serializeBankConfigOpt(bankConfigOpt);
@@ -20061,6 +20099,7 @@ async function executeBundleSimulation(rpcEndpoint, encodedTransactions, config)
 
 //#endregion
 //#region src/services/transaction/transaction.service.ts
+init_constants();
 const DEFAULT_PROCESS_TX_OPTS = {
 	broadcastType: "RPC",
 	isSequentialTxs: true,
@@ -20657,6 +20696,7 @@ function addTransactionTxTags(transactions) {
 
 //#endregion
 //#region src/services/account/utils/compute.utils.ts
+init_single_spl_pool();
 /**
 * Lendr Account Computes
 * =========================
@@ -21608,6 +21648,8 @@ function getActiveStaleBanks(balances, banks, additionalBanks, oraclePrices, max
 
 //#endregion
 //#region src/services/group/group.service.ts
+init_constants();
+init_single_spl_pool();
 async function makePoolConfigureBankIx(program, bank, args) {
 	const ix = await instructions_default.makePoolConfigureBankIx(program, { bank }, { bankConfigOpt: args });
 	return {
@@ -21741,6 +21783,8 @@ function dtoToValidatorStakeGroup(validatorStakeGroupDto) {
 
 //#endregion
 //#region src/services/native-stake/utils/fetch.utils.ts
+init_constants();
+init_single_spl_pool();
 /**
 * Retrieves all active stake accounts associated with a given public key grouped by validator
 *
@@ -22536,7 +22580,7 @@ var LendrAccount = class LendrAccount {
 			group: opts.overrideInferAccounts?.group ?? this.group,
 			liquidityVault: opts.overrideInferAccounts?.liquidityVault ?? bank.liquidityVault
 		}, ixArguments, remainingAccounts.map((account) => ({
-			pubkey: account,
+			pubkey: account.pubkey,
 			isSigner: false,
 			isWritable: false
 		})));
@@ -22548,9 +22592,6 @@ var LendrAccount = class LendrAccount {
 	}
 	async makeDepositWithSessionIx(program, banks, mintDatas, amount, bankAddress, sessionKey, opts = {}) {
 		const { depositIxs, ixArguments, userTokenAtaPk, mintData, remainingAccounts } = await this.prepareDepositIx(banks, mintDatas, amount, bankAddress, opts);
-		const PAYMASTER_DESTINATION = new PublicKey("43TSuDshgvKXuQCmDwHXmF4s3hH3nmDNJsvWGhoNnb7v");
-		const transferIx = createTransferInstruction(userTokenAtaPk, PAYMASTER_DESTINATION, this.authority, 1e4, [], TOKEN_PROGRAM_ID);
-		depositIxs.unshift(transferIx);
 		const accounts$2 = {
 			sessionKey,
 			lendrAccount: this.address,
@@ -22651,7 +22692,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());
@@ -22675,9 +22716,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(), __toCommonJS(single_spl_pool_exports));
+				const pool = findPoolAddress$1(new PublicKey(bankMetadata.validatorVoteAccount));
+				const solPool = findPoolStakeAddress$1(pool);
+				const lstMint = findPoolMintAddress$1(pool);
+				remainingAccounts.push(lstMint, solPool);
+			}
+		}
 		return {
 			withdrawIxs,
 			wrapAndUnwrapSol,
@@ -22691,8 +22746,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,
@@ -22716,8 +22771,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
 		});
@@ -23035,6 +23090,7 @@ function isWeightedPrice(reqType) {
 
 //#endregion
 //#region src/models/account/wrapper.ts
+init_constants();
 var LendrAccountWrapper = class LendrAccountWrapper {
 	address;
 	_lendrAccount;
@@ -23049,7 +23105,7 @@ var LendrAccountWrapper = class LendrAccountWrapper {
 	static async fetch(lendrAccountPk, client, commitment) {
 		const { config, program } = client;
 		const _lendrAccountPk = translateAddress(lendrAccountPk);
-		const accountData = await LendrAccountWrapper._fetchAccountData(_lendrAccountPk, config, program, commitment);
+		const accountData = await LendrAccountWrapper.fetchAccountData(_lendrAccountPk, config, program, commitment);
 		const lendrAccount = LendrAccount.fromAccountParsed(_lendrAccountPk, accountData);
 		const lendrAccountProxy = new LendrAccountWrapper(_lendrAccountPk, client, lendrAccount);
 		client.logger.debug({ accountPk: _lendrAccountPk }, "[lendr:lendr-account] Loaded lendr account");
@@ -23942,7 +23998,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.
@@ -23958,7 +24015,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.
@@ -24605,6 +24663,12 @@ var LendrAccountWrapper = class LendrAccountWrapper {
 	async makePulseHealthIx(mandatoryBanks = [], excludedBanks = []) {
 		return this._lendrAccount.makePulseHealthIx(this._program, this.client.banks, mandatoryBanks, excludedBanks, this.client.bankMetadataMap || {});
 	}
+	static async fetchAccountData(accountAddress, config, program, commitment) {
+		const mergedCommitment = commitment ?? program.provider.connection.commitment ?? DEFAULT_COMMITMENT;
+		const data = await program.account.lendrAccount.fetch(accountAddress, mergedCommitment);
+		if (!data.group.equals(config.groupPk)) throw Error(`Lendr account tied to group ${data.group.toBase58()}. Expected: ${config.groupPk.toBase58()}`);
+		return data;
+	}
 	static async encode(decoded, idl) {
 		const coder = new BorshCoder(idl);
 		return await coder.accounts.encode(AccountType.LendrAccount, decoded);
@@ -24778,6 +24842,7 @@ var LendrGroup = class LendrGroup {
 
 //#endregion
 //#region src/clients/client.ts
+init_constants();
 /**
 * Entrypoint to interact with the lendr contract.
 */
@@ -24909,6 +24974,22 @@ var LendrClient = class LendrClient {
 		});
 	}
 	/**
+	* Fetches address lookup tables from the provided addresses
+	* @param connection The Solana connection
+	* @param addressLookupTableAddresses Optional array of address lookup table addresses to fetch
+	* @param logger Optional logger
+	* @returns Array of address lookup table accounts
+	*/
+	static async fetchAddressLookupTables(connection, addressLookupTableAddresses, logger = new NoopLogger()) {
+		if (!addressLookupTableAddresses || addressLookupTableAddresses.length === 0) {
+			logger.debug({}, "[lendr:client] No address lookup table addresses provided");
+			return [];
+		}
+		logger.debug({ for: addressLookupTableAddresses }, "[lendr:client] Fetching address lookup tables");
+		const addressLookupTables = (await Promise.all(addressLookupTableAddresses.map((address$2) => connection.getAddressLookupTable(address$2)))).map((response) => response?.value).filter((table) => table !== null);
+		return addressLookupTables;
+	}
+	/**
 	* Fetches all data for a group, including banks and oracle prices
 	* NOTE: If bankAddresses not provided, this will make 2 RPC calls
 	* @param connection
@@ -25280,21 +25361,12 @@ var LendrClient = class LendrClient {
 	}
 	async makeCreateLendrAccountWithSessionIx(session, accountIndex, thirdPartyId) {
 		this.logger.debug({ for: session.walletPublicKey.toBase58() }, "Generating lendr account init with session ix");
-		const PAYMASTER_DESTINATION = new PublicKey("43TSuDshgvKXuQCmDwHXmF4s3hH3nmDNJsvWGhoNnb7v");
-		const userTokenAtaPk = getAssociatedTokenAddressSync(NATIVE_MINT, session.walletPublicKey, true);
-		const transferIx = createTransferInstruction(userTokenAtaPk, PAYMASTER_DESTINATION, session.walletPublicKey, 1e4, [], TOKEN_PROGRAM_ID);
-		this.logger.debug({
-			transferFrom: userTokenAtaPk.toBase58(),
-			transferTo: PAYMASTER_DESTINATION.toBase58(),
-			amount: 1e4,
-			programId: TOKEN_PROGRAM_ID.toBase58()
-		}, "Adding paymaster transfer instruction to initialize tx");
 		const initLendrAccountIx = await instructions_default.makeInitLendrAccountWithSessionIx(this.program, {
 			lendrGroup: this.groupAddress,
 			session,
 			feePayer: session.payer
 		}, accountIndex, thirdPartyId);
-		const ixs = [transferIx, initLendrAccountIx];
+		const ixs = [initLendrAccountIx];
 		this.logger.debug({
 			numInstructions: ixs.length,
 			instructions: ixs.map((ix, i) => ({
@@ -25339,11 +25411,13 @@ var LendrClient = class LendrClient {
 		const tx = await this.createLendrAccountWithSessionTx(session, accountIndex, thirdPartyId);
 		const txResult = await session.sendTransaction(tx);
 		this.logger.debug({ txResult }, "Created Lendr account (using session)");
+		const thirdPartyIdValue = thirdPartyId ?? 0;
 		const [accountPublicKey] = PublicKey.findProgramAddressSync([
-			Buffer.from("pyroners"),
-			session.walletPublicKey.toBuffer(),
+			Buffer.from("lendr_account"),
 			this.groupAddress.toBuffer(),
-			new BN$1(accountIndex).toArrayLike(Buffer, "le", 8)
+			session.walletPublicKey.toBuffer(),
+			Buffer.from(new Uint16Array([accountIndex]).buffer),
+			Buffer.from(new Uint16Array([thirdPartyIdValue]).buffer)
 		], this.programId);
 		try {
 			return {
@@ -25680,6 +25754,10 @@ var EmodeSettings = class EmodeSettings {
 	}
 };
 
+//#endregion
+//#region src/index.ts
+init_constants();
+
 //#endregion
 export { AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_CLUSTER, DEFAULT_COMMITMENT, DEFAULT_CONFIRM_OPTS, DEFAULT_ORACLE_MAX_AGE, DEFAULT_PROCESS_TX_OPTS, DEFAULT_PROCESS_TX_STRATEGY, DEFAULT_SEND_OPTS, DISABLED_FLAG, DUMMY_USDC_MINT, DataFetcher, DummyMetadataFetcher, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, FogoMetadataFetcher, GROUP_PK, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, JUPITER_V6_PROGRAM, LENDR_IDL, LENDR_PROGRAM, LENDR_SPONSORED_SHARD_ID, LST_MINT, LUT_PROGRAM_AUTHORITY_INDEX, LendrAccount, LendrAccountWrapper, client_default as LendrClient, LendrGroup, LendrRequirementType, MAX_ACCOUNT_KEYS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MetadataService, MetaplexMetadataFetcher, OperationalState, OracleSetup, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PRIORITY_TX_SIZE, PROGRAM_ID, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, ProcessTransactionError, ProcessTransactionErrorType, RiskTier, SINGLE_POOL_PROGRAM_ID, SKIP_SIMULATION, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, TRANSFER_ACCOUNT_AUTHORITY_FLAG, USDC_DECIMALS, USDC_MINT, WSOL_EXTENDED_METADATA, WSOL_MINT, accountFlagToBN, addOracleToBanksIx, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankRawToDto, buildFeedIdMap, computeAccountValue, computeActiveEmodePairs, computeAssetUsdValue, computeBalanceUsdValue, computeBaseInterestRate, computeClaimedEmissions, computeEmodeImpacts, computeFreeCollateral, computeFreeCollateralLegacy, computeHealthAccountMetas, computeHealthCheckAccounts, computeHealthComponents, computeHealthComponentsLegacy, computeHealthComponentsWithoutBiasLegacy, computeInterestRates, computeLiabilityUsdValue, computeLoopingParams, computeMaxLeverage, computeNetApy, computeQuantity, computeQuantityUi, computeRemainingCapacity, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, confirmTransaction, crankPythOracleIx, createLendrAccountTx, createUpdateFeedIx, decodeAccountRaw, decodeBankRaw, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToLendrAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, feedIdToString, fetchLendrAccountAddresses, fetchLendrAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchPythOracleData, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleData, findOracleKey, findPythPushOracleAddress, freezeBankConfigIx, getActiveAccountFlags, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getActiveStaleBanks, getAssetQuantity, getAssetShares, getAssetWeight, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getConfig, getConfigPda, getHealthCacheStatusDescription, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getPrice, getPriceFeedAccountForProgram, getPriceWithConfidence, getTotalAssetQuantity, getTotalLiabilityQuantity, getTreasuryPda, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, instructions_default as instructions, isOracleSetupSupported, isWeightedPrice, lendrAccountToDto, makeAddPermissionlessStakedBankIx, makeBundleTipIx, makePoolAddBankIx, makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx, makeTxPriorityIx, makeUnwrapSolIx, makeVersionedTransaction, makeWrapSolIxs, metadataSchema, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseErrorFromLogs, parseLendrAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseTransactionError, processTransactions, serializeBankConfigOpt, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateTransactions, toBankConfigDto, toBankDto, toEmodeSettingsDto, toInterestRateConfigDto, validatorStakeGroupToDto, vendor_exports as vendor };
 //# sourceMappingURL=index.js.map