@pyefi/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,1340 @@
+import {
+  ALLOWED_VALIDATORS,
+  __spreadValues,
+  allTokenAddresses,
+  allowedLockups,
+  buildMarketLookup,
+  buildPtLookup,
+  configurePyeSDK,
+  createApyStore,
+  createBalanceStore,
+  createMarketStore,
+  createWalletStore,
+  fetchBalances,
+  fetchBalancesForMints,
+  fetchExchangeBalances,
+  fetchManifestMarkets,
+  fetchUserStakeAccounts,
+  getMaturity,
+  getPyeConfig,
+  lockups,
+  lookupBondByVoteAccount,
+  maturities,
+  maturitiesArray,
+  maturityIdsArray,
+  parseOrderBook,
+  tokenIdsArray,
+  tokens,
+  validators
+} from "./chunk-5XHGVQ3Z.js";
+
+// src/constants/fees.ts
+import { PublicKey } from "@solana/web3.js";
+var PYE_TRADING_FEE_BPS = 50;
+var PYE_TREASURY_WALLET = new PublicKey(
+  "D3LKi2CUFmudj4fT8izGeBky84oYPZY7UWwvcLUhh2ch"
+);
+function calculateFeeLamports(expectedSolOut) {
+  return BigInt(
+    Math.round(expectedSolOut * 1e9 * PYE_TRADING_FEE_BPS / 1e4)
+  );
+}
+function applyTradingFee(grossSolOut) {
+  return grossSolOut * (1 - PYE_TRADING_FEE_BPS / 1e4);
+}
+
+// src/lib/fetch-lockup-metrics.ts
+import { createClient } from "@supabase/supabase-js";
+var LAMPORTS_PER_SOL = 1e9;
+function formatBps(bps) {
+  const pct = bps / 100;
+  return pct.toLocaleString("en-US", {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 2
+  }) + "%";
+}
+function formatSol(lamports) {
+  const sol = lamports / LAMPORTS_PER_SOL;
+  return sol.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 4
+  }) + " SOL";
+}
+async function fetchLockupMetrics(bondPubkey, opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
+  const supabase = (_a = opts == null ? void 0 : opts.supabaseClient) != null ? _a : (() => {
+    const config = getPyeConfig();
+    return createClient(config.supabaseUrl, config.supabaseAnonKey);
+  })();
+  const includeCharts = (_b = opts == null ? void 0 : opts.includeChartData) != null ? _b : false;
+  const noData = Promise.resolve({ data: null });
+  const bondRes = await supabase.from("solo_validator_bonds").select("tvl_cap, inflation_bps, mev_tips_bps, block_rewards_bps, validator_vote_account").eq("pubkey", bondPubkey).single();
+  const voteAccount = (_c = bondRes.data) == null ? void 0 : _c.validator_vote_account;
+  const [tvlRes, paymentsRes, rewardsRes, tvlHistoryRes, apyRes] = await Promise.all([
+    supabase.from("tvl_snapshots").select("sol").eq("bond", bondPubkey).order("created_at", { ascending: false }).limit(1).single(),
+    supabase.from("bond_payments").select("epoch, amount").eq("bond_pubkey", bondPubkey).order("epoch", { ascending: true }),
+    includeCharts ? supabase.from("bond_rewards").select("epoch, expected_inflation_rewards, expected_mev_rewards, expected_block_rewards").eq("bond_pubkey", bondPubkey).order("epoch", { ascending: true }) : noData,
+    includeCharts ? supabase.from("tvl_snapshots").select("created_at, sol").eq("bond", bondPubkey).order("created_at", { ascending: true }) : noData,
+    voteAccount ? supabase.from("stakewiz_apy").select("apy").eq("vote_account", voteAccount).order("updated_at", { ascending: false }).limit(1).single() : noData
+  ]);
+  let depositCap = "No Cap";
+  if (((_d = bondRes.data) == null ? void 0 : _d.tvl_cap) && bondRes.data.tvl_cap > 0) {
+    const cap = Number(bondRes.data.tvl_cap);
+    depositCap = cap.toLocaleString("en-US", {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 4
+    }) + " SOL";
+  }
+  let tvl = "\u2014";
+  if (((_e = tvlRes.data) == null ? void 0 : _e.sol) != null) {
+    const solVal = parseFloat(tvlRes.data.sol);
+    tvl = solVal.toLocaleString("en-US", {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 4
+    }) + " SOL";
+  }
+  const inflationBps = Number((_g = (_f = bondRes.data) == null ? void 0 : _f.inflation_bps) != null ? _g : 0);
+  const mevTipsBps = Number((_i = (_h = bondRes.data) == null ? void 0 : _h.mev_tips_bps) != null ? _i : 0);
+  const blockRewardsBps = Number((_k = (_j = bondRes.data) == null ? void 0 : _j.block_rewards_bps) != null ? _k : 0);
+  const payments = [];
+  let totalPaymentLamports = 0;
+  if (paymentsRes.data) {
+    for (const row of paymentsRes.data) {
+      const amount = Number((_l = row.amount) != null ? _l : 0);
+      payments.push({ epoch: Number(row.epoch), amount });
+      totalPaymentLamports += amount;
+    }
+  }
+  const rewardBreakdown = [];
+  let totalRewardLamports = 0;
+  if (rewardsRes.data) {
+    for (const row of rewardsRes.data) {
+      const inflation = Number((_m = row.expected_inflation_rewards) != null ? _m : 0);
+      const mev = Number((_n = row.expected_mev_rewards) != null ? _n : 0);
+      const block = Number((_o = row.expected_block_rewards) != null ? _o : 0);
+      totalRewardLamports += inflation + mev + block;
+      rewardBreakdown.push({
+        epoch: Number(row.epoch),
+        staking: inflation / LAMPORTS_PER_SOL,
+        mev: mev / LAMPORTS_PER_SOL,
+        block: block / LAMPORTS_PER_SOL
+      });
+    }
+  }
+  const tvlHistory = [];
+  if (tvlHistoryRes.data) {
+    const byDay = /* @__PURE__ */ new Map();
+    for (const row of tvlHistoryRes.data) {
+      const date = row.created_at.slice(0, 10);
+      byDay.set(date, parseFloat((_p = row.sol) != null ? _p : "0"));
+    }
+    for (const [date, sol] of byDay) {
+      tvlHistory.push({ date, sol });
+    }
+  }
+  const depositCapSol = Number((_r = (_q = bondRes.data) == null ? void 0 : _q.tvl_cap) != null ? _r : 0);
+  const tvlSol = parseFloat((_t = (_s = tvlRes.data) == null ? void 0 : _s.sol) != null ? _t : "0");
+  let apy90d = null;
+  if (((_u = apyRes.data) == null ? void 0 : _u.apy) != null) {
+    const pct = Number(apyRes.data.apy);
+    apy90d = pct.toFixed(2) + "%";
+  }
+  return {
+    depositCap,
+    depositCapSol,
+    tvl,
+    tvlSol,
+    totalRewards: formatSol(totalRewardLamports),
+    apy90d,
+    inflationRewards: formatBps(1e4 - inflationBps),
+    mevRewards: formatBps(1e4 - mevTipsBps),
+    blockRewards: formatBps(1e4 - blockRewardsBps),
+    payments,
+    rewardBreakdown,
+    tvlHistory,
+    hasChartData: includeCharts,
+    fetchedAt: Date.now()
+  };
+}
+
+// src/lib/liquidity.ts
+function checkBuyLiquidity(asks, orderSizeTokens) {
+  if (asks.length === 0 || orderSizeTokens <= 0) {
+    return {
+      expectedFillPrice: null,
+      slippageBps: 0,
+      totalAvailableSize: 0,
+      isSufficientLiquidity: false
+    };
+  }
+  const sorted = [...asks].sort((a, b) => a.price - b.price);
+  const totalAvailableSize = sorted.reduce((sum, o) => sum + o.size, 0);
+  let remaining = orderSizeTokens;
+  let totalCost = 0;
+  const bestPrice = sorted[0].price;
+  for (const order of sorted) {
+    if (remaining <= 0) break;
+    const fillSize = Math.min(remaining, order.size);
+    totalCost += fillSize * order.price;
+    remaining -= fillSize;
+  }
+  const isSufficientLiquidity = remaining <= 0;
+  const filledSize = orderSizeTokens - Math.max(remaining, 0);
+  const expectedFillPrice = filledSize > 0 ? totalCost / filledSize : null;
+  const slippageBps = expectedFillPrice && bestPrice > 0 ? Math.round((expectedFillPrice - bestPrice) / bestPrice * 1e4) : 0;
+  return {
+    expectedFillPrice,
+    slippageBps,
+    totalAvailableSize,
+    isSufficientLiquidity
+  };
+}
+function checkSellLiquidity(bids, orderSizeTokens) {
+  if (bids.length === 0 || orderSizeTokens <= 0) {
+    return {
+      expectedFillPrice: null,
+      slippageBps: 0,
+      totalAvailableSize: 0,
+      isSufficientLiquidity: false
+    };
+  }
+  const sorted = [...bids].sort((a, b) => b.price - a.price);
+  const totalAvailableSize = sorted.reduce((sum, o) => sum + o.size, 0);
+  let remaining = orderSizeTokens;
+  let totalRevenue = 0;
+  const bestPrice = sorted[0].price;
+  for (const order of sorted) {
+    if (remaining <= 0) break;
+    const fillSize = Math.min(remaining, order.size);
+    totalRevenue += fillSize * order.price;
+    remaining -= fillSize;
+  }
+  const isSufficientLiquidity = remaining <= 0;
+  const filledSize = orderSizeTokens - Math.max(remaining, 0);
+  const expectedFillPrice = filledSize > 0 ? totalRevenue / filledSize : null;
+  const slippageBps = expectedFillPrice && bestPrice > 0 ? Math.round((bestPrice - expectedFillPrice) / bestPrice * 1e4) : 0;
+  return {
+    expectedFillPrice,
+    slippageBps,
+    totalAvailableSize,
+    isSufficientLiquidity
+  };
+}
+
+// src/lib/estimate-rt.ts
+var DEFAULT_MS_PER_SLOT = 400;
+async function fetchEpochSyncedNowTs(connection) {
+  const epochInfo = await connection.getEpochInfo();
+  const elapsedSeconds = epochInfo.slotIndex * DEFAULT_MS_PER_SLOT / 1e3;
+  return Date.now() / 1e3 - elapsedSeconds;
+}
+function estimateRtFromStake({
+  amountSol,
+  maturity,
+  nowTs
+}) {
+  if (amountSol <= 0) return 0;
+  const maturityTs = Number(maturity.maturity_timestamp);
+  const issuanceStartTs = Number(maturity.issuance_start_timestamp);
+  const total = maturityTs - issuanceStartTs;
+  if (total <= 0) return 0;
+  const remaining = Math.max(maturityTs - nowTs, 0);
+  return amountSol * (remaining / total);
+}
+
+// src/lib/execute-stake-deposit.ts
+import {
+  ComputeBudgetProgram,
+  Keypair,
+  PublicKey as PublicKey2,
+  StakeProgram,
+  Transaction,
+  TransactionInstruction
+} from "@solana/web3.js";
+import {
+  TOKEN_PROGRAM_ID,
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddressSync,
+  createAssociatedTokenAccountIdempotentInstruction
+} from "@solana/spl-token";
+var BONDS_PROGRAM_ID = new PublicKey2(
+  "PYEQZ2qYHPQapnw8Ms8MSPMNzoq59NHHfNwAtuV26wx"
+);
+var DEPOSIT_SOL_DISCRIMINATOR = new Uint8Array([
+  253,
+  10,
+  62,
+  175,
+  159,
+  90,
+  55,
+  142
+]);
+var DEPOSIT_STAKE_DISCRIMINATOR = new Uint8Array([
+  21,
+  14,
+  117,
+  220,
+  1,
+  60,
+  23,
+  13
+]);
+var SYSVAR_CLOCK = new PublicKey2(
+  "SysvarC1ock11111111111111111111111111111111"
+);
+var STAKE_PROGRAM = new PublicKey2(
+  "Stake11111111111111111111111111111111111111"
+);
+var SYSVAR_RENT = new PublicKey2(
+  "SysvarRent111111111111111111111111111111111"
+);
+var SYSVAR_STAKE_HISTORY = new PublicKey2(
+  "SysvarStakeHistory1111111111111111111111111"
+);
+var STAKE_CONFIG = new PublicKey2(
+  "StakeConfig11111111111111111111111111111111"
+);
+function deriveGlobalSettings() {
+  const [pda] = PublicKey2.findProgramAddressSync(
+    [Buffer.from("global_settings")],
+    BONDS_PROGRAM_ID
+  );
+  return pda;
+}
+function deriveStakeAccount(bond) {
+  const [pda] = PublicKey2.findProgramAddressSync(
+    [Buffer.from("stake"), bond.toBuffer()],
+    BONDS_PROGRAM_ID
+  );
+  return pda;
+}
+async function fetchProtocolFeeWallet(connection, globalSettingsPda) {
+  const info = await connection.getAccountInfo(globalSettingsPda);
+  if (!info || !info.data) {
+    throw new Error("GlobalSettings account not found");
+  }
+  return new PublicKey2(info.data.subarray(40, 72));
+}
+async function fetchTransientStakeAccount(connection, bond) {
+  const info = await connection.getAccountInfo(bond);
+  if (!info || !info.data) {
+    throw new Error("Bond account not found");
+  }
+  return new PublicKey2(info.data.subarray(72, 104));
+}
+function encodeDepositData(amountLamports) {
+  const buf = new ArrayBuffer(16);
+  const bytes = new Uint8Array(buf);
+  bytes.set(DEPOSIT_SOL_DISCRIMINATOR, 0);
+  new DataView(buf).setBigUint64(8, amountLamports, true);
+  return bytes;
+}
+async function executeStakeAccountDeposit({
+  connection,
+  wallet,
+  bondPubkey,
+  principalTokenMint,
+  yieldTokenMint,
+  validatorVoteAccount,
+  stakeAccountPubkey,
+  amountSol,
+  stakeBalanceSol
+}) {
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const owner = wallet.publicKey;
+  const bond = new PublicKey2(bondPubkey);
+  const ptMint = new PublicKey2(principalTokenMint);
+  const ytMint = new PublicKey2(yieldTokenMint);
+  const voteAccount = new PublicKey2(validatorVoteAccount);
+  const userStake = new PublicKey2(stakeAccountPubkey);
+  const globalSettingsPda = deriveGlobalSettings();
+  const stakeAccountPda = deriveStakeAccount(bond);
+  const [protocolFeeWallet, transientStakeAccount, rentExemptReserve, latestBlockhash] = await Promise.all([
+    fetchProtocolFeeWallet(connection, globalSettingsPda),
+    fetchTransientStakeAccount(connection, bond),
+    connection.getMinimumBalanceForRentExemption(StakeProgram.space),
+    connection.getLatestBlockhash("confirmed")
+  ]);
+  const ownerPt = getAssociatedTokenAddressSync(ptMint, owner, true);
+  const ownerYt = getAssociatedTokenAddressSync(ytMint, owner, true);
+  const feeWalletPt = getAssociatedTokenAddressSync(ptMint, protocolFeeWallet, true);
+  const feeWalletYt = getAssociatedTokenAddressSync(ytMint, protocolFeeWallet, true);
+  const amountLamports = Math.round(amountSol * 1e9);
+  const totalLamports = Math.round(stakeBalanceSol * 1e9);
+  const isPartial = amountLamports < totalLamports;
+  const tx = new Transaction();
+  tx.recentBlockhash = latestBlockhash.blockhash;
+  tx.feePayer = owner;
+  tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 }));
+  tx.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1e3 }));
+  let depositStakeAccount;
+  let splitKeypair = null;
+  if (isPartial) {
+    splitKeypair = Keypair.generate();
+    tx.add(
+      StakeProgram.split(
+        {
+          stakePubkey: userStake,
+          authorizedPubkey: owner,
+          splitStakePubkey: splitKeypair.publicKey,
+          lamports: amountLamports
+        },
+        rentExemptReserve
+      )
+    );
+    depositStakeAccount = splitKeypair.publicKey;
+  } else {
+    depositStakeAccount = userStake;
+  }
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, ownerPt, owner, ptMint)
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, ownerYt, owner, ytMint)
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, feeWalletPt, protocolFeeWallet, ptMint)
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, feeWalletYt, protocolFeeWallet, ytMint)
+  );
+  const isTransientSet = !transientStakeAccount.equals(PublicKey2.default);
+  const remainingAccounts = isTransientSet ? [{ pubkey: transientStakeAccount, isSigner: false, isWritable: true }] : [];
+  const depositIx = new TransactionInstruction({
+    programId: BONDS_PROGRAM_ID,
+    keys: [
+      { pubkey: owner, isSigner: true, isWritable: true },
+      { pubkey: depositStakeAccount, isSigner: false, isWritable: true },
+      { pubkey: ownerPt, isSigner: false, isWritable: true },
+      { pubkey: ownerYt, isSigner: false, isWritable: true },
+      { pubkey: bond, isSigner: false, isWritable: false },
+      { pubkey: voteAccount, isSigner: false, isWritable: false },
+      { pubkey: stakeAccountPda, isSigner: false, isWritable: true },
+      { pubkey: ptMint, isSigner: false, isWritable: true },
+      { pubkey: ytMint, isSigner: false, isWritable: true },
+      { pubkey: globalSettingsPda, isSigner: false, isWritable: false },
+      { pubkey: protocolFeeWallet, isSigner: false, isWritable: false },
+      { pubkey: feeWalletPt, isSigner: false, isWritable: true },
+      { pubkey: feeWalletYt, isSigner: false, isWritable: true },
+      { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: PublicKey2.default, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_CLOCK, isSigner: false, isWritable: false },
+      { pubkey: STAKE_PROGRAM, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_STAKE_HISTORY, isSigner: false, isWritable: false },
+      ...remainingAccounts
+    ],
+    data: Buffer.from(DEPOSIT_STAKE_DISCRIMINATOR)
+  });
+  tx.add(depositIx);
+  const signers = splitKeypair ? [splitKeypair] : [];
+  const signature = await wallet.sendTransaction(tx, connection, { signers });
+  const confirmation = await connection.confirmTransaction(
+    {
+      signature,
+      blockhash: latestBlockhash.blockhash,
+      lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+    },
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature };
+}
+async function executeStakeDeposit({
+  connection,
+  wallet,
+  bondPubkey,
+  principalTokenMint,
+  yieldTokenMint,
+  validatorVoteAccount,
+  amountSol
+}) {
+  var _a;
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const owner = wallet.publicKey;
+  const bond = new PublicKey2(bondPubkey);
+  const ptMint = new PublicKey2(principalTokenMint);
+  const ytMint = new PublicKey2(yieldTokenMint);
+  const voteAccount = new PublicKey2(validatorVoteAccount);
+  const globalSettingsPda = deriveGlobalSettings();
+  const stakeAccountPda = deriveStakeAccount(bond);
+  const [protocolFeeWallet, transientStakeAccount, latestBlockhash] = await Promise.all([
+    fetchProtocolFeeWallet(connection, globalSettingsPda),
+    fetchTransientStakeAccount(connection, bond),
+    connection.getLatestBlockhash("confirmed")
+  ]);
+  const ownerPt = getAssociatedTokenAddressSync(ptMint, owner, true);
+  const ownerYt = getAssociatedTokenAddressSync(ytMint, owner, true);
+  const feeWalletPt = getAssociatedTokenAddressSync(ptMint, protocolFeeWallet, true);
+  const feeWalletYt = getAssociatedTokenAddressSync(ytMint, protocolFeeWallet, true);
+  const amountLamports = BigInt(Math.round(amountSol * 1e9));
+  const isTransientUninitialized = transientStakeAccount.equals(PublicKey2.default);
+  const transientKeypair = isTransientUninitialized ? Keypair.generate() : null;
+  const transientPubkey = (_a = transientKeypair == null ? void 0 : transientKeypair.publicKey) != null ? _a : transientStakeAccount;
+  const tx = new Transaction();
+  tx.recentBlockhash = latestBlockhash.blockhash;
+  tx.feePayer = owner;
+  tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 285e3 }));
+  tx.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1e3 }));
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, ownerPt, owner, ptMint)
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, ownerYt, owner, ytMint)
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, feeWalletPt, protocolFeeWallet, ptMint)
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction(owner, feeWalletYt, protocolFeeWallet, ytMint)
+  );
+  const depositIx = new TransactionInstruction({
+    programId: BONDS_PROGRAM_ID,
+    keys: [
+      { pubkey: owner, isSigner: true, isWritable: true },
+      { pubkey: ownerPt, isSigner: false, isWritable: true },
+      { pubkey: ownerYt, isSigner: false, isWritable: true },
+      { pubkey: bond, isSigner: false, isWritable: true },
+      { pubkey: voteAccount, isSigner: false, isWritable: false },
+      { pubkey: stakeAccountPda, isSigner: false, isWritable: true },
+      { pubkey: ptMint, isSigner: false, isWritable: true },
+      { pubkey: ytMint, isSigner: false, isWritable: true },
+      { pubkey: globalSettingsPda, isSigner: false, isWritable: false },
+      { pubkey: protocolFeeWallet, isSigner: false, isWritable: true },
+      { pubkey: feeWalletPt, isSigner: false, isWritable: true },
+      { pubkey: feeWalletYt, isSigner: false, isWritable: true },
+      { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: PublicKey2.default, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_CLOCK, isSigner: false, isWritable: false },
+      { pubkey: STAKE_PROGRAM, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_RENT, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_STAKE_HISTORY, isSigner: false, isWritable: false },
+      { pubkey: STAKE_CONFIG, isSigner: false, isWritable: false },
+      { pubkey: transientPubkey, isSigner: !!transientKeypair, isWritable: true },
+      { pubkey: BONDS_PROGRAM_ID, isSigner: false, isWritable: false }
+    ],
+    data: Buffer.from(encodeDepositData(amountLamports))
+  });
+  tx.add(depositIx);
+  const signers = transientKeypair ? [transientKeypair] : [];
+  const signature = await wallet.sendTransaction(tx, connection, { signers });
+  const confirmation = await connection.confirmTransaction(
+    {
+      signature,
+      blockhash: latestBlockhash.blockhash,
+      lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+    },
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature };
+}
+
+// src/lib/execute-deposit-and-sell.ts
+import { ManifestClient } from "@cks-systems/manifest-sdk";
+import {
+  ComputeBudgetProgram as ComputeBudgetProgram2,
+  Keypair as Keypair2,
+  PublicKey as PublicKey3,
+  StakeProgram as StakeProgram2,
+  TransactionInstruction as TransactionInstruction2,
+  TransactionMessage,
+  VersionedTransaction
+} from "@solana/web3.js";
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID as ASSOCIATED_TOKEN_PROGRAM_ID2,
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2,
+  createAssociatedTokenAccountIdempotentInstruction as createAssociatedTokenAccountIdempotentInstruction2,
+  createCloseAccountInstruction,
+  createTransferInstruction,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2
+} from "@solana/spl-token";
+var BONDS_PROGRAM_ID2 = new PublicKey3(
+  "PYEQZ2qYHPQapnw8Ms8MSPMNzoq59NHHfNwAtuV26wx"
+);
+var DEPOSIT_STAKE_DISCRIMINATOR2 = new Uint8Array([
+  21,
+  14,
+  117,
+  220,
+  1,
+  60,
+  23,
+  13
+]);
+var SYSVAR_CLOCK2 = new PublicKey3("SysvarC1ock11111111111111111111111111111111");
+var STAKE_PROGRAM2 = new PublicKey3("Stake11111111111111111111111111111111111111");
+var SYSVAR_STAKE_HISTORY2 = new PublicKey3("SysvarStakeHistory1111111111111111111111111");
+function deriveGlobalSettings2() {
+  const [pda] = PublicKey3.findProgramAddressSync(
+    [Buffer.from("global_settings")],
+    BONDS_PROGRAM_ID2
+  );
+  return pda;
+}
+function deriveStakeAccount2(bond) {
+  const [pda] = PublicKey3.findProgramAddressSync(
+    [Buffer.from("stake"), bond.toBuffer()],
+    BONDS_PROGRAM_ID2
+  );
+  return pda;
+}
+async function fetchProtocolFeeWallet2(connection, globalSettingsPda) {
+  const info = await connection.getAccountInfo(globalSettingsPda);
+  if (!(info == null ? void 0 : info.data)) throw new Error("GlobalSettings account not found");
+  return new PublicKey3(info.data.subarray(40, 72));
+}
+async function fetchTransientStakeAccount2(connection, bond) {
+  const info = await connection.getAccountInfo(bond);
+  if (!(info == null ? void 0 : info.data)) throw new Error("Bond account not found");
+  return new PublicKey3(info.data.subarray(72, 104));
+}
+async function executeDepositAndSell({
+  connection,
+  wallet,
+  bondPubkey,
+  principalTokenMint,
+  yieldTokenMint,
+  validatorVoteAccount,
+  stakeAccountPubkey,
+  amountSol,
+  stakeBalanceSol,
+  marketPubkey,
+  rtAmountToSell,
+  minReceiveTokens,
+  expectedSolOut,
+  altPubkey
+}) {
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const owner = wallet.publicKey;
+  const bond = new PublicKey3(bondPubkey);
+  const ptMint = new PublicKey3(principalTokenMint);
+  const ytMint = new PublicKey3(yieldTokenMint);
+  const voteAccount = new PublicKey3(validatorVoteAccount);
+  const userStake = new PublicKey3(stakeAccountPubkey);
+  const marketPk = new PublicKey3(marketPubkey);
+  const globalSettingsPda = deriveGlobalSettings2();
+  const stakeAccountPda = deriveStakeAccount2(bond);
+  const [
+    protocolFeeWallet,
+    transientStakeAccount,
+    rentExemptReserve,
+    latestBlockhash,
+    manifestClient,
+    altResponse
+  ] = await Promise.all([
+    fetchProtocolFeeWallet2(connection, globalSettingsPda),
+    fetchTransientStakeAccount2(connection, bond),
+    connection.getMinimumBalanceForRentExemption(StakeProgram2.space),
+    connection.getLatestBlockhash("confirmed"),
+    ManifestClient.getClientReadOnly(connection, marketPk),
+    connection.getAddressLookupTable(new PublicKey3(altPubkey))
+  ]);
+  const altAccount = altResponse.value;
+  if (!altAccount) {
+    throw new Error(
+      `Address Lookup Table ${altPubkey} not found on-chain \u2014 it may not be deployed yet.`
+    );
+  }
+  const ownerPt = getAssociatedTokenAddressSync2(ptMint, owner, true);
+  const ownerYt = getAssociatedTokenAddressSync2(ytMint, owner, true);
+  const feeWalletPt = getAssociatedTokenAddressSync2(ptMint, protocolFeeWallet, true);
+  const feeWalletYt = getAssociatedTokenAddressSync2(ytMint, protocolFeeWallet, true);
+  const wsolAta = getAssociatedTokenAddressSync2(NATIVE_MINT, owner, true, TOKEN_PROGRAM_ID2);
+  const treasuryWsol = getAssociatedTokenAddressSync2(
+    NATIVE_MINT,
+    PYE_TREASURY_WALLET,
+    true,
+    TOKEN_PROGRAM_ID2
+  );
+  const ataInfos = await connection.getMultipleAccountsInfo([
+    ownerPt,
+    ownerYt,
+    feeWalletPt,
+    feeWalletYt,
+    wsolAta,
+    treasuryWsol
+  ]);
+  const [
+    ownerPtExists,
+    ownerYtExists,
+    feeWalletPtExists,
+    feeWalletYtExists,
+    wsolAtaExists,
+    treasuryWsolExists
+  ] = ataInfos.map((info) => info !== null);
+  const amountLamports = Math.round(amountSol * 1e9);
+  const totalLamports = Math.round(stakeBalanceSol * 1e9);
+  const isPartial = amountLamports < totalLamports;
+  const baseDecimals = manifestClient.market.baseDecimals();
+  const quoteDecimals = manifestClient.market.quoteDecimals();
+  const rawInAtoms = Math.floor(rtAmountToSell * 10 ** baseDecimals);
+  const safetyBuffer = Math.max(Math.ceil(rawInAtoms * 2e-4), 100);
+  const inAtoms = BigInt(Math.max(rawInAtoms - safetyBuffer, 0));
+  const outAtoms = BigInt(Math.floor(minReceiveTokens * 10 ** quoteDecimals));
+  const instructions = [];
+  instructions.push(ComputeBudgetProgram2.setComputeUnitLimit({ units: 55e4 }));
+  instructions.push(ComputeBudgetProgram2.setComputeUnitPrice({ microLamports: 1e3 }));
+  let depositStakeAccount;
+  let splitKeypair = null;
+  if (isPartial) {
+    splitKeypair = Keypair2.generate();
+    instructions.push(
+      ...StakeProgram2.split(
+        {
+          stakePubkey: userStake,
+          authorizedPubkey: owner,
+          splitStakePubkey: splitKeypair.publicKey,
+          lamports: amountLamports
+        },
+        rentExemptReserve
+      ).instructions
+    );
+    depositStakeAccount = splitKeypair.publicKey;
+  } else {
+    depositStakeAccount = userStake;
+  }
+  if (!ownerPtExists) instructions.push(createAssociatedTokenAccountIdempotentInstruction2(owner, ownerPt, owner, ptMint));
+  if (!ownerYtExists) instructions.push(createAssociatedTokenAccountIdempotentInstruction2(owner, ownerYt, owner, ytMint));
+  if (!feeWalletPtExists) instructions.push(createAssociatedTokenAccountIdempotentInstruction2(owner, feeWalletPt, protocolFeeWallet, ptMint));
+  if (!feeWalletYtExists) instructions.push(createAssociatedTokenAccountIdempotentInstruction2(owner, feeWalletYt, protocolFeeWallet, ytMint));
+  if (!wsolAtaExists) instructions.push(createAssociatedTokenAccountIdempotentInstruction2(owner, wsolAta, owner, NATIVE_MINT));
+  if (!treasuryWsolExists) instructions.push(createAssociatedTokenAccountIdempotentInstruction2(owner, treasuryWsol, PYE_TREASURY_WALLET, NATIVE_MINT));
+  const isTransientSet = !transientStakeAccount.equals(PublicKey3.default);
+  const remainingAccounts = isTransientSet ? [{ pubkey: transientStakeAccount, isSigner: false, isWritable: true }] : [];
+  instructions.push(
+    new TransactionInstruction2({
+      programId: BONDS_PROGRAM_ID2,
+      keys: [
+        { pubkey: owner, isSigner: true, isWritable: true },
+        { pubkey: depositStakeAccount, isSigner: false, isWritable: true },
+        { pubkey: ownerPt, isSigner: false, isWritable: true },
+        { pubkey: ownerYt, isSigner: false, isWritable: true },
+        { pubkey: bond, isSigner: false, isWritable: false },
+        { pubkey: voteAccount, isSigner: false, isWritable: false },
+        { pubkey: stakeAccountPda, isSigner: false, isWritable: true },
+        { pubkey: ptMint, isSigner: false, isWritable: true },
+        { pubkey: ytMint, isSigner: false, isWritable: true },
+        { pubkey: globalSettingsPda, isSigner: false, isWritable: false },
+        { pubkey: protocolFeeWallet, isSigner: false, isWritable: false },
+        { pubkey: feeWalletPt, isSigner: false, isWritable: true },
+        { pubkey: feeWalletYt, isSigner: false, isWritable: true },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID2, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID2, isSigner: false, isWritable: false },
+        { pubkey: PublicKey3.default, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_CLOCK2, isSigner: false, isWritable: false },
+        { pubkey: STAKE_PROGRAM2, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_STAKE_HISTORY2, isSigner: false, isWritable: false },
+        ...remainingAccounts
+      ],
+      data: Buffer.from(DEPOSIT_STAKE_DISCRIMINATOR2)
+    })
+  );
+  instructions.push(
+    manifestClient.swapIx(owner, {
+      inAtoms,
+      outAtoms,
+      isBaseIn: true,
+      isExactIn: true
+    })
+  );
+  const feeLamports = calculateFeeLamports(expectedSolOut);
+  if (feeLamports > BigInt(0)) {
+    instructions.push(
+      createTransferInstruction(wsolAta, treasuryWsol, owner, feeLamports)
+    );
+  }
+  instructions.push(createCloseAccountInstruction(wsolAta, owner, owner));
+  const message = new TransactionMessage({
+    payerKey: owner,
+    recentBlockhash: latestBlockhash.blockhash,
+    instructions
+  }).compileToV0Message([altAccount]);
+  const vtx = new VersionedTransaction(message);
+  if (splitKeypair) vtx.sign([splitKeypair]);
+  try {
+    const serialized = vtx.serialize();
+    console.log(
+      `[executeDepositAndSell] v0 tx size=${serialized.length}B (limit=1232) alt=${altPubkey.slice(0, 8)}... skipped=[ownerPt:${ownerPtExists},ownerYt:${ownerYtExists},feeWalletPt:${feeWalletPtExists},feeWalletYt:${feeWalletYtExists},wsolAta:${wsolAtaExists},treasuryWsol:${treasuryWsolExists}] feeLamports=${feeLamports}`
+    );
+  } catch (err) {
+    console.warn("[executeDepositAndSell] could not measure tx size:", err);
+  }
+  const signature = await wallet.sendTransaction(vtx, connection);
+  const confirmation = await connection.confirmTransaction(
+    {
+      signature,
+      blockhash: latestBlockhash.blockhash,
+      lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+    },
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature };
+}
+
+// src/lib/execute-swap.ts
+import { ManifestClient as ManifestClient2 } from "@cks-systems/manifest-sdk";
+import {
+  PublicKey as PublicKey4,
+  SystemProgram,
+  Transaction as Transaction2
+} from "@solana/web3.js";
+import {
+  NATIVE_MINT as NATIVE_MINT2,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3,
+  createAssociatedTokenAccountIdempotentInstruction as createAssociatedTokenAccountIdempotentInstruction3,
+  createCloseAccountInstruction as createCloseAccountInstruction2,
+  createSyncNativeInstruction,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync3
+} from "@solana/spl-token";
+async function executeSwap({
+  connection,
+  wallet,
+  marketPubkey,
+  orderSizeTokens,
+  maxPayTokens,
+  slippageBps
+}) {
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const payer = wallet.publicKey;
+  const marketPk = new PublicKey4(marketPubkey);
+  const client = await ManifestClient2.getClientReadOnly(connection, marketPk);
+  const baseDecimals = client.market.baseDecimals();
+  const quoteDecimals = client.market.quoteDecimals();
+  const baseMint = client.market.baseMint();
+  const outAtoms = BigInt(Math.round(orderSizeTokens * 10 ** baseDecimals));
+  const inAtoms = BigInt(
+    Math.round(maxPayTokens * (1 + slippageBps / 1e4) * 10 ** quoteDecimals)
+  );
+  const baseAta = getAssociatedTokenAddressSync3(baseMint, payer, true, TOKEN_PROGRAM_ID3);
+  const wsolAta = getAssociatedTokenAddressSync3(NATIVE_MINT2, payer, true, TOKEN_PROGRAM_ID3);
+  const tx = new Transaction2();
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction3(
+      payer,
+      baseAta,
+      payer,
+      baseMint
+    )
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction3(
+      payer,
+      wsolAta,
+      payer,
+      NATIVE_MINT2
+    )
+  );
+  tx.add(
+    SystemProgram.transfer({
+      fromPubkey: payer,
+      toPubkey: wsolAta,
+      lamports: inAtoms
+    })
+  );
+  tx.add(createSyncNativeInstruction(wsolAta));
+  tx.add(
+    client.swapIx(payer, {
+      inAtoms,
+      outAtoms,
+      isBaseIn: false,
+      isExactIn: false
+    })
+  );
+  tx.add(createCloseAccountInstruction2(wsolAta, payer, payer));
+  const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+  tx.recentBlockhash = latestBlockhash.blockhash;
+  tx.feePayer = payer;
+  const signature = await wallet.sendTransaction(tx, connection);
+  const confirmation = await connection.confirmTransaction(
+    __spreadValues({ signature }, latestBlockhash),
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature };
+}
+
+// src/lib/execute-rt-sell.ts
+import { ManifestClient as ManifestClient3 } from "@cks-systems/manifest-sdk";
+import {
+  PublicKey as PublicKey5,
+  Transaction as Transaction3
+} from "@solana/web3.js";
+import {
+  NATIVE_MINT as NATIVE_MINT3,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4,
+  createAssociatedTokenAccountIdempotentInstruction as createAssociatedTokenAccountIdempotentInstruction4,
+  createCloseAccountInstruction as createCloseAccountInstruction3,
+  createTransferInstruction as createTransferInstruction2,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync4
+} from "@solana/spl-token";
+async function executeRtSell({
+  connection,
+  wallet,
+  marketPubkey,
+  rtMint,
+  orderSizeTokens,
+  minReceiveTokens,
+  expectedSolOut
+}) {
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const payer = wallet.publicKey;
+  const marketPk = new PublicKey5(marketPubkey);
+  const rtMintPk = new PublicKey5(rtMint);
+  const client = await ManifestClient3.getClientReadOnly(connection, marketPk);
+  const baseDecimals = client.market.baseDecimals();
+  const quoteDecimals = client.market.quoteDecimals();
+  const rawInAtoms = Math.floor(orderSizeTokens * 10 ** baseDecimals);
+  const safetyBuffer = Math.max(Math.ceil(rawInAtoms * 2e-4), 100);
+  const inAtoms = BigInt(Math.max(rawInAtoms - safetyBuffer, 0));
+  const outAtoms = BigInt(Math.floor(minReceiveTokens * 10 ** quoteDecimals));
+  const rtAta = getAssociatedTokenAddressSync4(rtMintPk, payer, true, TOKEN_PROGRAM_ID4);
+  const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT3, payer, true, TOKEN_PROGRAM_ID4);
+  const treasuryWsol = getAssociatedTokenAddressSync4(
+    NATIVE_MINT3,
+    PYE_TREASURY_WALLET,
+    true,
+    TOKEN_PROGRAM_ID4
+  );
+  const tx = new Transaction3();
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction4(
+      payer,
+      rtAta,
+      payer,
+      rtMintPk
+    )
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction4(
+      payer,
+      wsolAta,
+      payer,
+      NATIVE_MINT3
+    )
+  );
+  tx.add(
+    createAssociatedTokenAccountIdempotentInstruction4(
+      payer,
+      treasuryWsol,
+      PYE_TREASURY_WALLET,
+      NATIVE_MINT3
+    )
+  );
+  tx.add(
+    client.swapIx(payer, {
+      inAtoms,
+      outAtoms,
+      isBaseIn: true,
+      isExactIn: true
+    })
+  );
+  const feeLamports = calculateFeeLamports(expectedSolOut);
+  if (feeLamports > BigInt(0)) {
+    tx.add(createTransferInstruction2(wsolAta, treasuryWsol, payer, feeLamports));
+  }
+  tx.add(createCloseAccountInstruction3(wsolAta, payer, payer));
+  const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+  tx.recentBlockhash = latestBlockhash.blockhash;
+  tx.feePayer = payer;
+  const signature = await wallet.sendTransaction(tx, connection);
+  const confirmation = await connection.confirmTransaction(
+    __spreadValues({ signature }, latestBlockhash),
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature };
+}
+
+// src/lib/execute-limit-order.ts
+import { ManifestClient as ManifestClient4, OrderType } from "@cks-systems/manifest-sdk";
+import { PublicKey as PublicKey6, Transaction as Transaction4 } from "@solana/web3.js";
+async function executeLimitOrder({
+  connection,
+  wallet,
+  marketPubkey,
+  orderSizeTokens,
+  limitPrice
+}) {
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const payer = wallet.publicKey;
+  const marketPk = new PublicKey6(marketPubkey);
+  let setupSignature;
+  const setupData = await ManifestClient4.getSetupIxs(
+    connection,
+    marketPk,
+    payer
+  );
+  if (setupData.setupNeeded) {
+    const setupTx = new Transaction4();
+    for (const ix of setupData.instructions) {
+      setupTx.add(ix);
+    }
+    const signers = setupData.wrapperKeypair ? [setupData.wrapperKeypair] : [];
+    const setupBlockhash = await connection.getLatestBlockhash("confirmed");
+    setupTx.recentBlockhash = setupBlockhash.blockhash;
+    setupTx.feePayer = payer;
+    setupSignature = await wallet.sendTransaction(setupTx, connection, {
+      signers
+    });
+    const setupConfirmation = await connection.confirmTransaction(
+      __spreadValues({ signature: setupSignature }, setupBlockhash),
+      "confirmed"
+    );
+    if (setupConfirmation.value.err) {
+      throw new Error(
+        `Setup transaction failed on-chain: ${JSON.stringify(setupConfirmation.value.err)}`
+      );
+    }
+  }
+  const client = await ManifestClient4.getClientForMarketNoPrivateKey(
+    connection,
+    marketPk,
+    payer
+  );
+  const orderIxs = await client.placeOrderWithRequiredDepositIxs(payer, {
+    numBaseTokens: orderSizeTokens,
+    tokenPrice: limitPrice,
+    isBid: false,
+    lastValidSlot: 4e9,
+    orderType: OrderType.Limit,
+    clientOrderId: BigInt(Date.now())
+  });
+  const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+  const tx = new Transaction4();
+  tx.recentBlockhash = latestBlockhash.blockhash;
+  tx.feePayer = payer;
+  for (const ix of orderIxs) tx.add(ix);
+  const signature = await wallet.sendTransaction(tx, connection);
+  const confirmation = await connection.confirmTransaction(
+    __spreadValues({ signature }, latestBlockhash),
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature, setupSignature };
+}
+
+// src/lib/execute-cancel-order.ts
+import {
+  Market,
+  createBatchUpdateInstruction,
+  getVaultAddress,
+  getGlobalAddress,
+  getGlobalVaultAddress
+} from "@cks-systems/manifest-sdk";
+import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID5 } from "@solana/spl-token";
+import { PublicKey as PublicKey7, Transaction as Transaction5 } from "@solana/web3.js";
+async function executeCancelOrder({
+  connection,
+  wallet,
+  marketPubkey,
+  sequenceNumber
+}) {
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const payer = wallet.publicKey;
+  const marketPk = new PublicKey7(marketPubkey);
+  const market = await Market.loadFromAddress({ connection, address: marketPk });
+  const baseMint = market.baseMint();
+  const quoteMint = market.quoteMint();
+  const cancelIx = createBatchUpdateInstruction(
+    {
+      payer,
+      market: marketPk,
+      baseMint,
+      baseGlobal: getGlobalAddress(baseMint),
+      baseGlobalVault: getGlobalVaultAddress(baseMint),
+      baseMarketVault: getVaultAddress(marketPk, baseMint),
+      baseTokenProgram: TOKEN_PROGRAM_ID5,
+      quoteMint,
+      quoteGlobal: getGlobalAddress(quoteMint),
+      quoteGlobalVault: getGlobalVaultAddress(quoteMint),
+      quoteMarketVault: getVaultAddress(marketPk, quoteMint),
+      quoteTokenProgram: TOKEN_PROGRAM_ID5
+    },
+    {
+      params: {
+        cancels: [
+          {
+            orderSequenceNumber: BigInt(sequenceNumber),
+            orderIndexHint: null
+          }
+        ],
+        orders: [],
+        traderIndexHint: null
+      }
+    }
+  );
+  const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+  const tx = new Transaction5();
+  tx.recentBlockhash = latestBlockhash.blockhash;
+  tx.feePayer = payer;
+  tx.add(cancelIx);
+  const signature = await wallet.sendTransaction(tx, connection);
+  const confirmation = await connection.confirmTransaction(
+    __spreadValues({ signature }, latestBlockhash),
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature };
+}
+
+// src/lib/execute-redeem.ts
+import {
+  ComputeBudgetProgram as ComputeBudgetProgram3,
+  Keypair as Keypair3,
+  PublicKey as PublicKey8,
+  Transaction as Transaction6,
+  TransactionInstruction as TransactionInstruction3
+} from "@solana/web3.js";
+import {
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID6,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync5
+} from "@solana/spl-token";
+var BONDS_PROGRAM_ID3 = new PublicKey8(
+  "PYEQZ2qYHPQapnw8Ms8MSPMNzoq59NHHfNwAtuV26wx"
+);
+var HANDLE_MATURITY_DISC = new Uint8Array([127, 154, 109, 164, 119, 21, 34, 149]);
+var REDEEM_PT_STAKE_DISC = new Uint8Array([131, 241, 170, 225, 20, 53, 106, 95]);
+var REDEEM_YT_STAKE_DISC = new Uint8Array([143, 45, 75, 247, 229, 60, 80, 179]);
+var SYSVAR_CLOCK3 = new PublicKey8("SysvarC1ock11111111111111111111111111111111");
+var STAKE_PROGRAM3 = new PublicKey8("Stake11111111111111111111111111111111111111");
+var SYSVAR_RENT2 = new PublicKey8("SysvarRent111111111111111111111111111111111");
+var SYSVAR_STAKE_HISTORY3 = new PublicKey8("SysvarStakeHistory1111111111111111111111111");
+function deriveGlobalSettings3() {
+  const [pda] = PublicKey8.findProgramAddressSync(
+    [Buffer.from("global_settings")],
+    BONDS_PROGRAM_ID3
+  );
+  return pda;
+}
+function deriveStakeAccount3(bond) {
+  const [pda] = PublicKey8.findProgramAddressSync(
+    [Buffer.from("stake"), bond.toBuffer()],
+    BONDS_PROGRAM_ID3
+  );
+  return pda;
+}
+async function fetchBondData(connection, bond) {
+  const info = await connection.getAccountInfo(bond);
+  if (!(info == null ? void 0 : info.data)) throw new Error("Bond account not found");
+  return {
+    transientStakeAccount: new PublicKey8(info.data.subarray(72, 104)),
+    maturityHandled: info.data[185] === 1
+  };
+}
+function encodeAmount(disc, amount) {
+  const ab = new ArrayBuffer(16);
+  const view = new DataView(ab);
+  for (let i = 0; i < 8; i++) view.setUint8(i, disc[i]);
+  view.setBigUint64(8, amount, true);
+  return Buffer.from(ab);
+}
+async function executeRedeem({
+  connection,
+  wallet,
+  bondPubkey,
+  principalTokenMint,
+  yieldTokenMint,
+  ptAmountLamports,
+  rtAmountLamports
+}) {
+  if (!wallet.publicKey || !wallet.sendTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const owner = wallet.publicKey;
+  const bond = new PublicKey8(bondPubkey);
+  const ptMint = new PublicKey8(principalTokenMint);
+  const ytMint = new PublicKey8(yieldTokenMint);
+  const globalSettingsPda = deriveGlobalSettings3();
+  const stakeAccountPda = deriveStakeAccount3(bond);
+  const ownerPt = getAssociatedTokenAddressSync5(ptMint, owner, true);
+  const ownerYt = getAssociatedTokenAddressSync5(ytMint, owner, true);
+  const [bondData, latestBlockhash] = await Promise.all([
+    fetchBondData(connection, bond),
+    connection.getLatestBlockhash("confirmed")
+  ]);
+  const tx = new Transaction6();
+  tx.recentBlockhash = latestBlockhash.blockhash;
+  tx.feePayer = owner;
+  tx.add(ComputeBudgetProgram3.setComputeUnitLimit({ units: 5e5 }));
+  tx.add(ComputeBudgetProgram3.setComputeUnitPrice({ microLamports: 1e3 }));
+  if (!bondData.maturityHandled) {
+    const isTransientSet = !bondData.transientStakeAccount.equals(PublicKey8.default);
+    tx.add(
+      new TransactionInstruction3({
+        programId: BONDS_PROGRAM_ID3,
+        keys: [
+          { pubkey: bond, isSigner: false, isWritable: true },
+          { pubkey: stakeAccountPda, isSigner: false, isWritable: true },
+          ...isTransientSet ? [{ pubkey: bondData.transientStakeAccount, isSigner: false, isWritable: true }] : [],
+          { pubkey: ptMint, isSigner: false, isWritable: false },
+          { pubkey: ytMint, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_CLOCK3, isSigner: false, isWritable: false },
+          { pubkey: STAKE_PROGRAM3, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_STAKE_HISTORY3, isSigner: false, isWritable: false },
+          { pubkey: globalSettingsPda, isSigner: false, isWritable: false }
+        ],
+        data: Buffer.from(HANDLE_MATURITY_DISC)
+      })
+    );
+  }
+  const signers = [];
+  if (ptAmountLamports > 0) {
+    const newStakeKp = Keypair3.generate();
+    signers.push(newStakeKp);
+    tx.add(
+      new TransactionInstruction3({
+        programId: BONDS_PROGRAM_ID3,
+        keys: [
+          { pubkey: owner, isSigner: true, isWritable: true },
+          { pubkey: newStakeKp.publicKey, isSigner: true, isWritable: true },
+          { pubkey: ownerPt, isSigner: false, isWritable: true },
+          { pubkey: bond, isSigner: false, isWritable: true },
+          { pubkey: stakeAccountPda, isSigner: false, isWritable: true },
+          { pubkey: ptMint, isSigner: false, isWritable: true },
+          { pubkey: TOKEN_PROGRAM_ID6, isSigner: false, isWritable: false },
+          { pubkey: PublicKey8.default, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_CLOCK3, isSigner: false, isWritable: false },
+          { pubkey: STAKE_PROGRAM3, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_RENT2, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_STAKE_HISTORY3, isSigner: false, isWritable: false },
+          { pubkey: globalSettingsPda, isSigner: false, isWritable: false }
+        ],
+        data: encodeAmount(REDEEM_PT_STAKE_DISC, BigInt(ptAmountLamports))
+      })
+    );
+  }
+  if (rtAmountLamports > 0) {
+    const newStakeKp = Keypair3.generate();
+    signers.push(newStakeKp);
+    tx.add(
+      new TransactionInstruction3({
+        programId: BONDS_PROGRAM_ID3,
+        keys: [
+          { pubkey: owner, isSigner: true, isWritable: false },
+          { pubkey: newStakeKp.publicKey, isSigner: true, isWritable: true },
+          { pubkey: ownerYt, isSigner: false, isWritable: true },
+          { pubkey: bond, isSigner: false, isWritable: true },
+          { pubkey: stakeAccountPda, isSigner: false, isWritable: true },
+          { pubkey: ytMint, isSigner: false, isWritable: true },
+          { pubkey: ptMint, isSigner: false, isWritable: false },
+          { pubkey: TOKEN_PROGRAM_ID6, isSigner: false, isWritable: false },
+          { pubkey: PublicKey8.default, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_CLOCK3, isSigner: false, isWritable: false },
+          { pubkey: STAKE_PROGRAM3, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_RENT2, isSigner: false, isWritable: false },
+          { pubkey: SYSVAR_STAKE_HISTORY3, isSigner: false, isWritable: false },
+          { pubkey: globalSettingsPda, isSigner: false, isWritable: false }
+        ],
+        data: encodeAmount(REDEEM_YT_STAKE_DISC, BigInt(rtAmountLamports))
+      })
+    );
+  }
+  const signature = await wallet.sendTransaction(tx, connection, { signers });
+  const confirmation = await connection.confirmTransaction(
+    {
+      signature,
+      blockhash: latestBlockhash.blockhash,
+      lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+    },
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Transaction failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return { signature };
+}
+export {
+  ALLOWED_VALIDATORS,
+  PYE_TRADING_FEE_BPS,
+  PYE_TREASURY_WALLET,
+  allTokenAddresses,
+  allowedLockups,
+  applyTradingFee,
+  buildMarketLookup,
+  buildPtLookup,
+  calculateFeeLamports,
+  checkBuyLiquidity,
+  checkSellLiquidity,
+  configurePyeSDK,
+  createApyStore,
+  createBalanceStore,
+  createMarketStore,
+  createWalletStore,
+  estimateRtFromStake,
+  executeCancelOrder,
+  executeDepositAndSell,
+  executeLimitOrder,
+  executeRedeem,
+  executeRtSell,
+  executeStakeAccountDeposit,
+  executeStakeDeposit,
+  executeSwap,
+  fetchBalances,
+  fetchBalancesForMints,
+  fetchEpochSyncedNowTs,
+  fetchExchangeBalances,
+  fetchLockupMetrics,
+  fetchManifestMarkets,
+  fetchUserStakeAccounts,
+  getMaturity,
+  getPyeConfig,
+  lockups,
+  lookupBondByVoteAccount,
+  maturities,
+  maturitiesArray,
+  maturityIdsArray,
+  parseOrderBook,
+  tokenIdsArray,
+  tokens,
+  validators
+};
+//# sourceMappingURL=index.js.map