@pyron-finance/pyron-client 2.0.1 → 2.2.0

package/dist/index.cjs

@@ -1,12 +1,12 @@
-const require_common = require('./common-D8PG-Y0L.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"));
 const bignumber_js = require_common.__toESM(require("bignumber.js"));
-const bn_js = require_common.__toESM(require("bn.js"));
 const bs58 = require_common.__toESM(require("bs58"));
 const unstorage = require_common.__toESM(require("unstorage"));
 const zod_v4_mini = require_common.__toESM(require("zod/v4-mini"));
+const bn_js = require_common.__toESM(require("bn.js"));
 const __metaplex_foundation_mpl_token_metadata = require_common.__toESM(require("@metaplex-foundation/mpl-token-metadata"));
 const __metaplex_foundation_umi = require_common.__toESM(require("@metaplex-foundation/umi"));
 const __metaplex_foundation_umi_bundle_defaults = require_common.__toESM(require("@metaplex-foundation/umi-bundle-defaults"));
@@ -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";
@@ -10103,8 +10105,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] = __solana_web3_js.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();
@@ -10476,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);
@@ -11141,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,
+				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: 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
@@ -15986,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;
@@ -18720,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;
 }
@@ -19687,6 +19724,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);
@@ -20058,6 +20096,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,
@@ -20654,6 +20693,7 @@ function addTransactionTxTags(transactions) {
 
 //#endregion
 //#region src/services/account/utils/compute.utils.ts
+init_single_spl_pool();
 /**
 * Lendr Account Computes
 * =========================
@@ -21605,6 +21645,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 {
@@ -21738,6 +21780,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
 *
@@ -22533,7 +22577,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
 		})));
@@ -22545,9 +22589,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 __solana_web3_js.PublicKey("43TSuDshgvKXuQCmDwHXmF4s3hH3nmDNJsvWGhoNnb7v");
-		const transferIx = (0, __solana_spl_token.createTransferInstruction)(userTokenAtaPk, PAYMASTER_DESTINATION, this.authority, 1e4, [], __solana_spl_token.TOKEN_PROGRAM_ID);
-		depositIxs.unshift(transferIx);
 		const accounts$2 = {
 			sessionKey,
 			lendrAccount: this.address,
@@ -22648,7 +22689,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());
@@ -22672,9 +22713,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,
@@ -22688,8 +22743,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,
@@ -22713,8 +22768,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
 		});
@@ -23032,6 +23087,7 @@ function isWeightedPrice(reqType) {
 
 //#endregion
 //#region src/models/account/wrapper.ts
+require_common.init_constants();
 var LendrAccountWrapper = class LendrAccountWrapper {
 	address;
 	_lendrAccount;
@@ -23046,7 +23102,7 @@ var LendrAccountWrapper = class LendrAccountWrapper {
 	static async fetch(lendrAccountPk, client, commitment) {
 		const { config, program } = client;
 		const _lendrAccountPk = (0, __coral_xyz_anchor.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");
@@ -23939,7 +23995,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.
@@ -23955,7 +24012,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.
@@ -24602,6 +24660,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 ?? require_common.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 __coral_xyz_anchor.BorshCoder(idl);
 		return await coder.accounts.encode(AccountType.LendrAccount, decoded);
@@ -24775,6 +24839,7 @@ var LendrGroup = class LendrGroup {
 
 //#endregion
 //#region src/clients/client.ts
+require_common.init_constants();
 /**
 * Entrypoint to interact with the lendr contract.
 */
@@ -24906,6 +24971,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
@@ -25277,21 +25358,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 __solana_web3_js.PublicKey("43TSuDshgvKXuQCmDwHXmF4s3hH3nmDNJsvWGhoNnb7v");
-		const userTokenAtaPk = (0, __solana_spl_token.getAssociatedTokenAddressSync)(__solana_spl_token.NATIVE_MINT, session.walletPublicKey, true);
-		const transferIx = (0, __solana_spl_token.createTransferInstruction)(userTokenAtaPk, PAYMASTER_DESTINATION, session.walletPublicKey, 1e4, [], __solana_spl_token.TOKEN_PROGRAM_ID);
-		this.logger.debug({
-			transferFrom: userTokenAtaPk.toBase58(),
-			transferTo: PAYMASTER_DESTINATION.toBase58(),
-			amount: 1e4,
-			programId: __solana_spl_token.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) => ({
@@ -25336,11 +25408,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] = __solana_web3_js.PublicKey.findProgramAddressSync([
-			Buffer.from("pyroners"),
-			session.walletPublicKey.toBuffer(),
+			Buffer.from("lendr_account"),
 			this.groupAddress.toBuffer(),
-			new bn_js.default(accountIndex).toArrayLike(Buffer, "le", 8)
+			session.walletPublicKey.toBuffer(),
+			Buffer.from(new Uint16Array([accountIndex]).buffer),
+			Buffer.from(new Uint16Array([thirdPartyIdValue]).buffer)
 		], this.programId);
 		try {
 			return {
@@ -25677,6 +25751,10 @@ var EmodeSettings = class EmodeSettings {
 	}
 };
 
+//#endregion
+//#region src/index.ts
+init_constants();
+
 //#endregion
 exports.AccountFlags = AccountFlags;
 exports.AccountType = AccountType;