@wireio/stake 0.2.2 → 0.2.4

package/lib/stake.m.js

@@ -1,10 +1,19 @@
-import { PublicKey as PublicKey$1, KeyType, EvmChainID, SolChainID } from '@wireio/core';
-import { PublicKey, StakeProgram, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_CLOCK_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, SYSVAR_RENT_PUBKEY, Transaction, Keypair, Connection } from '@solana/web3.js';
+import { PublicKey as PublicKey$1, KeyType, SolChainID, EvmChainID } from '@wireio/core';
+import { PublicKey, StakeProgram, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_CLOCK_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, SYSVAR_RENT_PUBKEY, Transaction, Keypair, Connection, LAMPORTS_PER_SOL as LAMPORTS_PER_SOL$1 } from '@solana/web3.js';
 import { Program, BN, AnchorProvider } from '@coral-xyz/anchor';
 import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress, createAssociatedTokenAccountInstruction } from '@solana/spl-token';
 import { ethers, Contract, BigNumber } from 'ethers';
 
-var address$2 = "HR3t8mA25TdJpwLph2h2L7KhK7ynWoAByYYzgUAfd5rk";
+var PurchaseAsset =  ((PurchaseAsset2) => {
+  PurchaseAsset2["SOL"] = "SOL";
+  PurchaseAsset2["LIQSOL"] = "LIQSOL";
+  PurchaseAsset2["ETH"] = "ETH";
+  PurchaseAsset2["LIQETH"] = "LIQETH";
+  PurchaseAsset2["YIELD"] = "YIELD";
+  return PurchaseAsset2;
+})(PurchaseAsset || {});
+
+var address$2 = "BBkVcNWNQz1vZ6esv5US4QnNFWPRqxWbdpJHur9GVXSu";
 var metadata$2 = {
 	name: "liqsol_core",
 	version: "0.1.0",
@@ -3184,58 +3193,8 @@ var events = [
 var errors$2 = [
 	{
 		code: 6000,
-		name: "NoRewardsToClaim",
-		msg: "No rewards to claim"
-	},
-	{
-		code: 6001,
-		name: "InsufficientBalance",
-		msg: "Insufficient balance"
-	},
-	{
-		code: 6002,
-		name: "InsufficientFunds",
-		msg: "Insufficient funds"
-	},
-	{
-		code: 6003,
-		name: "Unauthorized",
-		msg: "Unauthorized - caller is not the distribution authority"
-	},
-	{
-		code: 6004,
-		name: "InvalidMint",
-		msg: "Invalid mint"
-	},
-	{
-		code: 6005,
-		name: "InvalidOwner",
-		msg: "Invalid owner"
-	},
-	{
-		code: 6006,
-		name: "InvalidUserRecord",
-		msg: "Invalid user record"
-	},
-	{
-		code: 6007,
-		name: "InvalidWithdrawal",
-		msg: "Invalid withdrawal - balance increased instead of decreased"
-	},
-	{
-		code: 6008,
-		name: "InvalidProgramId",
-		msg: "Invalid program ID"
-	},
-	{
-		code: 6009,
-		name: "InstructionIntrospectionFailed",
-		msg: "Instruction introspection failed"
-	},
-	{
-		code: 6010,
-		name: "ReceiptFulfilled",
-		msg: "Receipt already fulfilled"
+		name: "AccountBorrowFailed",
+		msg: "Util Acc borrow Failed"
 	}
 ];
 var types$4 = [
@@ -4519,7 +4478,7 @@ var liqsolCoreIDL = {
 	types: types$4
 };
 
-var address$1 = "HEAKvfg2X7K4zbGDiAbfuu5abxQyk1HbKVgskZZFXrUx";
+var address$1 = "6cDoerqdV6UQDsGvUEq5Qj5HRxxyDxSuUaB2J6iK8cio";
 var metadata$1 = {
 	name: "liqsol_token",
 	version: "0.1.0",
@@ -4708,7 +4667,7 @@ var liqsolTokenJson = {
 	types: types$3
 };
 
-var address = "BcMW7wN54FexYaB7Xujvag5uUQ1WoDoGbzVg1VEXPBhV";
+var address = "C4ddPrB1ALYpW4G1Qz4ffvETBA8YGUL7TVZaLiE6bb1q";
 var metadata = {
 	name: "validator_leaderboard",
 	version: "0.1.0",
@@ -5326,7 +5285,8 @@ const PDA_SEEDS = {
   USER_WARRANT_RECORD: "user_warrant_record",
   BAR_STATE_SEED: "bar_state",
   BONDED_ACTOR_SEED: "bonded_actor",
-  BOND_LEVEL_SEED: "bond_level"
+  BOND_LEVEL_SEED: "bond_level",
+  PRICE_HISTORY: "price_history"
 };
 const deriveLiqsolMintPda = () => PublicKey.findProgramAddressSync(
   [Buffer.from(PDA_SEEDS.LIQSOL_MINT)],
@@ -5428,6 +5388,10 @@ const deriveBondedActorPda = (actor) => PublicKey.findProgramAddressSync(
   [Buffer.from(PDA_SEEDS.BONDED_ACTOR_SEED), actor.toBuffer()],
   LIQSOL_CORE
 )[0];
+const derivePriceHistoryPda = () => PublicKey.findProgramAddressSync(
+  [Buffer.from(PDA_SEEDS.PRICE_HISTORY)],
+  LIQSOL_CORE
+)[0];
 const deriveEphemeralStakeAddress = async (user, seed) => {
   const seedStr = `ephemeral_${seed}`;
   return await PublicKey.createWithSeed(user, seedStr, StakeProgram.programId);
@@ -5775,6 +5739,129 @@ class LeaderboardClient {
   }
 }
 
+const INDEX_SCALE = BigInt(1e12);
+BigInt(1e8);
+const BPS = BigInt(1e4);
+function toBigint(x) {
+  if (typeof x === "bigint") return x;
+  if (typeof x === "number") return BigInt(x);
+  return BigInt(x.toString());
+}
+function tokensToShares(amount, currentIndex) {
+  if (amount === BigInt(0)) return BigInt(0);
+  const num = amount * INDEX_SCALE;
+  const q = num / currentIndex;
+  const r = num % currentIndex;
+  return r === BigInt(0) ? q : q + BigInt(1);
+}
+function growOnce(value, growthBps) {
+  const g = BigInt(growthBps);
+  return (value * (BPS + g) + BPS / BigInt(2)) / BPS;
+}
+function shrinkOnce(value, growthBps) {
+  const g = BigInt(growthBps);
+  return (value * BPS + (BPS + g) / BigInt(2)) / (BPS + g);
+}
+function buildSolanaTrancheLadder(options) {
+  const {
+    currentTranche,
+    initialTrancheSupply,
+    currentTrancheSupply,
+    currentPriceUsd,
+    supplyGrowthBps,
+    priceGrowthBps,
+    windowBefore = 5,
+    windowAfter = 5
+  } = options;
+  const startId = Math.max(0, currentTranche - windowBefore);
+  const endId = currentTranche + windowAfter;
+  const capacity =  new Map();
+  const price =  new Map();
+  capacity.set(currentTranche, initialTrancheSupply);
+  price.set(currentTranche, currentPriceUsd);
+  for (let id = currentTranche + 1; id <= endId; id++) {
+    const prevCap = capacity.get(id - 1);
+    const prevPrice = price.get(id - 1);
+    capacity.set(id, growOnce(prevCap, supplyGrowthBps));
+    price.set(id, growOnce(prevPrice, priceGrowthBps));
+  }
+  for (let id = currentTranche - 1; id >= startId; id--) {
+    const nextCap = capacity.get(id + 1);
+    const nextPrice = price.get(id + 1);
+    capacity.set(id, shrinkOnce(nextCap, supplyGrowthBps));
+    price.set(id, shrinkOnce(nextPrice, priceGrowthBps));
+  }
+  const ladder = [];
+  for (let id = startId; id <= endId; id++) {
+    const cap = capacity.get(id);
+    let sold;
+    if (id < currentTranche) {
+      sold = cap;
+    } else if (id === currentTranche) {
+      sold = cap - currentTrancheSupply;
+    } else {
+      sold = BigInt(0);
+    }
+    ladder.push({
+      id,
+      capacity: cap,
+      sold,
+      remaining: cap - sold,
+      priceUsd: price.get(id)
+    });
+  }
+  return ladder;
+}
+function buildSolanaTrancheSnapshot(options) {
+  const {
+    chainID,
+    globalState,
+    trancheState,
+    solPriceUsd,
+    nativePriceTimestamp,
+    ladderWindowBefore,
+    ladderWindowAfter
+  } = options;
+  const currentIndex = toBigint(globalState.currentIndex);
+  const totalShares = toBigint(globalState.totalShares);
+  const currentTranche = trancheState.currentTrancheNumber.toNumber();
+  const currentTrancheSupply = toBigint(trancheState.currentTrancheSupply);
+  const initialTrancheSupply = toBigint(trancheState.initialTrancheSupply);
+  const totalWarrantsSold = toBigint(trancheState.totalWarrantsSold);
+  const currentPriceUsd = toBigint(trancheState.currentTranchePriceUsd);
+  const supplyGrowthBps = trancheState.supplyGrowthBps;
+  const priceGrowthBps = trancheState.priceGrowthBps;
+  const minPriceUsd = trancheState.minPriceUsd ? toBigint(trancheState.minPriceUsd) : void 0;
+  const maxPriceUsd = trancheState.maxPriceUsd ? toBigint(trancheState.maxPriceUsd) : void 0;
+  const ladder = buildSolanaTrancheLadder({
+    currentTranche,
+    initialTrancheSupply,
+    currentTrancheSupply,
+    totalWarrantsSold,
+    currentPriceUsd,
+    supplyGrowthBps,
+    priceGrowthBps,
+    windowBefore: ladderWindowBefore,
+    windowAfter: ladderWindowAfter
+  });
+  return {
+    chainID,
+    currentIndex,
+    totalShares,
+    currentTranche,
+    currentPriceUsd,
+    minPriceUsd,
+    maxPriceUsd,
+    supplyGrowthBps,
+    priceGrowthBps,
+    currentTrancheSupply,
+    initialTrancheSupply,
+    totalWarrantsSold,
+    nativePriceUsd: solPriceUsd,
+    nativePriceTimestamp,
+    ladder
+  };
+}
 let _liqsolCoreProgram = null;
 function getLiqsolCoreProgram(connection) {
   if (_liqsolCoreProgram && _liqsolCoreProgram.provider.connection === connection) {
@@ -5948,8 +6035,17 @@ async function buildOutpostAccounts(connection, user) {
     false,
     TOKEN_2022_PROGRAM_ID
   );
-  const chainLinkFeed = CHAINLINK_FEED;
-  const chainLinkProgram = CHAINLINK_PROGRAM;
+  let chainLinkFeed = CHAINLINK_FEED;
+  let chainLinkProgram = CHAINLINK_PROGRAM;
+  try {
+    const program = getLiqsolCoreProgram(connection);
+    const ts = await program.account.trancheState.fetch(trancheState);
+    if (ts.chainlinkFeed && ts.chainlinkProgram) {
+      chainLinkFeed = ts.chainlinkFeed;
+      chainLinkProgram = ts.chainlinkProgram;
+    }
+  } catch {
+  }
   return {
     user,
     globalState,
@@ -6354,6 +6450,134 @@ const _OutpostClient = class _OutpostClient {
 _OutpostClient.INDEX_SCALE = new BN("1000000000000");
 let OutpostClient = _OutpostClient;
 
+class TokenClient {
+  constructor(provider) {
+    this.provider = provider;
+    const svc = new SolanaProgramService(provider);
+    this.program = svc.getProgram("liqsolCore");
+  }
+  get wallet() {
+    return this.provider.wallet;
+  }
+  async getAccounts(user) {
+    return buildOutpostAccounts(this.provider.connection, user);
+  }
+  async fetchGlobalState() {
+    const { globalState } = await this.getAccounts(this.wallet.publicKey);
+    return this.program.account.globalState.fetch(globalState);
+  }
+  async fetchTrancheState() {
+    const { trancheState } = await this.getAccounts(this.wallet.publicKey);
+    return this.program.account.trancheState.fetch(trancheState);
+  }
+  async fetchWireReceipt(user) {
+    const { wireReceipt } = await this.getAccounts(user);
+    return this.program.account.wireReceipt.fetch(wireReceipt);
+  }
+  async fetchUserWarrantRecord(user) {
+    const { userWarrantRecord } = await this.getAccounts(user);
+    return this.program.account.userWarrantRecord.fetch(userWarrantRecord);
+  }
+  async buildPurchaseWithSolIx(amountLamports, user = this.wallet.publicKey) {
+    const a = await this.getAccounts(user);
+    return this.program.methods.purchaseWithSol(new BN(amountLamports.toString())).accounts({
+      user: a.user,
+      liqsolMint: a.liqsolMint,
+      globalState: a.globalState,
+      poolAuthority: a.poolAuthority,
+      liqsolPoolAta: a.liqsolPoolAta,
+      liqsolPoolUserRecord: a.poolUserRecord,
+      distributionState: a.distributionState,
+      payRateHistory: a.payRateHistory,
+      bucketAuthority: a.bucketAuthority,
+      bucketTokenAccount: a.bucketTokenAccount,
+      solBucket: a.solBucket,
+      warrantDepositRecord: a.wireReceipt,
+      trancheState: a.trancheState,
+      userWarrantRecord: a.userWarrantRecord,
+      chainlinkFeed: a.chainLinkFeed,
+      chainlinkProgram: a.chainLinkProgram,
+      tokenProgram: TOKEN_2022_PROGRAM_ID,
+      systemProgram: SystemProgram.programId
+    }).instruction();
+  }
+  async buildPurchaseWithLiqsolIx(amountLamports, user = this.wallet.publicKey) {
+    const a = await this.getAccounts(user);
+    return this.program.methods.purchaseWithLiqsol(new BN(amountLamports.toString())).accounts({
+      user: a.user,
+      liqsolMint: a.liqsolMint,
+      globalState: a.globalState,
+      buyerAta: a.userAta,
+      poolAuthority: a.poolAuthority,
+      liqsolPoolAta: a.liqsolPoolAta,
+      warrantDepositRecord: a.wireReceipt,
+      liqsolPoolUserRecord: a.poolUserRecord,
+      distributionState: a.distributionState,
+      payRateHistory: a.payRateHistory,
+      bucketAuthority: a.bucketAuthority,
+      bucketTokenAccount: a.bucketTokenAccount,
+      solBucket: a.solBucket,
+      trancheState: a.trancheState,
+      userWarrantRecord: a.userWarrantRecord,
+      chainlinkFeed: a.chainLinkFeed,
+      chainlinkProgram: a.chainLinkProgram,
+      tokenProgram: TOKEN_2022_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId
+    }).instruction();
+  }
+  async buildPurchaseFromYieldIx(user = this.wallet.publicKey) {
+    const a = await this.getAccounts(user);
+    return this.program.methods.purchaseWarrantsFromYield().accounts({
+      user: a.user,
+      globalState: a.globalState,
+      liqsolMint: a.liqsolMint,
+      poolAuthority: a.poolAuthority,
+      liqsolPoolAta: a.liqsolPoolAta,
+      solBucket: a.solBucket,
+      liqsolPoolUserRecord: a.poolUserRecord,
+      distributionState: a.distributionState,
+      payRateHistory: a.payRateHistory,
+      bucketAuthority: a.bucketAuthority,
+      bucketTokenAccount: a.bucketTokenAccount,
+      trancheState: a.trancheState,
+      userWarrantRecord: a.userWarrantRecord,
+      chainlinkFeed: a.chainLinkFeed,
+      chainlinkProgram: a.chainLinkProgram,
+      tokenProgram: TOKEN_2022_PROGRAM_ID,
+      systemProgram: SystemProgram.programId
+    }).instruction();
+  }
+  async getSolPriceUsdSafe() {
+    try {
+      const price = await this.getSolPriceUsd();
+      return { price, timestamp: void 0 };
+    } catch {
+      return { price: void 0, timestamp: void 0 };
+    }
+  }
+  async getSolPriceUsd() {
+    const priceHistoryPda = derivePriceHistoryPda();
+    const history = await this.program.account.priceHistory.fetch(
+      priceHistoryPda
+    );
+    const { prices, nextIndex, count, windowSize } = history;
+    if (!prices || prices.length === 0 || !count) {
+      throw new Error("Price history is empty \u2013 no SOL price available");
+    }
+    const capacity = prices.length || windowSize;
+    if (!capacity) {
+      throw new Error("Price history capacity is zero \u2013 check account layout");
+    }
+    const lastIndex = nextIndex === 0 ? capacity - 1 : nextIndex - 1;
+    const latest = prices[lastIndex];
+    if (!BN.isBN(latest)) {
+      throw new Error("Latest price entry is not a BN \u2013 check IDL/decoder");
+    }
+    return BigInt(latest.toString());
+  }
+}
+
 const commitment = "confirmed";
 class SolanaStakingClient {
   constructor(config) {
@@ -6386,6 +6610,8 @@ class SolanaStakingClient {
     this.distributionClient = new DistributionClient(this.anchor);
     this.leaderboardClient = new LeaderboardClient(this.anchor);
     this.outpostClient = new OutpostClient(this.anchor);
+    this.tokenClient = new TokenClient(this.anchor);
+    this.tokenClient = new TokenClient(this.anchor);
   }
   get solPubKey() {
     return new PublicKey(this.pubKey.data.array);
@@ -6394,36 +6620,94 @@ class SolanaStakingClient {
     return this.config.network;
   }
   async deposit(amountLamports) {
-    if (amountLamports <= BigInt(0)) throw new Error("Deposit amount must be greater than zero.");
+    if (amountLamports <= BigInt(0)) {
+      throw new Error("Deposit amount must be greater than zero.");
+    }
     const tx = await this.depositClient.buildDepositTx(amountLamports);
-    const { tx: prepared, blockhash, lastValidBlockHeight } = await this.prepareTx(tx);
+    const { tx: prepared, blockhash, lastValidBlockHeight } = await this.prepareTx(
+      tx
+    );
     const signed = await this.signTransaction(prepared);
-    const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
-    return result.signature;
+    return await this.sendAndConfirmHttp(signed, {
+      blockhash,
+      lastValidBlockHeight
+    });
   }
-  async withdraw(amountLamports) {
+  async withdraw(_amountLamports) {
     throw new Error("Withdraw method not yet implemented.");
   }
   async stake(amountLamports) {
-    if (amountLamports <= BigInt(0)) throw new Error("Stake amount must be greater than zero.");
-    const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(this.solPubKey);
+    if (amountLamports <= BigInt(0)) {
+      throw new Error("Stake amount must be greater than zero.");
+    }
+    const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(
+      this.solPubKey
+    );
     const stakeIx = await this.outpostClient.buildStakeLiqsolIx(amountLamports);
     const tx = new Transaction().add(...preIxs, stakeIx);
     const prepared = await this.prepareTx(tx);
     const signed = await this.signTransaction(prepared.tx);
-    const result = await this.sendAndConfirmHttp(signed, prepared);
-    return result.signature;
+    return await this.sendAndConfirmHttp(signed, prepared);
   }
   async unstake(amountLamports) {
-    if (amountLamports <= BigInt(0)) throw new Error("Unstake amount must be greater than zero.");
+    if (amountLamports <= BigInt(0)) {
+      throw new Error("Unstake amount must be greater than zero.");
+    }
     const user = this.solPubKey;
     const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
     const withdrawIx = await this.outpostClient.buildWithdrawStakeIx(amountLamports);
     const tx = new Transaction().add(...preIxs, withdrawIx);
     const prepared = await this.prepareTx(tx);
     const signed = await this.signTransaction(prepared.tx);
-    const result = await this.sendAndConfirmHttp(signed, prepared);
-    return result.signature;
+    return await this.sendAndConfirmHttp(signed, prepared);
+  }
+  async buy(amountLamports, purchaseAsset) {
+    const user = this.solPubKey;
+    let ix;
+    let preIxs = [];
+    switch (purchaseAsset) {
+      case PurchaseAsset.SOL: {
+        if (!amountLamports || amountLamports <= BigInt(0)) {
+          throw new Error("SOL pretoken purchase requires a positive amount.");
+        }
+        ix = await this.tokenClient.buildPurchaseWithSolIx(
+          amountLamports,
+          user
+        );
+        break;
+      }
+      case PurchaseAsset.LIQSOL: {
+        if (!amountLamports || amountLamports <= BigInt(0)) {
+          throw new Error(
+            "liqSOL pretoken purchase requires a positive amount."
+          );
+        }
+        preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
+        ix = await this.tokenClient.buildPurchaseWithLiqsolIx(
+          amountLamports,
+          user
+        );
+        break;
+      }
+      case PurchaseAsset.YIELD: {
+        ix = await this.tokenClient.buildPurchaseFromYieldIx(user);
+        break;
+      }
+      case PurchaseAsset.ETH:
+      case PurchaseAsset.LIQETH: {
+        throw new Error(
+          "ETH / LIQETH pretoken purchases are not supported on Solana."
+        );
+      }
+      default:
+        throw new Error(`Unsupported pretoken purchase asset: ${String(
+          purchaseAsset
+        )}`);
+    }
+    const tx = new Transaction().add(...preIxs, ix);
+    const prepared = await this.prepareTx(tx);
+    const signed = await this.signTransaction(prepared.tx);
+    return await this.sendAndConfirmHttp(signed, prepared);
   }
   async getPortfolio() {
     const user = this.solPubKey;
@@ -6437,7 +6721,12 @@ class SolanaStakingClient {
       TOKEN_2022_PROGRAM_ID,
       ASSOCIATED_TOKEN_PROGRAM_ID
     );
-    const [nativeLamports, actualBalResp, userRecord, snapshot] = await Promise.all([
+    const [
+      nativeLamports,
+      actualBalResp,
+      userRecord,
+      snapshot
+    ] = await Promise.all([
       this.connection.getBalance(user, "confirmed"),
       this.connection.getTokenAccountBalance(userLiqsolAta, "confirmed").catch(() => null),
       this.distributionClient.getUserRecord(user).catch(() => null),
@@ -6445,9 +6734,13 @@ class SolanaStakingClient {
     ]);
     const LIQSOL_DECIMALS = 9;
     const actualAmountStr = actualBalResp?.value?.amount ?? "0";
-    const trackedAmountStr = userRecord?.trackedBalance ? userRecord.trackedBalance.toString() : "0";
+    const trackedAmountStr = userRecord?.trackedBalance?.toString() ?? "0";
     const wireReceipt = snapshot?.wireReceipt ?? null;
-    const stakedAmountStr = wireReceipt?.stakedLiqsol ? wireReceipt.stakedLiqsol.toString() : "0";
+    const userWarrantRecord = snapshot?.userWarrantRecord ?? null;
+    const trancheState = snapshot?.trancheState ?? null;
+    const globalState = snapshot?.globalState ?? null;
+    const stakedAmountStr = wireReceipt?.stakedLiqsol?.toString() ?? "0";
+    const wireSharesStr = userWarrantRecord?.totalWarrantsPurchased?.toString() ?? "0";
     return {
       native: {
         amount: BigInt(nativeLamports),
@@ -6465,6 +6758,11 @@ class SolanaStakingClient {
         symbol: "LiqSOL",
         decimals: LIQSOL_DECIMALS
       },
+      wire: {
+        amount: BigInt(wireSharesStr),
+        symbol: "$WIRE",
+        decimals: 8
+      },
       tracked: {
         amount: BigInt(trackedAmountStr),
         symbol: "LiqSOL",
@@ -6474,40 +6772,124 @@ class SolanaStakingClient {
         userLiqsolAta: userLiqsolAta.toBase58(),
         reservePoolPDA: reservePoolPDA.toBase58(),
         vaultPDA: vaultPDA.toBase58(),
-        wireReceipt
+        wireReceipt,
+        userWarrantRecord,
+        globalIndex: globalState?.currentIndex?.toString(),
+        totalShares: globalState?.totalShares?.toString(),
+        currentTrancheNumber: trancheState?.currentTrancheNumber?.toString(),
+        currentTranchePriceUsd: trancheState?.currentTranchePriceUsd?.toString()
       },
       chainID: this.network.chainId
     };
   }
+  async getTrancheSnapshot(options) {
+    const {
+      chainID = SolChainID.WireTestnet,
+      windowBefore,
+      windowAfter
+    } = options ?? {};
+    const [globalState, trancheState] = await Promise.all([
+      this.tokenClient.fetchGlobalState(),
+      this.tokenClient.fetchTrancheState()
+    ]);
+    const { price: solPriceUsd, timestamp } = await this.tokenClient.getSolPriceUsdSafe();
+    return buildSolanaTrancheSnapshot({
+      chainID,
+      globalState,
+      trancheState,
+      solPriceUsd,
+      nativePriceTimestamp: timestamp,
+      ladderWindowBefore: windowBefore,
+      ladderWindowAfter: windowAfter
+    });
+  }
+  async getBuyQuote(amount, asset, opts) {
+    if (asset !== PurchaseAsset.YIELD && amount <= BigInt(0)) {
+      throw new Error("amount must be > 0 for non-YIELD purchases");
+    }
+    const snapshot = await this.getTrancheSnapshot({
+      chainID: opts?.chainID
+    });
+    const wirePriceUsd = snapshot.currentPriceUsd;
+    const solPriceUsd = snapshot.nativePriceUsd;
+    if (!wirePriceUsd || wirePriceUsd <= BigInt(0)) {
+      throw new Error("Invalid WIRE price in tranche snapshot");
+    }
+    if (!solPriceUsd || solPriceUsd <= BigInt(0)) {
+      throw new Error("No SOL/USD price available");
+    }
+    const ONE_E9 = BigInt(LAMPORTS_PER_SOL$1);
+    const ONE_E8 = BigInt(1e8);
+    let notionalUsd;
+    switch (asset) {
+      case PurchaseAsset.SOL: {
+        notionalUsd = amount * solPriceUsd / ONE_E9;
+        break;
+      }
+      case PurchaseAsset.LIQSOL: {
+        notionalUsd = amount * solPriceUsd / ONE_E9;
+        break;
+      }
+      case PurchaseAsset.YIELD: {
+        notionalUsd = amount * solPriceUsd / ONE_E9;
+        break;
+      }
+      case PurchaseAsset.ETH:
+      case PurchaseAsset.LIQETH:
+        throw new Error("getBuyQuote for ETH/LIQETH is not supported on Solana");
+      default:
+        throw new Error(`Unsupported purchase asset: ${String(asset)}`);
+    }
+    const numerator = notionalUsd * ONE_E8;
+    const wireShares = numerator === BigInt(0) ? BigInt(0) : (numerator + wirePriceUsd - BigInt(1)) / wirePriceUsd;
+    return {
+      purchaseAsset: asset,
+      amountIn: amount,
+      wireShares,
+      wireDecimals: 8,
+      wirePriceUsd,
+      notionalUsd
+    };
+  }
   async getUserRecord() {
     return this.distributionClient.getUserRecord(this.solPubKey);
   }
-  getProtocolFee() {
-  }
   async correctBalance(amount) {
     const build = await this.distributionClient.buildCorrectRegisterTx({ amount });
     if (!build.canSucceed || !build.transaction) {
       throw new Error(build.reason ?? "Unable to build Correct&Register transaction");
     }
-    const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(build.transaction);
+    const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(
+      build.transaction
+    );
     const signed = await this.signTransaction(tx);
-    const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
-    return result.signature;
+    const signature = await this.sendAndConfirmHttp(signed, {
+      blockhash,
+      lastValidBlockHeight
+    });
+    return signature;
   }
   async sendAndConfirmHttp(signed, ctx) {
-    const signature = await this.connection.sendRawTransaction(signed.serialize(), {
-      skipPreflight: false,
-      preflightCommitment: commitment,
-      maxRetries: 3
-    });
+    const signature = await this.connection.sendRawTransaction(
+      signed.serialize(),
+      {
+        skipPreflight: false,
+        preflightCommitment: commitment,
+        maxRetries: 3
+      }
+    );
     const conf = await this.connection.confirmTransaction(
-      { signature, blockhash: ctx.blockhash, lastValidBlockHeight: ctx.lastValidBlockHeight },
+      {
+        signature,
+        blockhash: ctx.blockhash,
+        lastValidBlockHeight: ctx.lastValidBlockHeight
+      },
       commitment
     );
     if (conf.value.err) {
       throw new Error(`Transaction failed: ${JSON.stringify(conf.value.err)}`);
     }
-    return { signature, slot: conf.context.slot, confirmed: true };
+    return signature;
   }
   async signTransaction(tx) {
     return this.anchor.wallet.signTransaction(tx);
@@ -24317,6 +24699,12 @@ class EthereumStakingClient {
       rewardCooldown
     };
   }
+  buy(amount, purchaseAsset) {
+    throw new Error("Method not yet implemented.");
+  }
+  getBuyQuote(amount, purchaseAsset) {
+    throw new Error("Method not yet implemented.");
+  }
   async getPortfolio() {
     const walletAddress = await this.signer.getAddress();
     const nativeBalance = await this.provider.getBalance(walletAddress);
@@ -24346,10 +24734,18 @@ class EthereumStakingClient {
         decimals: nativeDecimals,
         symbol: liqSymbol
       },
+      wire: {
+        amount: BigInt(0),
+        decimals: 0,
+        symbol: "$WIRE"
+      },
       chainID: this.network.chainId
     };
     return portfolio;
   }
+  async getTrancheSnapshot() {
+    return null;
+  }
   async requestWithdraw(amountWei) {
     const deadline = Math.floor(Date.now() / 1e3) + 3600;
     const liqEth = this.contract.LiqEth;
@@ -24461,13 +24857,13 @@ const CONTRACT_NAMES = [
 ];
 
 var types$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CONTRACT_NAMES: CONTRACT_NAMES
+    __proto__: null,
+    CONTRACT_NAMES: CONTRACT_NAMES
 });
 
 var types = /*#__PURE__*/Object.freeze({
-  __proto__: null
+    __proto__: null
 });
 
-export { ADDRESSES, CHAINLINK_FEED, CHAINLINK_PROGRAM, CONTRACTS, DEFAULT_AVERAGE_PAY_RATE, DEFAULT_PAY_RATE_LOOKBACK, DepositClient$1 as DepositClient, DistributionClient, EPHEMERAL_RENT_EXEMPTION, ERC1155Abi, ERC20Abi, ERC721Abi, types$1 as ETH, EthereumContractService, EthereumStakingClient, LAMPORTS_PER_SOL, LIQSOL_CORE, LIQSOL_TOKEN, LeaderboardClient, OutpostClient, PAY_RATE_SCALE_FACTOR, PDA_SEEDS, PROGRAM_IDS, types as SOL, SolanaStakingClient, Staker, VALIDATOR_LEADERBOARD, airdropSol, buildOutpostAccounts, calculateExpectedFee, deriveBarConfigPda, deriveBondLevelPda, deriveBondedActorPda, deriveBucketAuthorityPda, deriveDepositAuthorityPda, deriveDistributionStatePda, deriveEphemeralStakeAddress, deriveLeaderboardStatePda, deriveLiqsolMintAuthorityPda, deriveLiqsolMintPda, deriveOutpostGlobalStatePda, deriveOutpostPoolAuthorityPda, derivePayRateHistoryPda, derivePayoutStatePda, derivePoolUserRecordPda, deriveReservePoolPda, deriveSolBucketPda, deriveStakeControllerStatePda, deriveStakeControllerVaultPda, deriveTrancheStatePda, deriveUserRecordPda, deriveUserUserRecordPda, deriveUserWarrantRecordPda, deriveValidatorRecordPda, deriveVaultPda, deriveWireReceiptPda, generateRandomDepositAmount, generateTestKeypair, getAveragePayRate, getBucketLiqSolBalance, getEpochSnapshot, getErrorMessage, getLiqsolCoreProgram, getPayoutStateRaw, getReservePoolBalance, getStakeControllerStateRaw, getUserLiqSolBalance, getUserRecordRaw, lamportsToSol, msToEpochEnd, previewDepositEffects, scheduledInstruction, sleep, solToLamports, waitForConfirmation, waitUntilSafeToExecuteFunction };
+export { ADDRESSES, CHAINLINK_FEED, CHAINLINK_PROGRAM, CONTRACTS, DEFAULT_AVERAGE_PAY_RATE, DEFAULT_PAY_RATE_LOOKBACK, DepositClient$1 as DepositClient, DistributionClient, EPHEMERAL_RENT_EXEMPTION, ERC1155Abi, ERC20Abi, ERC721Abi, types$1 as ETH, EthereumContractService, EthereumStakingClient, LAMPORTS_PER_SOL, LIQSOL_CORE, LIQSOL_TOKEN, LeaderboardClient, OutpostClient, PAY_RATE_SCALE_FACTOR, PDA_SEEDS, PROGRAM_IDS, PurchaseAsset, types as SOL, SolanaStakingClient, Staker, TokenClient, VALIDATOR_LEADERBOARD, airdropSol, buildOutpostAccounts, buildSolanaTrancheLadder, buildSolanaTrancheSnapshot, calculateExpectedFee, deriveBarConfigPda, deriveBondLevelPda, deriveBondedActorPda, deriveBucketAuthorityPda, deriveDepositAuthorityPda, deriveDistributionStatePda, deriveEphemeralStakeAddress, deriveLeaderboardStatePda, deriveLiqsolMintAuthorityPda, deriveLiqsolMintPda, deriveOutpostGlobalStatePda, deriveOutpostPoolAuthorityPda, derivePayRateHistoryPda, derivePayoutStatePda, derivePoolUserRecordPda, derivePriceHistoryPda, deriveReservePoolPda, deriveSolBucketPda, deriveStakeControllerStatePda, deriveStakeControllerVaultPda, deriveTrancheStatePda, deriveUserRecordPda, deriveUserUserRecordPda, deriveUserWarrantRecordPda, deriveValidatorRecordPda, deriveVaultPda, deriveWireReceiptPda, generateRandomDepositAmount, generateTestKeypair, getAveragePayRate, getBucketLiqSolBalance, getEpochSnapshot, getErrorMessage, getLiqsolCoreProgram, getPayoutStateRaw, getReservePoolBalance, getStakeControllerStateRaw, getUserLiqSolBalance, getUserRecordRaw, lamportsToSol, msToEpochEnd, previewDepositEffects, scheduledInstruction, sleep, solToLamports, toBigint, tokensToShares, waitForConfirmation, waitUntilSafeToExecuteFunction };
 //# sourceMappingURL=stake.m.js.map