@0dotxyz/p0-ts-sdk 2.1.0 → 2.2.0-alpha.0

package/dist/index.cjs

@@ -15162,9 +15162,48 @@ var MintLayout = bufferLayout.struct([
   bufferLayoutUtils.publicKey("freezeAuthority")
 ]);
 MintLayout.span;
+var approveInstructionData = bufferLayout.struct([
+  bufferLayout.u8("instruction"),
+  bufferLayoutUtils.u64("amount")
+]);
+function createApproveInstruction(account, delegate, owner, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
+  const keys = addSigners(
+    [
+      { pubkey: account, isSigner: false, isWritable: true },
+      { pubkey: delegate, isSigner: false, isWritable: false }
+    ],
+    owner,
+    multiSigners
+  );
+  const data = buffer.Buffer.alloc(approveInstructionData.span);
+  approveInstructionData.encode(
+    {
+      instruction: 4 /* Approve */,
+      amount: BigInt(amount)
+    },
+    data
+  );
+  return new web3_js.TransactionInstruction({ keys, programId, data });
+}
 bufferLayout.struct([
   bufferLayout.u8("instruction")
 ]);
+function createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+  const keys = [
+    { pubkey: payer, isSigner: true, isWritable: true },
+    { pubkey: associatedToken, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: web3_js.SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: programId, isSigner: false, isWritable: false },
+    { pubkey: web3_js.SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }
+  ];
+  return new web3_js.TransactionInstruction({
+    keys,
+    programId: associatedTokenProgramId,
+    data: buffer.Buffer.alloc(0)
+  });
+}
 function createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
   return buildAssociatedTokenAccountInstruction(
     payer,
@@ -43379,6 +43418,169 @@ new Fraction(new BN11__default.default(0));
 function roundNearest(decimal) {
   return decimal.toDecimalPlaces(0, Decimal3__default.default.ROUND_HALF_CEIL);
 }
+var 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: web3_js.STAKE_CONFIG_ID, 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([0 /* 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([6 /* 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([2 /* 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([3 /* WithdrawStake */]),
+      userStakeAuthority.toBuffer(),
+      Buffer.from(new BN11.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([4 /* 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([5 /* 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
+    );
+  }
+};
+var createTransactionInstruction = (programId, keys, data) => {
+  return {
+    programId,
+    keys,
+    data
+  };
+};
 var findPda = (baseAddress, prefix, programId = SINGLE_POOL_PROGRAM_ID) => {
   const [pda] = web3_js.PublicKey.findProgramAddressSync(
     [Buffer.from(prefix), baseAddress.toBuffer()],
@@ -43389,7 +43591,17 @@ var findPda = (baseAddress, prefix, programId = SINGLE_POOL_PROGRAM_ID) => {
 var findPoolAddress = (voteAccountAddress) => findPda(voteAccountAddress, "pool");
 var findPoolMintAddress = (poolAddress) => findPda(poolAddress, "mint");
 var findPoolStakeAddress = (poolAddress) => findPda(poolAddress, "stake");
+var findPoolStakeAuthorityAddress = (poolAddress) => findPda(poolAddress, "stake_authority");
+var findPoolMintAuthorityAddress = (poolAddress) => findPda(poolAddress, "mint_authority");
+var findPoolMplAuthorityAddress = (poolAddress) => findPda(poolAddress, "mpl_authority");
 var findPoolOnRampAddress = (poolAddress) => findPda(poolAddress, "onramp");
+var findMplMetadataAddress = async (poolMintAddress) => {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("metadata"), MPL_METADATA_PROGRAM_ID.toBuffer(), poolMintAddress.toBuffer()],
+    MPL_METADATA_PROGRAM_ID
+  );
+  return pda;
+};
 BigInt(33);
 BigInt(200);
 BigInt(82);
@@ -48025,6 +48237,179 @@ async function buildSwapDebtFlashloanTx({
   }
   throw new Error("Failed to build swap debt flashloan tx");
 }
+var SYSVAR_CLOCK_ID2 = new web3_js.PublicKey("SysvarC1ock11111111111111111111111111111111");
+async function makeMintStakedLstIx(params) {
+  const { amount, authority, stakeAccountPk, validator, connection } = params;
+  const pool = findPoolAddress(validator);
+  const lstMint = findPoolMintAddress(pool);
+  const poolStakeAuth = findPoolStakeAuthorityAddress(pool);
+  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
+  const [lstAccInfo, stakeAccInfoParsed, rentExemptReserve] = await Promise.all([
+    connection.getAccountInfo(lstAta),
+    connection.getParsedAccountInfo(stakeAccountPk),
+    connection.getMinimumBalanceForRentExemption(web3_js.StakeProgram.space)
+  ]);
+  const stakeAccParsed = stakeAccInfoParsed?.value?.data;
+  const amountLamports = Math.round(Number(amount) * web3_js.LAMPORTS_PER_SOL);
+  const stakeAccLamports = Number(stakeAccParsed?.parsed?.info?.stake?.delegation?.stake ?? 0);
+  const isFullStake = amountLamports >= stakeAccLamports;
+  const instructions2 = [];
+  const signers = [];
+  if (!lstAccInfo) {
+    instructions2.push(
+      createAssociatedTokenAccountInstruction(authority, lstAta, authority, lstMint)
+    );
+  }
+  let targetStakePubkey;
+  if (!isFullStake) {
+    const splitStakeAccount = web3_js.Keypair.generate();
+    signers.push(splitStakeAccount);
+    targetStakePubkey = splitStakeAccount.publicKey;
+    instructions2.push(
+      ...web3_js.StakeProgram.split(
+        {
+          stakePubkey: stakeAccountPk,
+          authorizedPubkey: authority,
+          splitStakePubkey: splitStakeAccount.publicKey,
+          lamports: amountLamports
+        },
+        rentExemptReserve
+      ).instructions
+    );
+  } else {
+    targetStakePubkey = stakeAccountPk;
+  }
+  const [authorizeStakerIx, authorizeWithdrawIx] = await Promise.all([
+    web3_js.StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: web3_js.StakeAuthorizationLayout.Staker
+    }).instructions,
+    web3_js.StakeProgram.authorize({
+      stakePubkey: targetStakePubkey,
+      authorizedPubkey: authority,
+      newAuthorizedPubkey: poolStakeAuth,
+      stakeAuthorizationType: web3_js.StakeAuthorizationLayout.Withdrawer
+    }).instructions
+  ]);
+  [authorizeStakerIx[0], authorizeWithdrawIx[0]].forEach((ix) => {
+    if (ix) {
+      ix.keys = ix.keys.map((key) => ({
+        ...key,
+        isWritable: key.pubkey.equals(SYSVAR_CLOCK_ID2) ? false : key.isWritable
+      }));
+    }
+  });
+  instructions2.push(...authorizeStakerIx, ...authorizeWithdrawIx);
+  const depositStakeIx = await SinglePoolInstruction.depositStake(
+    pool,
+    targetStakePubkey,
+    lstAta,
+    authority
+  );
+  instructions2.push(depositStakeIx);
+  return { instructions: instructions2, keys: signers };
+}
+async function makeMintStakedLstTx(params) {
+  const { connection, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeMintStakedLstIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new web3_js.VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "DEPOSIT_STAKE" /* DEPOSIT_STAKE */
+  });
+}
+async function makeRedeemStakedLstIx(params) {
+  const { amount, authority, validator, connection } = params;
+  const pool = findPoolAddress(validator);
+  const lstMint = findPoolMintAddress(pool);
+  const mintAuthority = findPoolMintAuthorityAddress(pool);
+  const lstAta = getAssociatedTokenAddressSync(lstMint, authority);
+  const rentExemption = await connection.getMinimumBalanceForRentExemption(
+    web3_js.StakeProgram.space
+  );
+  const stakeAmount = new BigNumber3__default.default(new BigNumber3__default.default(amount).toString());
+  const instructions2 = [];
+  const signers = [];
+  const stakeAccount = web3_js.Keypair.generate();
+  signers.push(stakeAccount);
+  instructions2.push(
+    web3_js.SystemProgram.createAccount({
+      fromPubkey: authority,
+      newAccountPubkey: stakeAccount.publicKey,
+      lamports: rentExemption,
+      space: web3_js.StakeProgram.space,
+      programId: web3_js.StakeProgram.programId
+    })
+  );
+  instructions2.push(
+    createApproveInstruction(
+      lstAta,
+      mintAuthority,
+      authority,
+      BigInt(stakeAmount.multipliedBy(1e9).toFixed(0))
+    )
+  );
+  const withdrawStakeIx = await SinglePoolInstruction.withdrawStake(
+    pool,
+    stakeAccount.publicKey,
+    authority,
+    lstAta,
+    stakeAmount
+  );
+  instructions2.push(withdrawStakeIx);
+  return { instructions: instructions2, keys: signers };
+}
+async function makeRedeemStakedLstTx(params) {
+  const { connection, luts, blockhash: providedBlockhash } = params;
+  const { instructions: instructions2, keys } = await makeRedeemStakedLstIx(params);
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: params.authority,
+    recentBlockhash: blockhash,
+    instructions: instructions2
+  }).compileToV0Message(luts);
+  const tx = new web3_js.VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    signers: keys,
+    addressLookupTables: luts,
+    type: "WITHDRAW_STAKE" /* WITHDRAW_STAKE */
+  });
+}
+async function makeMergeStakeAccountsTx(params) {
+  const {
+    authority,
+    sourceStakeAccount,
+    destinationStakeAccount,
+    connection,
+    luts,
+    blockhash: providedBlockhash
+  } = params;
+  const mergeIx = web3_js.StakeProgram.merge({
+    stakePubkey: destinationStakeAccount,
+    sourceStakePubKey: sourceStakeAccount,
+    authorizedPubkey: authority
+  }).instructions;
+  const blockhash = providedBlockhash ?? (await connection.getLatestBlockhash("confirmed")).blockhash;
+  const message = new web3_js.TransactionMessage({
+    payerKey: authority,
+    recentBlockhash: blockhash,
+    instructions: mergeIx
+  }).compileToV0Message(luts);
+  const tx = new web3_js.VersionedTransaction(message);
+  return addTransactionMetadata(tx, {
+    addressLookupTables: luts,
+    type: "MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */
+  });
+}
 
 // src/services/account/services/account-simulation.service.ts
 async function simulateAccountHealthCacheWithFallback(params) {
@@ -49075,7 +49460,12 @@ async function makeUpdateSwbFeedIx(props) {
     seen.add(key);
     return true;
   });
-  const swbProgram = await onDemand.AnchorUtils.loadProgramFromConnection(props.connection);
+  const dummyWallet = {
+    publicKey: props.feePayer,
+    signTransaction: async (tx) => tx,
+    signAllTransactions: async (txs) => txs
+  };
+  const swbProgram = await onDemand.AnchorUtils.loadProgramFromConnection(props.connection, dummyWallet);
   const pullFeedInstances = uniqueOracles.map((oracle) => {
     const pullFeed = new onDemand.PullFeed(swbProgram, oracle.key);
     return pullFeed;
@@ -49086,21 +49476,11 @@ async function makeUpdateSwbFeedIx(props) {
   const crossbarClient = new common.CrossbarClient(
     process.env.NEXT_PUBLIC_SWITCHBOARD_CROSSSBAR_API || "https://integrator-crossbar.prod.mrgn.app"
   );
-  const gatewayUrls = await crossbarClient.fetchGateways("mainnet");
-  if (!gatewayUrls || gatewayUrls.length === 0) {
-    throw new Error(`No gateways available for mainnet`);
-  }
-  const gatewayUrl = gatewayUrls[0];
-  if (!gatewayUrl) {
-    throw new Error(`Invalid gateway URL received formainnet`);
-  }
-  const gateway = new onDemand.Gateway(swbProgram, gatewayUrl);
   const [pullIx, luts] = await onDemand.PullFeed.fetchUpdateManyIx(swbProgram, {
     feeds: pullFeedInstances,
-    gateway: gateway.gatewayUrl,
     numSignatures: 1,
-    payer: props.feePayer,
-    crossbarClient
+    crossbarClient,
+    payer: props.feePayer
   });
   return { instructions: pullIx, luts };
 }
@@ -49440,18 +49820,15 @@ var fetchPythOracleData = async (banks, opts) => {
       bankOraclePriceMap: /* @__PURE__ */ new Map()
     };
   }
-  pythStakedCollateralBanks.map((bank) => [
-    opts.validatorVoteAccountByBank?.[bank.address.toBase58()] ?? "",
-    bank.mint.toBase58()
-  ]);
-  const priceCoeffByBank = {};
   const combinedPythBanks = [
     ...pythPushBanks,
+    ...pythStakedCollateralBanks,
     ...pythPushKaminosBanks,
     ...driftPythPullBanks,
     ...solendPythPullBanks,
     ...juplendPythPullBanks
   ];
+  const priceCoeffByBank = {};
   const pythOracleKeys = extractPythOracleKeys(combinedPythBanks);
   const uniquePythOracleKeys = Array.from(new Set(pythOracleKeys));
   let oraclePrices;
@@ -50656,6 +51033,389 @@ function dtoToValidatorStakeGroup(validatorStakeGroupDto) {
     }))
   };
 }
+
+// src/services/native-stake/utils/metadata.data.ts
+var STAKED_BANK_METADATA_JSON = [
+  {
+    bankAddress: "8g5qG6PVygcVSXV1cJnjXaD1yhrDwcWAMQCY2wR9VuAf",
+    validatorVoteAccount: "CooLbbZy5Xmdt7DiHPQ3ss2uRXawnTXXVgpMS8E8jDzr",
+    tokenAddress: "BADo3D6nMtGnsAaTv3iEes8mMcq92TuFoBWebFe8kzeA",
+    tokenName: "Cavey Cool",
+    tokenSymbol: "COOL"
+  },
+  {
+    bankAddress: "BuCckNm1djpp3vZVhvh1CrrniirY6sr2hwUmeP5kTcGz",
+    validatorVoteAccount: "mrgn4t2JabSgvGnrCaHXMvz8ocr4F52scsxJnkQMQsQ",
+    tokenAddress: "FUyAyVbYrMfiaN1QEQYFZTuBNzW5EJf3jWzjjymGqKLv",
+    tokenName: "Project 0 Meridian",
+    tokenSymbol: "MERIDIAN"
+  },
+  {
+    bankAddress: "Hco1P3dGRXz3ZGFvMkbDgghZQy47Tp7vp7koSYRvP6nm",
+    validatorVoteAccount: "mrgn6ETrBDM8mjjYN8rbVwFqVwF8z6rtmvGLbdGuVUU",
+    tokenAddress: "A4B5MGQvcZCUqeiUEAB4ckZ2tvH2UmEg31vF7TiERDkH",
+    tokenName: "MRGN 3",
+    tokenSymbol: "MRGN3"
+  },
+  {
+    bankAddress: "EPh2abWP8DusPH8myWnECAAeQUZgAz927aMbmwXt3eRY",
+    validatorVoteAccount: "mrgn2vsZ5EJ8YEfAMNPXmRux7th9cNfBasQ1JJvVwPn",
+    tokenAddress: "6Mt7tBWLUJfDxqCFTsjoRXF9wD55g4Lhs5nAyYp244pX",
+    tokenName: "Project 0 Horizon",
+    tokenSymbol: "HORIZON"
+  },
+  {
+    bankAddress: "6wjAwhnxTMEzHk8NNHVXgkx1jSrb6TX1bC17j3S56FfB",
+    validatorVoteAccount: "3N7s9zXMZ4QqvHQR15t5GNHyqc89KduzMP7423eWiD5g",
+    tokenAddress: "DKPvRV4dxUejjGpr2XwFmzZbbbTD7vx9Jmt1kk43n4d5",
+    tokenName: "Binance",
+    tokenSymbol: "BINANCE"
+  },
+  {
+    bankAddress: "J9tksvZEDSwtNtZ6yxYjWDDkzhPbwDMnihU61NkFG9FE",
+    validatorVoteAccount: "he1iusunGwqrNtafDtLdhsUQDFvo13z9sUa36PauBtk",
+    tokenAddress: "2k79y8CApbU9jAvWhLS2j6uRbaVjpLJTUzstBTho9vGq",
+    tokenName: "Helius",
+    tokenSymbol: "HELIUS"
+  },
+  {
+    bankAddress: "Dfr6Sf44ftecaJaoJMzFQABdkt3CEHfBwut1WyacRzaE",
+    validatorVoteAccount: "SLaYv7tCwetrFGbPCRnqpHswG5qqKino78EYpbGF7xY",
+    tokenAddress: "Vsw4JT33S7bLbhjySMMyrP3JKvTAcNi9WG5Doekrmgg",
+    tokenName: "Solayer",
+    tokenSymbol: "SOLAYER"
+  },
+  {
+    bankAddress: "BZAm4qGscR8gg5bmWrEq6BTofgaZPbg7Fwfa7rFghEXL",
+    validatorVoteAccount: "J1to3PQfXidUUhprQWgdKkQAMWPJAEqSJ7amkBDE9qhF",
+    tokenAddress: "6B8hZSupE5mcACmjzozP6C1DR2uaCCtmrGqcYWC6SBCc",
+    tokenName: "Bonk",
+    tokenSymbol: "BONK"
+  },
+  {
+    bankAddress: "3UrMZ26NRKu2y6c2dPE7gZVHwEmhpwKLcWACg3tjCVEt",
+    validatorVoteAccount: "J2nUHEAgZFRyuJbFjdqPrAa9gyWDuc7hErtDQHPhsYRp",
+    tokenAddress: "9M7oMo4oL6RDPG7WbAX3Zz4dPzbMgpiCzwrQPMwG4Wgq",
+    tokenName: "Phantom",
+    tokenSymbol: "PHANTOM"
+  },
+  {
+    bankAddress: "8c269gkonvATm93nviuYiriCQ829f7ypx3aScYDR1YoQ",
+    validatorVoteAccount: "D3QPJm7BDzzPeRG51YZSEz3LfV7GvFNu9NkcibzURxuj",
+    tokenAddress: "8hXCCQmYFcDhU5Mkuvyixp2Q11sbyQComkceSSh3GY4a",
+    tokenName: "Starke Finance",
+    tokenSymbol: "STARKE"
+  },
+  {
+    bankAddress: "37tiA2NTF6YCt85XzCidPo9ZVpuqkkmfVJCYQ5Yx5Uhs",
+    validatorVoteAccount: "SBLZib4npE7svxFA7AsD3ytdQAfYNb39c8zsU82AA2E",
+    tokenAddress: "96rXgCFy1Er49169XoKHkeLiKC2k4bTy1641q1TVrMm2",
+    tokenName: "SolBlaze Validator",
+    tokenSymbol: "SOLBLAZE"
+  },
+  {
+    bankAddress: "J9trpcrVdFjVNg6VFrdF1XPGgjftQKZhbbWsxertdv9V",
+    validatorVoteAccount: "FACqsS19VScz8oo2YhdMg35EsAy6xsCZ9Y58eJXGv8QJ",
+    tokenAddress: "AH6fxpHS2gtMtJgBy8y8pEAPkqyop2pSugF6REs9NaTp",
+    tokenName: "Lantern",
+    tokenSymbol: "LNTRN"
+  },
+  {
+    bankAddress: "EGTfrYiuWpPPZ4yfY9tCxnK6QMkY7pzVie9DxK772iGe",
+    validatorVoteAccount: "EfnywDKqArxK6N6FS9ctsuzNdxfx3pzfXEQE5EevQ1SV",
+    tokenAddress: "FcXEwHku68ZquqtSj1eSWS1SVWkhAZSyb4usfpiuEJAL",
+    tokenName: "PROJECT SUPER",
+    tokenSymbol: "SUPER"
+  },
+  {
+    bankAddress: "A5e7UTE3g11ZfKgftqRCvxAgcDuFGyeDjMka96zJWSWe",
+    validatorVoteAccount: "3ZUQekqiZoybB57y49eqtvSaoonqDwuNbeqEGwN88JkQ",
+    tokenAddress: "F1XPjtpsEy23Q7po4JkWjp1jkDZcvFYSrqD8TR1YL3EF",
+    tokenName: "Paws",
+    tokenSymbol: "PAWS"
+  },
+  {
+    bankAddress: "91jkdp4cF8vCDhjwude3SGSGrmVWFk5vTAtR6fsGVAfy",
+    validatorVoteAccount: "gangtRyGPTvYWb8K3xS2feJQaCks4iJ7rytFUPtVqSY",
+    tokenAddress: "6ZS7ZVDw91BVAC8gsz3SZBSeVeF2GtXtL2BHK31Kvyjm",
+    tokenName: "Lotus Validator",
+    tokenSymbol: "LOTUS"
+  },
+  {
+    bankAddress: "72BS34HkCgq8RWQR7kuVVmiJMtKqSxG4CHX6ZXpSCwg7",
+    validatorVoteAccount: "oRAnGeU5h8h2UkvbfnE5cjXnnAa4rBoaxmS4kbFymSe",
+    tokenAddress: "9yF8pXctzicum2P73uuk4Dhqf2MVz6tzRAe8THGXCJcp",
+    tokenName: "Orangefin Ventures",
+    tokenSymbol: "ORANGEFIN"
+  },
+  {
+    bankAddress: "8F4DsU3NMFunUxBZkWrpYR8zwhAfoAt7QuiEPMtyhWvX",
+    validatorVoteAccount: "3xjfK9C9YNcta8MvK1US4sQ3bc6DEjoJoR3qLExGf9xE",
+    tokenAddress: "Akib1NYJzzh9HkiDH41S2LUefUmR1bKsk65xgqUcW5C5",
+    tokenName: "pico\u{1F644}.sol",
+    tokenSymbol: "PICO"
+  },
+  {
+    bankAddress: "GdtggomQth6cxuYPdiVhBbcX7VC9rnDDwLMfxipxE2Po",
+    validatorVoteAccount: "oPaLTmyvoUhW26QCMwLA5JNUeBYy72PDpFoXQF8SeX4",
+    tokenAddress: "C71A3W7g5XALUNwTDWTwHX3qhfypaYZ41aNZjBpcaC9D",
+    tokenName: "Temporal Opal",
+    tokenSymbol: "OPAL"
+  },
+  {
+    bankAddress: "5sJCKePwAhyD3mzrzLRDM2PkFMc85nnvvarxHLsvWvpg",
+    validatorVoteAccount: "9jYFwBfbjYmvasFbJyES9apLJDTkwtbgSDRWanHEvcRw",
+    tokenAddress: "Hj69K1WbnfZFipLbrzdxgGhDqCR47q48bN5nUHt6xQZo",
+    tokenName: "WATCHTOWER",
+    tokenSymbol: "WATCHTOWER"
+  },
+  {
+    bankAddress: "3F3QXT3BtkegaBfFjn2odKLurFYLHJHJ99xKV2TRTvrk",
+    validatorVoteAccount: "6JfBwvcz5QUKQJ37BMKTLrf968DDJBtwoZLw19aHwFtQ",
+    tokenAddress: "8FqX86cQofBHReetZgxrxxvzN4iqMVsj2hbiv7pj2h73",
+    tokenName: "Spectrum Staking",
+    tokenSymbol: "SPECTRUM"
+  },
+  {
+    bankAddress: "CFmvdtEPQJPVqS1QRkeRcdQm2itAPk6k8hSJbmt88Sjc",
+    validatorVoteAccount: "Haz7b47sZBpxh9SwggGndN3fAyNQ1S949BPdxWXS3ab6",
+    tokenAddress: "38ZUTefZnKSUJU3wxpUe3xpiw2j5WQPnmzSTNbS1JqLA",
+    tokenName: "Temporal Emerald",
+    tokenSymbol: "EMERALD"
+  },
+  {
+    bankAddress: "CmBDHSVuodmUnanbBVFvY9cauLeosbdFQn9bJANMVYUG",
+    validatorVoteAccount: "mintrNtxN3PhAB45Pt41XqyKghTTpqcoBkQTZqh96iR",
+    tokenAddress: "GxGmv7s7s2co3pLZukns946fr5zmR8c5buWRD9prGd6v",
+    tokenName: "Hanabi Staking",
+    tokenSymbol: "haSOLmrgn"
+  },
+  {
+    bankAddress: "7bLfrb4fWVYkVpZ9rg7dBUwKRAqLyiivCW4ahMMGcKyS",
+    validatorVoteAccount: "76DafWkJ6pGK2hoD41HjrM4xTBhfKqrDYDazv13n5ir1",
+    tokenAddress: "GT7n9uZbYzHv52YqDBowtZ5ZVW91umaBQTNPFQNeLUpR",
+    tokenName: "Solana Japan Validator",
+    tokenSymbol: "SolJAPAn"
+  },
+  {
+    bankAddress: "6q5DB86DhCBQt5bqzZwgopV8EA96aCnngu5ebR1ooDFq",
+    validatorVoteAccount: "Cue647T8jgwpRSDUb8ttTYx7NiEfJCRZNiiw1qmchXsG",
+    tokenAddress: "EAR6LenhNstHxR9289rWakm82WgLJYvHD7NawfXtuyUx",
+    tokenName: "KIWAMI",
+    tokenSymbol: "KIWAMI"
+  },
+  {
+    bankAddress: "GLSCJ39N82Xo21621jMheinvjQLrBrkG7gzo2C5L1y6y",
+    validatorVoteAccount: "7emL18Bnve7wbYE9Az7vYJjikxN6YPU81igf6rVU5FN8",
+    tokenAddress: "EQuMUgLZArKwWUk6uGPmTGYUgNbfgJrbBaNR7CQyZ5uf",
+    tokenName: "Temporal Topaz",
+    tokenSymbol: "TOPAZ"
+  },
+  {
+    bankAddress: "4irzCCsU53ffh9XB7NxGzbbHjvSR7FTfPbn6KoXkt7kX",
+    validatorVoteAccount: "2iWXwF2Q5W6o7yntV2mkbxncB4rYHnX61y3NU8a8EFMJ",
+    tokenAddress: "14Pets6QpE9iXKkXg8Ri4GcDazRMfWR3guM6LZXnFChc",
+    tokenName: "Bull Moose SOL",
+    tokenSymbol: "bmsSOL"
+  },
+  {
+    bankAddress: "C96do7nkEaaFjHq8jHzPpyPTdJSea5xEGwxDzDSepCzf",
+    validatorVoteAccount: "voteRnv6PBzmiGP8NicWtQiqEJTwKKq2SxtqtdLUJjd",
+    tokenAddress: "3YEDiJ4r4xRGNhq6nudRnkwrdKHG7PAtDim24CjTMtBH",
+    tokenName: "diman",
+    tokenSymbol: "DIMAN"
+  },
+  {
+    bankAddress: "9dZiyG51FBR4BWpAs69XbDpr7GfVAEB1ZB89v38maV36",
+    validatorVoteAccount: "Simpj3KyRQmpRkXuBvCQFS7DBBG6vqw93SkZb9UD1hp",
+    tokenAddress: "77YLpVLQXr2KU66GM2JykbT9g5du7LarWgehbWD3CJaB",
+    tokenName: "SIMPDIGIT",
+    tokenSymbol: "SIMPDIGIT"
+  },
+  {
+    bankAddress: "2foqT8wWzWRduyV37uRdj81DijkNMKzYD3D6JPfir7La",
+    validatorVoteAccount: "48oxpSHQkM4sdXUY9NQ8KnEtebzZbyk8uUT7JRdVQNuf",
+    tokenAddress: "42m7Ygk5VxREdKfcFrsH1HnuoqCke8BcVcxNeywMCfp2",
+    tokenName: "Infinite Lux",
+    tokenSymbol: "LUX"
+  },
+  {
+    bankAddress: "FsdWEJzHXkUXejWnb7c1p9UJtF69hVWQNNoakjoXyRCJ",
+    validatorVoteAccount: "4AUED4uj6nSTuANzaAUnGBPJQRmhpDYDwoWJNkoUUBBW",
+    tokenAddress: "CiyQTfHJ9PbTwC7TGf4pXZk8szcWGJ8TeFhhCuUwybqi",
+    tokenName: "Anagram",
+    tokenSymbol: "ANAGRAM"
+  },
+  {
+    bankAddress: "2hs1pHAzDWGqnn1d8VQkc8bZRfQ45grYvzfau8dnWFUk",
+    validatorVoteAccount: "2NxEEbhqqj1Qptq5LXLbDTP5tLa9f7PqkU8zNgxbGU9P",
+    tokenAddress: "9yQLxEzusZ7QiZNafDNdzbEaTCPuJToGjMhLRJtZbgsd",
+    tokenName: "NANSEN",
+    tokenSymbol: "NANSEN"
+  },
+  {
+    bankAddress: "FCi8unSVCwJd3QkrhTtv6LTTjw1c4zV65D5cG5N1rAG6",
+    validatorVoteAccount: "Va1idkzkB6LEmVFmxWbWU8Ao9qehC62Tjmf68L3uYKj",
+    tokenAddress: "AExKb8oJ6mGPYJUyfiX49DMMi226h2AnWeG1G6neQBEz",
+    tokenName: "VALIDATOR",
+    tokenSymbol: "VALID"
+  },
+  {
+    bankAddress: "HzS8RqaQ5syk6EHbVi7h9rFYN48PpxykUXEs6w9wNfNP",
+    validatorVoteAccount: "sTach38ebT8jnGH8i2D1g8NDAS6An19whVMnSSWPXt4",
+    tokenAddress: "AFDVYBqxADagPfN9DdbrNrf9zZqugub7CV4kUJEUrK6J",
+    tokenName: "Stache Node",
+    tokenSymbol: "STACHE"
+  },
+  {
+    bankAddress: "9Hs4E6ACNw6Hmwjvm1duXzbaWmvXxSxN11agw4updEn1",
+    validatorVoteAccount: "EtMSc3MvcDXUr6ChK5GxyFVwTxYA3zqP5XzjE9jwKvSV",
+    tokenAddress: "ENKFyZQZHzNNSxcKYoaVsNLi2xoGPoStZH4A9xxezjbC",
+    tokenName: "Mad Lads CN",
+    tokenSymbol: "MadLadsCN"
+  },
+  {
+    bankAddress: "4watsWcjTBAwsrZpArwQbnNX4bQ1yeHBxgdbrGT4eMu9",
+    validatorVoteAccount: "EARNynHRWg6GfyJCmrrizcZxARB3HVzcaasvNa8kBS72",
+    tokenAddress: "8fhkWcm2n28JuadzY7mRR8FFDZZfnaPfWgw7pLNVZCbE",
+    tokenName: "Solana Compass Stake",
+    tokenSymbol: "compaStake"
+  },
+  {
+    bankAddress: "9d7MTvcz1VMB1rK6H73quMxkR26dLPz5HDaac2eGRjQx",
+    validatorVoteAccount: "nymsndUdAZyUPpWYz5VEg8Ghj9cFvwTRgciLogpmYaQ",
+    tokenAddress: "FWFeaqpkgDr3ejVSY3HjiUmUg3u9fcr5d66HvimnDLWE",
+    tokenName: "Hypo Nyms",
+    tokenSymbol: "NYMS"
+  },
+  {
+    bankAddress: "6V4vCK3n3JVncfpS16mW8ceLoNPatvu61pKxFmWx8adi",
+    validatorVoteAccount: "BT8LZUvQVwFHRGw2Dwv7UeqDUq7btfjegLpuz5bwgziD",
+    tokenAddress: "9YRS7Stf9dVibTT1M4uVEAuRMcoS4MH1QxqXy9Lssrab",
+    tokenName: "private",
+    tokenSymbol: "private"
+  },
+  {
+    bankAddress: "CK8qRAcmvkDXaqX2S5GkgTCZT5pCz34me1neQhpJYe1Z",
+    validatorVoteAccount: "Ac1beBKixfNdrTAac7GRaTsJTxLyvgGvJjvy4qQfvyfc",
+    tokenAddress: "DLTAbTL5NXhbqX6LX3ie3tf52pdtGpxe2DrZUr1RhgY6",
+    tokenName: "Stronghold",
+    tokenSymbol: "Stronghold"
+  },
+  {
+    bankAddress: "H6CT1aiCgSNw9S6aq38npEhdoN2UPhSKe8Lj9fQqqjuu",
+    validatorVoteAccount: "FREEL1BCzmPpNneC7FHCtBqzeWYrHRbtisFvi4N8XUP9",
+    tokenAddress: "AKFuMoM5rjSpQSL4p6TBoc7D4dmEem9QrHhuSDCBYyZ8",
+    tokenName: "Ross",
+    tokenSymbol: "Ross"
+  },
+  {
+    bankAddress: "G46aHuakgStymbE2WsLbja61mH5UXBPdSdpwf6Ci3saG",
+    validatorVoteAccount: "mnvkHm47ZmRKoSWuQZAfXLRiDPiKCq8PWkMWrp1Wwqe",
+    tokenAddress: "Cq9S5UB9BviPn5yoGkEDk3m7neQag4KJnhPWGyuev9W8",
+    tokenName: "gripto staked sol",
+    tokenSymbol: "GRIPTO"
+  },
+  {
+    bankAddress: "75UmeEMdqVnGn3JHx8yVZEn7viybJ73XYSjhYCYfyhp2",
+    validatorVoteAccount: "4m1PbxzwLdUnEwog3T9UKxgjktgriHgE1CfAhMqDw7Xx",
+    tokenAddress: "432SogPNunjZMneDV6goZ8ZcCQz282GxoSJ4rwqx95pT",
+    tokenName: "kumasol",
+    tokenSymbol: "kumasol"
+  },
+  {
+    bankAddress: "3zk6EmXANYQK12bwy9dySRAM4cT2vT5cDcAB79j8G33B",
+    validatorVoteAccount: "HvsD9L5t62MGv3QBD2K7xjkipGYr9UZN7BtsW8NuSPpg",
+    tokenAddress: "5vmwd6JHDCmX9W2XT1n2QpvYGA2kk4Xf7qWSayDU6caT",
+    tokenName: "ArgenTerraSOL",
+    tokenSymbol: "atSOL"
+  },
+  {
+    bankAddress: "4C2vPweGNpiE6kTEbYvcbUBHNWxrn4ErQYaqWm5zDexx",
+    validatorVoteAccount: "FnAPJkzf19s87sm24Qhv6bHZMZvZ43gjNUBRgjwXpD4v",
+    tokenAddress: "6q4kVnwUpkE3i7W32dqaX6V12pbsrCnMqZ7TWz9yp1m5",
+    tokenName: "BLOCKPORT",
+    tokenSymbol: "BPT"
+  },
+  {
+    bankAddress: "E5hZu5QQ1pRmGvyS4JHGXVQwzdUPaYM4yEiNKr64YzyG",
+    validatorVoteAccount: "nfGcSJkP35SkPa5475iBChmq1UNcj7JE1uQHrrasymm",
+    tokenAddress: "AQpQoJ3tJKGH9Yn8GSzoUsVcHPJjj3xYfQFp9XVr74F6",
+    tokenName: "Test01",
+    tokenSymbol: "TEST01"
+  },
+  {
+    bankAddress: "3VCkXWAmE5DSwYRpqGFnkUz7vvD2RKbhFvrhzLuE8msu",
+    validatorVoteAccount: "abc1zP7ihWsgQW8z5YmfQNqMckJE5Dfx8fwUNMNVNkY",
+    tokenAddress: "BNisp3omkr6Rg5nHESWafjUbeCpGPy6MYq1iRJRgSAsh",
+    tokenName: "ALGO STAKE",
+    tokenSymbol: "ALGO"
+  },
+  {
+    bankAddress: "7BHHMWw3P1AyebLhX9A8wnDeeGy8jgFXqqHuEZt7BVmW",
+    validatorVoteAccount: "8Pep3GmYiijRALqrMKpez92cxvF4YPTzoZg83uXh14pW",
+    tokenAddress: "zBH13AzXYCqHZKS8NGa4KR8zQhWiyvFdDY15nmfrHgS",
+    tokenName: "8Pep",
+    tokenSymbol: "8Pep"
+  },
+  {
+    bankAddress: "9QWUatjtJtc98yts4ufWnmNeaWQRmaaLjFwbK3iMdS47",
+    validatorVoteAccount: "CatzoSMUkTRidT5DwBxAC2pEtnwMBTpkCepHkFgZDiqb",
+    tokenAddress: "98B1NMLYaNJQNxiQGr53vbjNFMNTYFmDqoCgj7qD9Vhm",
+    tokenName: "JUPITER ",
+    tokenSymbol: "JUPITER"
+  },
+  {
+    bankAddress: "5q1wJkGqqRh6mSBtjG8sfjBsgJSGdA2QoXTWv4UQbHGk",
+    validatorVoteAccount: "shft7Fry1js37Hm9wq4dfwcZSp2DyKszeWMvEpjYCQ1",
+    tokenAddress: "C1KwBJZNwUaodUcP5kXqD52NCuZzThNAG2cw3vt5H6iE",
+    tokenName: "BLUESHIFT",
+    tokenSymbol: "SHIFT"
+  },
+  {
+    bankAddress: "FZaHyfg9hmNMKpfUJ474wNKPaPdXMpnJouasKnndECiZ",
+    validatorVoteAccount: "DdCNGDpP7qMgoAy6paFzhhak2EeyCZcgjH7ak5u5v28m",
+    tokenAddress: "PhxXAYTkFZS23ZWvFcz6H6Uq4VnVBMa6hniiAyudjaW",
+    tokenName: "KILN1",
+    tokenSymbol: "KILN1"
+  },
+  {
+    bankAddress: "5CBocarwfJeWGNozGemWktRYSz6kPikRPdfH8ZHSFrsg",
+    validatorVoteAccount: "8zuMRTXThoPTTPLLvaiKiJshLLCqGMt9BdRjjCL19xBc",
+    tokenAddress: "BDsEuxFWznAP5cUCannnfjyjDtTwqN57CkGfDbjx2nNZ",
+    tokenName: "DawnLabs",
+    tokenSymbol: "DawnLabs"
+  },
+  {
+    bankAddress: "9ivswG37QpCUmkPkLMpRZT7PMyP64V9dDpZdteM254ec",
+    validatorVoteAccount: "gaToR246dheK1DGAMEqxMdBJZwU4qFyt7DzhSwAHFWF",
+    tokenAddress: "TjA2rtxoUFzyPVAw35VQGEQnNXiwcmNjKSk29nmkq1P",
+    tokenName: "Valigator Open",
+    tokenSymbol: "Valigator"
+  }
+];
+
+// src/services/native-stake/utils/metadata.utils.ts
+var _metadataMap = null;
+var _voteAccountByBank = null;
+function getStakedBankMetadataMap() {
+  if (!_metadataMap) {
+    _metadataMap = /* @__PURE__ */ new Map();
+    for (const entry of STAKED_BANK_METADATA_JSON) {
+      _metadataMap.set(entry.bankAddress, entry);
+    }
+  }
+  return _metadataMap;
+}
+function getValidatorVoteAccountByBank() {
+  if (!_voteAccountByBank) {
+    _voteAccountByBank = {};
+    for (const entry of STAKED_BANK_METADATA_JSON) {
+      _voteAccountByBank[entry.bankAddress] = entry.validatorVoteAccount;
+    }
+  }
+  return _voteAccountByBank;
+}
 async function getKaminoMetadata(options) {
   const kaminoBanks = options.banks.filter((b) => b.config.assetTag === 3 /* KAMINO */);
   const DEFAULT_PUBKEY = web3_js.PublicKey.default;
@@ -53104,6 +53864,66 @@ var MarginfiAccountWrapper = class {
     return this.account.getHealthCheckAccounts(this.client.bankMap, mandatoryBanks, excludedBanks);
   }
   // ----------------------------------------------------------------------------
+  // Native stake actions
+  // Note: These call standalone action functions directly rather than routing
+  // through this.account because they interact with the SPL stake pool program,
+  // not the marginfi program. No MarginfiAccount state is needed.
+  // ----------------------------------------------------------------------------
+  /**
+   * Creates a transaction to mint LST from a native stake account.
+   *
+   * Converts a native stake account (or a portion of it) into LST tokens
+   * by depositing the stake into the single-validator pool.
+   *
+   * @param amount - SOL amount to convert (in UI units)
+   * @param stakeAccountPk - The stake account to convert
+   * @param validator - The validator vote account
+   */
+  async makeMintStakedLstTx(amount, stakeAccountPk, validator) {
+    return makeMintStakedLstTx({
+      amount,
+      authority: this.authority,
+      stakeAccountPk,
+      validator,
+      connection: this.client.program.provider.connection,
+      luts: this.client.addressLookupTables
+    });
+  }
+  /**
+   * Creates a transaction to redeem LST tokens back to a native stake account.
+   *
+   * Burns LST tokens and withdraws the underlying stake into a new stake account.
+   *
+   * @param amount - LST amount to redeem (in UI units)
+   * @param validator - The validator vote account
+   */
+  async makeRedeemStakedLstTx(amount, validator) {
+    return makeRedeemStakedLstTx({
+      amount,
+      authority: this.authority,
+      validator,
+      connection: this.client.program.provider.connection,
+      luts: this.client.addressLookupTables
+    });
+  }
+  /**
+   * Creates a transaction to merge two stake accounts.
+   *
+   * Both accounts must share the same authorized staker/withdrawer and vote account.
+   *
+   * @param sourceStakeAccount - The stake account to merge from (will be consumed)
+   * @param destinationStakeAccount - The stake account to merge into
+   */
+  async makeMergeStakeAccountsTx(sourceStakeAccount, destinationStakeAccount) {
+    return makeMergeStakeAccountsTx({
+      authority: this.authority,
+      sourceStakeAccount,
+      destinationStakeAccount,
+      connection: this.client.program.provider.connection,
+      luts: this.client.addressLookupTables
+    });
+  }
+  // ----------------------------------------------------------------------------
   // Helper methods
   // ----------------------------------------------------------------------------
   /**
@@ -53365,7 +54185,6 @@ var Project0Client = class _Project0Client {
           assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3__default.default(1));
           break;
         case 2 /* STAKED */:
-          assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3__default.default(1));
           break;
         case 0 /* DEFAULT */:
         case 1 /* SOL */:
@@ -53374,6 +54193,56 @@ var Project0Client = class _Project0Client {
           break;
       }
     });
+    const stakedBanks = banksArray.filter((b) => b.config.assetTag === 2 /* STAKED */);
+    if (stakedBanks.length > 0) {
+      const metadataMap = getStakedBankMetadataMap();
+      const stakedBankAddresses = [];
+      const poolStakeAddresses = [];
+      const lstMintAddresses = [];
+      for (const bank of stakedBanks) {
+        const metadata = metadataMap.get(bank.address.toBase58());
+        if (!metadata) {
+          assetShareMultiplierByBank.set(bank.address.toBase58(), new BigNumber3__default.default(1));
+          continue;
+        }
+        const pool = findPoolAddress(new web3_js.PublicKey(metadata.validatorVoteAccount));
+        stakedBankAddresses.push(bank.address.toBase58());
+        poolStakeAddresses.push(findPoolStakeAddress(pool));
+        lstMintAddresses.push(findPoolMintAddress(pool));
+      }
+      if (stakedBankAddresses.length > 0) {
+        const allAddresses = [
+          ...poolStakeAddresses.map((a) => a.toBase58()),
+          ...lstMintAddresses.map((a) => a.toBase58())
+        ];
+        const accountInfos = await chunkedGetRawMultipleAccountInfoOrdered(
+          connection,
+          allAddresses
+        );
+        const poolStakeInfos = accountInfos.slice(0, poolStakeAddresses.length);
+        const lstMintInfos = accountInfos.slice(poolStakeAddresses.length);
+        for (let i = 0; i < stakedBankAddresses.length; i++) {
+          const bankAddr = stakedBankAddresses[i];
+          const poolStakeInfo = poolStakeInfos[i];
+          const lstMintInfo = lstMintInfos[i];
+          if (!poolStakeInfo || !lstMintInfo) {
+            assetShareMultiplierByBank.set(bankAddr, new BigNumber3__default.default(1));
+            continue;
+          }
+          const stakeLamports = poolStakeInfo.lamports;
+          const supplyBuffer = lstMintInfo.data.slice(36, 44);
+          const lstMintSupply = Number(Buffer.from(supplyBuffer).readBigUInt64LE(0));
+          if (lstMintSupply === 0) {
+            assetShareMultiplierByBank.set(bankAddr, new BigNumber3__default.default(1));
+            continue;
+          }
+          const LAMPORTS_PER_SOL5 = 1e9;
+          const adjustedStake = Math.max(stakeLamports - LAMPORTS_PER_SOL5, 0);
+          const multiplier = new BigNumber3__default.default(adjustedStake).dividedBy(lstMintSupply);
+          assetShareMultiplierByBank.set(bankAddr, multiplier);
+        }
+      }
+    }
     const emodePairs = getEmodePairs(banksArray);
     return new _Project0Client(
       program,
@@ -53646,9 +54515,11 @@ exports.getOracleSourceFromOracleSetup = getOracleSourceFromOracleSetup;
 exports.getOracleSourceNameFromKey = getOracleSourceNameFromKey;
 exports.getPrice = getPrice;
 exports.getPriceWithConfidence = getPriceWithConfidence;
+exports.getStakedBankMetadataMap = getStakedBankMetadataMap;
 exports.getTotalAssetQuantity = getTotalAssetQuantity;
 exports.getTotalLiabilityQuantity = getTotalLiabilityQuantity;
 exports.getTxSize = getTxSize;
+exports.getValidatorVoteAccountByBank = getValidatorVoteAccountByBank;
 exports.groupToDto = groupToDto;
 exports.hasAccountFlag = hasAccountFlag;
 exports.hasEmodeEntryFlag = hasEmodeEntryFlag;
@@ -53688,11 +54559,16 @@ exports.makeKaminoDepositTx = makeKaminoDepositTx;
 exports.makeKaminoWithdrawIx = makeKaminoWithdrawIx3;
 exports.makeKaminoWithdrawTx = makeKaminoWithdrawTx;
 exports.makeLoopTx = makeLoopTx;
+exports.makeMergeStakeAccountsTx = makeMergeStakeAccountsTx;
+exports.makeMintStakedLstIx = makeMintStakedLstIx;
+exports.makeMintStakedLstTx = makeMintStakedLstTx;
 exports.makePoolAddBankIx = makePoolAddBankIx3;
 exports.makePoolConfigureBankIx = makePoolConfigureBankIx3;
 exports.makePriorityFeeIx = makePriorityFeeIx;
 exports.makePriorityFeeMicroIx = makePriorityFeeMicroIx;
 exports.makePulseHealthIx = makePulseHealthIx2;
+exports.makeRedeemStakedLstIx = makeRedeemStakedLstIx;
+exports.makeRedeemStakedLstTx = makeRedeemStakedLstTx;
 exports.makeRefreshKaminoBanksIxs = makeRefreshKaminoBanksIxs;
 exports.makeRepayIx = makeRepayIx3;
 exports.makeRepayTx = makeRepayTx;