@pyefi/sdk 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,317 @@
+import { V as ValidatorId, M as MaturityId, U as UserStakeAccount, O as OpenOrder, a as MatchedMarket, I as IndividualOrder, b as Maturity } from './apy-store-CNq9A4Xc.js';
+export { A as ALLOWED_VALIDATORS, c as ApyActions, d as ApyState, e as ApyStore, B as BalanceActions, f as BalanceState, g as BalanceStore, h as Balances, i as ManifestMarketRecord, j as MarketActions, k as MarketState, l as MarketStore, m as OrderBookSummary, S as StakeAccountState, n as Validator, W as WalletActions, o as WalletState, p as WalletStatus, q as WalletStore, r as buildMarketLookup, s as createApyStore, t as createBalanceStore, u as createMarketStore, v as createWalletStore, w as fetchManifestMarkets, x as getMaturity, y as maturities, z as maturitiesArray, C as maturityIdsArray, D as parseOrderBook, E as validators } from './apy-store-CNq9A4Xc.js';
+import { PublicKey, Connection } from '@solana/web3.js';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { WalletContextState } from '@solana/wallet-adapter-react';
+import 'immer';
+import 'zustand/vanilla';
+import '@solana/kit';
+
+interface PyeSDKConfig {
+    rpcUrl: string;
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    /** If set, only detect stake accounts delegated to this vote account */
+    voteAccount?: string;
+}
+declare function configurePyeSDK(config: PyeSDKConfig): void;
+declare function getPyeConfig(): PyeSDKConfig;
+
+interface Bond {
+    pubkey: string;
+    pt_address: string;
+    rt_address: string;
+}
+interface Bond {
+    pubkey: string;
+    pt_address: string;
+    rt_address: string;
+}
+declare const lockups: Partial<Record<ValidatorId, Partial<Record<MaturityId, Bond>>>>;
+declare function allowedLockups(): Partial<Record<ValidatorId, Partial<Record<MaturityId, Bond>>>>;
+/** Look up a bond by the stake account's validator vote account and maturity. */
+declare function lookupBondByVoteAccount(voteAccount: string, maturityId: MaturityId): (Bond & {
+    validatorId: ValidatorId;
+}) | null;
+interface PtLookupEntry {
+    validatorId: ValidatorId;
+    maturityId: MaturityId;
+    bond: Bond;
+}
+/** Reverse-lookup map: PT mint address → { validatorId, maturityId, bond }. */
+declare function buildPtLookup(): Map<string, PtLookupEntry>;
+
+interface Token {
+    name: string;
+    symbol: string;
+    coingecko_id: string;
+    icon: string;
+    address: string;
+}
+type TokenId = "solana";
+declare const tokens: {
+    [key in TokenId]: Token;
+};
+declare const tokenIdsArray: TokenId[];
+declare function allTokenAddresses(): string[];
+
+/**
+ * Pye protocol taker fee charged on RT sales, expressed in basis points.
+ * 50 bps = 0.50%. Applied to the SOL out of the Manifest swap.
+ */
+declare const PYE_TRADING_FEE_BPS = 50;
+/**
+ * Destination for taker-fee proceeds. Fees are transferred as wSOL to the
+ * treasury's wSOL ATA; the treasury unwraps out-of-band.
+ */
+declare const PYE_TREASURY_WALLET: PublicKey;
+/** Gross SOL out × feeBps/10_000, rounded to integer lamports. */
+declare function calculateFeeLamports(expectedSolOut: number): bigint;
+/** Apply fee deduction to a gross SOL quote to get the user-facing net. */
+declare function applyTradingFee(grossSolOut: number): number;
+
+declare function fetchUserStakeAccounts(connection: Connection, owner: PublicKey): Promise<UserStakeAccount[]>;
+
+declare function fetchBalances(connection: Connection, owner: PublicKey): Promise<Record<string, number>>;
+declare function fetchBalancesForMints(connection: Connection, owner: PublicKey, mints: string[]): Promise<Record<string, number>>;
+
+interface ExchangeBalancesResult {
+    exchangeBalances: Record<string, number>;
+    openOrdersBalances: Record<string, number>;
+    solBalances: Record<string, number>;
+    solOpenOrdersBalances: Record<string, number>;
+    openOrders: OpenOrder[];
+    perMarketBaseBalances: Record<string, number>;
+}
+declare function fetchExchangeBalances(connection: Connection, owner: PublicKey, markets: MatchedMarket[]): Promise<ExchangeBalancesResult>;
+
+interface BondPayment {
+    epoch: number;
+    amount: number;
+}
+interface RewardBreakdown {
+    epoch: number;
+    staking: number;
+    mev: number;
+    block: number;
+}
+interface TvlSnapshot {
+    date: string;
+    sol: number;
+}
+interface LockupMetrics {
+    depositCap: string;
+    depositCapSol: number;
+    tvl: string;
+    tvlSol: number;
+    totalRewards: string;
+    apy90d: string | null;
+    inflationRewards: string;
+    mevRewards: string;
+    blockRewards: string;
+    payments: BondPayment[];
+    rewardBreakdown: RewardBreakdown[];
+    tvlHistory: TvlSnapshot[];
+    hasChartData: boolean;
+    fetchedAt: number;
+}
+declare function fetchLockupMetrics(bondPubkey: string, opts?: {
+    includeChartData?: boolean;
+    supabaseClient?: SupabaseClient;
+}): Promise<LockupMetrics>;
+
+interface LiquidityCheck {
+    expectedFillPrice: number | null;
+    slippageBps: number;
+    totalAvailableSize: number;
+    isSufficientLiquidity: boolean;
+}
+/**
+ * Walk asks (sorted price ascending) to check buy-side liquidity.
+ * Returns weighted avg fill price and slippage vs best ask.
+ */
+declare function checkBuyLiquidity(asks: IndividualOrder[], orderSizeTokens: number): LiquidityCheck;
+/**
+ * Walk bids (sorted price descending) to check sell-side liquidity.
+ * Returns weighted avg fill price and slippage vs best bid.
+ */
+declare function checkSellLiquidity(bids: IndividualOrder[], orderSizeTokens: number): LiquidityCheck;
+
+/**
+ * Returns a UNIX-seconds "now" adjusted so that it aligns with the cluster's
+ * perceived epoch-start boundary. The Bonds program mints RT proportional to
+ * the remaining time window of the selected maturity; using a clock derived
+ * from `getEpochInfo().slotIndex` matches the on-chain program's view of time
+ * more closely than `Date.now()` on its own.
+ *
+ * Port of the `estNextEpochTs` calculation in pye-frontend-v2's
+ * `StakeAccountMigrateForm.tsx`.
+ */
+declare function fetchEpochSyncedNowTs(connection: Connection): Promise<number>;
+interface EstimateRtFromStakeParams {
+    /** Amount of SOL being deposited into the bond. */
+    amountSol: number;
+    /** Target maturity the deposit will issue into. */
+    maturity: Maturity;
+    /** UNIX seconds; should come from `fetchEpochSyncedNowTs` for best accuracy. */
+    nowTs: number;
+}
+/**
+ * Estimates how many RT tokens the Bonds program will mint to the user for a
+ * stake deposit of `amountSol` into the selected maturity.
+ *
+ * The Bonds program issues RT proportional to the remaining issuance window
+ * (RT represents claims on future rewards, so later depositors get less RT
+ * per SOL than earlier ones).
+ *
+ *   estimatedRt = amountSol * (maturityTs - nowTs) / (maturityTs - issuanceStartTs)
+ *
+ * Returns 0 if the maturity has already matured or the issuance window is
+ * invalid.
+ */
+declare function estimateRtFromStake({ amountSol, maturity, nowTs, }: EstimateRtFromStakeParams): number;
+
+interface ExecuteStakeDepositParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    bondPubkey: string;
+    principalTokenMint: string;
+    yieldTokenMint: string;
+    validatorVoteAccount: string;
+    amountSol: number;
+}
+interface ExecuteStakeDepositResult {
+    signature: string;
+}
+interface ExecuteStakeAccountDepositParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    bondPubkey: string;
+    principalTokenMint: string;
+    yieldTokenMint: string;
+    validatorVoteAccount: string;
+    stakeAccountPubkey: string;
+    amountSol: number;
+    stakeBalanceSol: number;
+}
+declare function executeStakeAccountDeposit({ connection, wallet, bondPubkey, principalTokenMint, yieldTokenMint, validatorVoteAccount, stakeAccountPubkey, amountSol, stakeBalanceSol, }: ExecuteStakeAccountDepositParams): Promise<ExecuteStakeDepositResult>;
+declare function executeStakeDeposit({ connection, wallet, bondPubkey, principalTokenMint, yieldTokenMint, validatorVoteAccount, amountSol, }: ExecuteStakeDepositParams): Promise<ExecuteStakeDepositResult>;
+
+interface ExecuteDepositAndSellParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    bondPubkey: string;
+    principalTokenMint: string;
+    yieldTokenMint: string;
+    validatorVoteAccount: string;
+    stakeAccountPubkey: string;
+    amountSol: number;
+    stakeBalanceSol: number;
+    marketPubkey: string;
+    /**
+     * Expected RT tokens the Bonds program will mint to the user for this
+     * deposit. The Bonds program mints RT proportional to remaining time in the
+     * issuance window, so this is always ≤ amountSol — compute with
+     * `estimateRtFromStake` using an epoch-synced `nowTs`.
+     */
+    rtAmountToSell: number;
+    minReceiveTokens: number;
+    /** Gross SOL out (pre-fee) used to size the Pye taker-fee transfer. */
+    expectedSolOut: number;
+    altPubkey: string;
+}
+interface ExecuteDepositAndSellResult {
+    signature: string;
+}
+/**
+ * Deposits a stake account into the Pye lockup and immediately sells the
+ * resulting RT tokens on Manifest — all in a single atomic transaction.
+ *
+ * Instruction order:
+ *   1. ComputeBudget (limit + price)
+ *   2. StakeProgram.split (only if partial deposit)
+ *   3. createATA: ownerPt, ownerYt (RT), feeWalletPt, feeWalletYt, wSOL, treasuryWsol
+ *   4. Bonds deposit → mints PT + RT into ownerPt / ownerYt
+ *   5. Manifest swapIx → sells RT for wSOL
+ *   6. transfer → Pye taker fee (wSOL) from owner's wsolAta to treasuryWsol
+ *   7. closeAccount → unwraps remaining wSOL to native SOL
+ */
+declare function executeDepositAndSell({ connection, wallet, bondPubkey, principalTokenMint, yieldTokenMint, validatorVoteAccount, stakeAccountPubkey, amountSol, stakeBalanceSol, marketPubkey, rtAmountToSell, minReceiveTokens, expectedSolOut, altPubkey, }: ExecuteDepositAndSellParams): Promise<ExecuteDepositAndSellResult>;
+
+interface ExecuteSwapParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    marketPubkey: string;
+    orderSizeTokens: number;
+    maxPayTokens: number;
+    slippageBps: number;
+}
+interface ExecuteSwapResult {
+    signature: string;
+}
+declare function executeSwap({ connection, wallet, marketPubkey, orderSizeTokens, maxPayTokens, slippageBps, }: ExecuteSwapParams): Promise<ExecuteSwapResult>;
+
+interface ExecuteRtSellParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    marketPubkey: string;
+    rtMint: string;
+    /**
+     * Amount of RT tokens to sell. This must match what the user actually holds
+     * in their RT ATA — for a fresh deposit, compute with `estimateRtFromStake`,
+     * not `amountSol`, since the Bonds program mints less than 1:1.
+     */
+    orderSizeTokens: number;
+    minReceiveTokens: number;
+    /** Gross SOL out (pre-fee) used to size the Pye taker-fee transfer. */
+    expectedSolOut: number;
+}
+interface ExecuteRtSellResult {
+    signature: string;
+}
+/**
+ * Sell RT tokens on a Manifest order book for SOL.
+ *
+ * Flow: RT (base) → swap → wSOL (quote) → unwrap to native SOL.
+ */
+declare function executeRtSell({ connection, wallet, marketPubkey, rtMint, orderSizeTokens, minReceiveTokens, expectedSolOut, }: ExecuteRtSellParams): Promise<ExecuteRtSellResult>;
+
+interface ExecuteLimitOrderParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    marketPubkey: string;
+    orderSizeTokens: number;
+    limitPrice: number;
+}
+interface ExecuteLimitOrderResult {
+    signature: string;
+    setupSignature?: string;
+}
+declare function executeLimitOrder({ connection, wallet, marketPubkey, orderSizeTokens, limitPrice, }: ExecuteLimitOrderParams): Promise<ExecuteLimitOrderResult>;
+
+interface ExecuteCancelOrderParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    marketPubkey: string;
+    sequenceNumber: string;
+}
+interface ExecuteCancelOrderResult {
+    signature: string;
+}
+declare function executeCancelOrder({ connection, wallet, marketPubkey, sequenceNumber, }: ExecuteCancelOrderParams): Promise<ExecuteCancelOrderResult>;
+
+interface ExecuteRedeemParams {
+    connection: Connection;
+    wallet: WalletContextState;
+    bondPubkey: string;
+    principalTokenMint: string;
+    yieldTokenMint: string;
+    ptAmountLamports: number;
+    rtAmountLamports: number;
+}
+interface ExecuteRedeemResult {
+    signature: string;
+}
+declare function executeRedeem({ connection, wallet, bondPubkey, principalTokenMint, yieldTokenMint, ptAmountLamports, rtAmountLamports, }: ExecuteRedeemParams): Promise<ExecuteRedeemResult>;
+
+export { type Bond, type BondPayment, type EstimateRtFromStakeParams, type ExchangeBalancesResult, type ExecuteCancelOrderParams, type ExecuteCancelOrderResult, type ExecuteDepositAndSellParams, type ExecuteDepositAndSellResult, type ExecuteLimitOrderParams, type ExecuteLimitOrderResult, type ExecuteRedeemParams, type ExecuteRedeemResult, type ExecuteRtSellParams, type ExecuteRtSellResult, type ExecuteStakeAccountDepositParams, type ExecuteStakeDepositParams, type ExecuteStakeDepositResult, type ExecuteSwapParams, type ExecuteSwapResult, IndividualOrder, type LiquidityCheck, type LockupMetrics, MatchedMarket, Maturity, MaturityId, OpenOrder, PYE_TRADING_FEE_BPS, PYE_TREASURY_WALLET, type PtLookupEntry, type PyeSDKConfig, type RewardBreakdown, type Token, type TokenId, type TvlSnapshot, UserStakeAccount, ValidatorId, allTokenAddresses, allowedLockups, applyTradingFee, buildPtLookup, calculateFeeLamports, checkBuyLiquidity, checkSellLiquidity, configurePyeSDK, estimateRtFromStake, executeCancelOrder, executeDepositAndSell, executeLimitOrder, executeRedeem, executeRtSell, executeStakeAccountDeposit, executeStakeDeposit, executeSwap, fetchBalances, fetchBalancesForMints, fetchEpochSyncedNowTs, fetchExchangeBalances, fetchLockupMetrics, fetchUserStakeAccounts, getPyeConfig, lockups, lookupBondByVoteAccount, tokenIdsArray, tokens };