@spield/sdk 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,783 @@
+import { rpc, xdr, Horizon } from '@stellar/stellar-sdk';
+
+type SpieldNetworkKey = 'testnet' | 'custom';
+type SpieldNetworkConfig = {
+    key: SpieldNetworkKey;
+    networkName: 'TESTNET' | string;
+    networkPassphrase: string;
+    rpcUrl: string;
+    horizonUrl: string;
+    explorerUrl: string;
+    contracts: {
+        /** Standardized Return share token over the strategy. */
+        sr: string;
+        /** Blend adapter behind SR. */
+        strategy: string;
+        /** PT/YT engine. This contract is also the custom SEP-41 YT token. */
+        yieldEngine: string;
+        /** PT/SR market. */
+        market: string;
+        /** Fixed-rate vault. */
+        vault: string;
+        /** One-transaction USDC routes. */
+        router: string;
+        /** Principal Token Stellar Asset Contract. */
+        pt: string;
+        usdc: string;
+    };
+    assets: {
+        /** The only trustline the protocol requires. YT is a contract token, not a classic asset. */
+        pt: {
+            code: string;
+            issuer: string;
+        };
+    };
+    decimals: number;
+};
+declare const STELLAR_NETWORK_PASSPHRASES: {
+    readonly PUBLIC: "Public Global Stellar Network ; September 2015";
+    readonly TESTNET: "Test SDF Network ; September 2015";
+};
+/**
+ * The live Spield Testnet deployment, tracking `deploy_sr_testnet.state` as of the
+ * **2026-08-30 redeploy**.
+ *
+ * That deployment carries the whole `FINAL_CHECK.md` round, and two of the fixes change behaviour
+ * an SDK consumer can observe:
+ *
+ * * **V2-01** — the market now prices every value-moving trade on a SYNCHRONIZED index
+ *   (`yieldEngine.py_index_current`). The `quote*` views still read the stored rate and can
+ *   therefore slightly OVER-state a sale, so size `minOut` from a simulation of the real entry
+ *   point rather than from a quote. See `USAGE.md`.
+ * * **V2-03** — the router no longer refuses to trade while a stray token balance rests on it, so
+ *   a stranger's dust can no longer deny every route.
+ *
+ * New read-only surface: `sr.realizableRate()`, `strategy.claimableEmissions()`.
+ */
+declare const testnet: () => SpieldNetworkConfig;
+declare const customNetwork: (config: SpieldNetworkConfig) => SpieldNetworkConfig;
+
+type SpieldSigner = {
+    getAddress(): Promise<string>;
+    signTransaction(xdr: string, opts: {
+        networkPassphrase: string;
+        address: string;
+    }): Promise<{
+        signedTxXdr: string;
+    }>;
+};
+type FreighterApi = {
+    getAddress?: () => Promise<{
+        address?: string;
+    } | string>;
+    signTransaction?: (xdr: string, opts: {
+        networkPassphrase: string;
+        address: string;
+    }) => Promise<{
+        signedTxXdr?: string;
+    } | string>;
+};
+declare class FreighterSigner implements SpieldSigner {
+    private readonly api?;
+    constructor(api?: FreighterApi | undefined);
+    private get freighter();
+    getAddress(): Promise<string>;
+    signTransaction(xdr: string, opts: {
+        networkPassphrase: string;
+        address: string;
+    }): Promise<{
+        signedTxXdr: string;
+    }>;
+}
+declare class ManualSigner implements SpieldSigner {
+    private readonly address;
+    private readonly sign;
+    constructor(address: string, sign: SpieldSigner['signTransaction']);
+    getAddress(): Promise<string>;
+    signTransaction(xdr: string, opts: {
+        networkPassphrase: string;
+        address: string;
+    }): Promise<{
+        signedTxXdr: string;
+    }>;
+}
+
+type SpieldClientOptions = {
+    network?: SpieldNetworkConfig;
+    signer?: SpieldSigner;
+    simulationSource?: string;
+    /** Maximum time to wait for Soroban RPC to index a submitted transaction. Defaults to 120 seconds. */
+    confirmationTimeoutMs?: number;
+    /** Delay between confirmation polls. Defaults to 1 second. */
+    confirmationPollIntervalMs?: number;
+};
+type CallOptions = {
+    signer?: SpieldSigner;
+};
+type TransactionResult = {
+    hash: string;
+    status: 'success';
+    explorerUrl: string;
+};
+type TokenSymbol = 'USDC' | 'PT' | 'YT' | string;
+type TokenAmount = {
+    raw: bigint;
+    formatted: string;
+    decimals: number;
+    symbol: TokenSymbol;
+};
+
+type SorobanContext = {
+    network: SpieldNetworkConfig;
+    signer?: SpieldSigner;
+    simulationSource: string;
+    confirmationTimeoutMs?: number;
+    confirmationPollIntervalMs?: number;
+};
+declare class SorobanClient {
+    private readonly context;
+    readonly server: rpc.Server;
+    constructor(context: SorobanContext);
+    read<T = unknown>(contractId: string, method: string, args?: xdr.ScVal[]): Promise<T>;
+    /**
+     * **Simulate a value-moving entry point AS `invoker`, and return what it would actually pay.**
+     *
+     * The `quote_*` views cannot synchronize SR — a view may not write — so they price on SR's stored
+     * high-water rate, which lags whenever nothing has synced since the last mutation. The real entry
+     * points *do* synchronize (`FINAL_CHECK.md` V2-01), so a quote can OVER-state a sale: derive
+     * `minOut` from it and the trade can trip its own slippage bound and revert.
+     *
+     * Simulating the real function runs the same synchronized code the submission will. Nothing is
+     * signed and nothing is sent.
+     *
+     * Unlike {@link read}, this simulates as the **user** rather than the shared simulation source,
+     * because the result depends on their balances.
+     *
+     * Returns `null` whenever the simulation cannot run — an unaffordable size, a route the pool
+     * cannot fill, a deployment predating the entry point — so callers fall back to the quote instead
+     * of failing the trade.
+     */
+    simulateAs(invoker: string, contractId: string, method: string, args?: xdr.ScVal[]): Promise<bigint | null>;
+    write(contractId: string, method: string, args?: xdr.ScVal[], signer?: SpieldSigner | undefined): Promise<TransactionResult>;
+    private waitForConfirmation;
+}
+
+type BlendStrategyRateBound = {
+    lastRate: bigint;
+    lastTimestamp: number;
+    maxAprBps: number;
+};
+type BlendStrategyState = {
+    currentRate: bigint;
+    totalShares: TokenAmount;
+    availableLiquidity: TokenAmount;
+    underlying: string;
+    pool: string;
+    rateBound: BlendStrategyRateBound;
+};
+/** Read client for the Blend adapter behind SR. */
+declare class BlendStrategyClient {
+    private readonly network;
+    private readonly soroban;
+    constructor(network: SpieldNetworkConfig, soroban: SorobanClient);
+    private get contract();
+    getAvailableLiquidity(): Promise<TokenAmount>;
+    /**
+     * **BLND accrued to the protocol and not yet claimed.**
+     *
+     * Measured on mainnet 2026-08-30: Blend allocates emissions to XLM *suppliers* and USDC
+     * *borrowers*, not USDC suppliers — which is the side Spield is on — so this reads `0` and has
+     * never been anything else. Allocations carry an expiration and rotate each cycle, so it will not
+     * necessarily stay zero.
+     *
+     * Claiming is permissionless and pays a destination fixed in contract storage, so an integrator
+     * can trigger it but can never redirect it.
+     */
+    getClaimableEmissions(): Promise<TokenAmount>;
+    /**
+     * **What the whole Blend position is really worth**, live rate, no monotonicity guard, no write.
+     * Unlike {@link getPositionValue} this keeps answering while a rate decrease has exits frozen.
+     */
+    getPositionValueUnguarded(): Promise<TokenAmount | null>;
+    getRateBound(): Promise<BlendStrategyRateBound>;
+    getPositionValue(input: {
+        shares: string | number | bigint;
+    }): Promise<TokenAmount>;
+    getState(): Promise<BlendStrategyState>;
+}
+
+declare const YT_MAX_IN_PAD_BPS = 300n;
+type SrMarketStats = {
+    ptReserve: TokenAmount;
+    srReserve: TokenAmount;
+    assetReserve: TokenAmount;
+    totalShares: TokenAmount;
+    ptPrice: bigint;
+    ptPriceNumber: number;
+    impliedApy: bigint;
+    impliedApyPct: number;
+    expiry: number;
+    expiryDate: Date;
+    treasuryEarned: TokenAmount;
+    treasuryFeeShareBps: number;
+    paused: boolean;
+};
+type SrMarketQuote = {
+    input: TokenAmount;
+    output: TokenAmount;
+    available: boolean;
+};
+type SrLpPosition = {
+    shares: TokenAmount;
+    ptClaim: TokenAmount;
+    srClaim: TokenAmount;
+};
+/** Client for the current PT/SR AMM and its YT routes. */
+declare class SrMarketClient {
+    private readonly network;
+    private readonly soroban;
+    private readonly signer?;
+    private latestLiquidityAbi;
+    constructor(network: SpieldNetworkConfig, soroban: SorobanClient, signer?: SpieldSigner | undefined);
+    private get contract();
+    getStats(): Promise<SrMarketStats>;
+    private quote;
+    quoteBuyPt(input: {
+        srIn: string | number | bigint;
+    }): Promise<SrMarketQuote>;
+    quoteSellPt(input: {
+        ptIn: string | number | bigint;
+    }): Promise<SrMarketQuote>;
+    quoteBuyYt(input: {
+        ytOut: string | number | bigint;
+    }): Promise<SrMarketQuote>;
+    quoteSellYt(input: {
+        ytIn: string | number | bigint;
+    }): Promise<SrMarketQuote>;
+    getLpPosition(input: {
+        owner: string;
+    }): Promise<SrLpPosition>;
+    buyPt(input: {
+        srIn: string | number | bigint;
+        minPtOut?: string | number | bigint;
+        deadlineLedger?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    sellPt(input: {
+        ptIn: string | number | bigint;
+        minSrOut?: string | number | bigint;
+        deadlineLedger?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    buyYt(input: {
+        ytOut: string | number | bigint;
+        maxSrIn?: string | number | bigint;
+        deadlineLedger?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    sellYt(input: {
+        ytIn: string | number | bigint;
+        minSrOut?: string | number | bigint;
+        deadlineLedger?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    addLiquidity(input: {
+        ptIn: string | number | bigint;
+        srIn: string | number | bigint;
+        /** Minimum LP shares accepted. Positive values opt into the new caller-controlled tolerance. */
+        minShares?: string | number | bigint;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    removeLiquidity(input: {
+        shares: string | number | bigint;
+        minPtOut?: string | number | bigint;
+        minSrOut?: string | number | bigint;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    /** Permissionless keep-alive for an LP share entry. */
+    bumpLp(input?: {
+        owner?: string;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    private supportsLatestLiquidityAbi;
+}
+
+declare const toBaseUnits: (amount: string | number | bigint, decimals?: number) => bigint;
+/** Parse an amount that may be zero, for slippage floors and optional minimum outputs. */
+declare const assertNonNegativeAmount: (amount: string | number | bigint, decimals?: number) => bigint;
+declare const fromBaseUnits: (units: bigint | number | string, decimals?: number) => string;
+declare const tokenAmount: (raw: bigint | number | string, symbol: TokenSymbol, decimals?: number) => TokenAmount;
+
+declare const SCALAR_12: bigint;
+/** Convert a 12-decimal fixed-point contract scalar (price, rate, APY) to a JS number. */
+declare const fromScalar12: (v: bigint) => number;
+type SrState = {
+    exchangeRate: bigint;
+    exchangeRateNumber: number;
+    totalSupply: TokenAmount;
+    totalAssets: TokenAmount;
+    maxRedeemable: TokenAmount | null;
+    depositCap: TokenAmount | null;
+    depositHeadroom: TokenAmount | null;
+    /** True when the configured TVL cap, rather than a pause, blocks every new deposit. */
+    depositCapReached: boolean;
+    paused: boolean;
+};
+/** Client for Spield's Standardized Return (SR) share token. */
+declare class StandardizedReturnClient {
+    private readonly network;
+    private readonly soroban;
+    private readonly signer?;
+    constructor(network: SpieldNetworkConfig, soroban: SorobanClient, signer?: SpieldSigner | undefined);
+    private get contract();
+    getExchangeRate(): Promise<bigint>;
+    /**
+     * **The honest twin of {@link getExchangeRate} — what a share is ACTUALLY worth.**
+     *
+     * `exchange_rate` is a high-water mark: it ratchets up and never falls. That stops the protocol
+     * repricing on a transient dip, but it means every value built on it — `previewRedeem`,
+     * `getAssetsOf` — reports MORE underlying than a redemption pays once Blend has taken a real loss.
+     *
+     * This reads the venue with no monotonicity guard, so unlike the guarded paths it keeps answering
+     * while exits are frozen — which is exactly when somebody needs the number.
+     *
+     * Returns `0n` on a deployment predating it. Sitting slightly ABOVE `exchange_rate` in normal
+     * operation is expected (it sees accrual the stored rate has not synced); only the other
+     * direction is interesting.
+     */
+    getRealizableRate(): Promise<bigint>;
+    /** A holder's actual pro-rata claim. See {@link getRealizableRate}. `null` if unavailable. */
+    getRealizableValue(input: {
+        shares: string | number | bigint;
+    }): Promise<TokenAmount | null>;
+    srToUnderlying(shares: bigint, rate: bigint): bigint;
+    underlyingToSr(amount: bigint, rate: bigint): bigint;
+    previewDeposit(input: {
+        amount: string | number | bigint;
+    }): Promise<TokenAmount>;
+    previewRedeem(input: {
+        shares: string | number | bigint;
+    }): Promise<TokenAmount>;
+    getBalance(input: {
+        owner: string;
+    }): Promise<TokenAmount>;
+    getAssetsOf(input: {
+        owner: string;
+    }): Promise<TokenAmount>;
+    getState(): Promise<SrState>;
+    deposit(input: {
+        amount: string | number | bigint;
+        receiver?: string;
+        minSharesOut?: string | number | bigint;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    redeem(input: {
+        shares: string | number | bigint;
+        receiver?: string;
+        minUnderlyingOut?: string | number | bigint;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    redeemPartial(input: {
+        shares: string | number | bigint;
+        receiver?: string;
+        minUnderlyingOut?: string | number | bigint;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    /** Permissionless update of SR's stored high-water exchange rate. */
+    syncRate(input?: {
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    /** Permissionless keep-alive for an SR holder's persistent balance entry. */
+    bumpHolder(input?: {
+        owner?: string;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+}
+
+/**
+ * PT is the protocol's only classic asset, so it is the only trustline a wallet needs.
+ * YT is a contract token issued by the yield engine and requires none.
+ */
+type PtTrustlineStatus = {
+    pt: boolean;
+    ready: boolean;
+};
+declare class HorizonClient {
+    private readonly network;
+    readonly horizon: Horizon.Server;
+    constructor(network: SpieldNetworkConfig);
+    getPtTrustline(address: string): Promise<PtTrustlineStatus>;
+    setupPtTrustline(address: string, signer?: SpieldSigner): Promise<TransactionResult | null>;
+}
+
+type SrTokenKey = 'USDC' | 'SR' | 'PT' | 'YT';
+declare class SrTokensClient {
+    private readonly network;
+    private readonly soroban;
+    private readonly horizon;
+    private readonly signer?;
+    constructor(network: SpieldNetworkConfig, soroban: SorobanClient, horizon: HorizonClient, signer?: SpieldSigner | undefined);
+    getBalance(input: {
+        token: SrTokenKey;
+        owner: string;
+    }): Promise<TokenAmount>;
+    getBalances(input: {
+        owner: string;
+    }): Promise<Record<'usdc' | 'sr' | 'pt' | 'yt', TokenAmount>>;
+    getPtTrustline(input: {
+        owner: string;
+    }): Promise<PtTrustlineStatus>;
+    /** Set up the sole v2 trustline. YT is a contract token and must not get a trustline. */
+    ensurePtTrustline(input?: {
+        owner?: string;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult | null>;
+}
+
+type SrFixedRateQuote = {
+    input: TokenAmount;
+    payout: TokenAmount;
+    coupon: TokenAmount;
+    rateBps: number;
+    ratePct: number;
+};
+type SrVaultStats = {
+    ptInventory: TokenAmount;
+    ytInventory: TokenAmount;
+    totalLiability: TokenAmount;
+    /** USDC banked for open receipts during resumable redemptions. */
+    totalCollected: TokenAmount;
+    couponCapacity: TokenAmount;
+    rateBps: number;
+    ratePct: number;
+    maturity: number;
+    maturityDate: Date;
+    openReceipts: number;
+    paused: boolean;
+};
+type SrVaultReceipt = {
+    receiptId: number;
+    owner: string;
+    principal: TokenAmount;
+    payout: TokenAmount;
+    rateBps: number;
+    ratePct: number;
+    maturity: number;
+    maturityDate: Date;
+    open: boolean;
+    /** USDC already secured for this receipt during an earlier partial redemption. */
+    collected: TokenAmount;
+    remaining: TokenAmount;
+};
+type SrVaultSurplus = {
+    sr: TokenAmount;
+    yt: TokenAmount;
+    usdc: TokenAmount;
+};
+/** Fixed-rate USDC vault backed by v2 bearer PT inventory. */
+declare class SrVaultClient {
+    private readonly network;
+    private readonly soroban;
+    private readonly signer?;
+    constructor(network: SpieldNetworkConfig, soroban: SorobanClient, signer?: SpieldSigner | undefined);
+    private get contract();
+    quoteFixedRate(input: {
+        amount: string | number | bigint;
+    }): Promise<SrFixedRateQuote>;
+    getStats(): Promise<SrVaultStats>;
+    getReceipt(input: {
+        receiptId: number;
+    }): Promise<SrVaultReceipt | null>;
+    getOwnerReceipts(input: {
+        owner: string;
+        maxScan?: number;
+    }): Promise<SrVaultReceipt[]>;
+    deposit(input: {
+        amount: string | number | bigint;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    redeemReceipt(input: {
+        receiptId: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    /** Remaining USDC owed before a receipt can close. Falls back to receipt data on the old ABI. */
+    getRedeemRemaining(input: {
+        receiptId: number;
+    }): Promise<TokenAmount>;
+    /** Read surplus SR, YT and USDC that the latest vault ABI can release after expiry. */
+    getSurplus(): Promise<SrVaultSurplus | null>;
+    /** Permissionless keep-alive for a long-dated vault receipt. */
+    bumpReceipt(input: {
+        receiptId: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    /** Permissionless claim and reinvestment of the vault's YT yield. */
+    harvest(input?: {
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    private assertReceiptId;
+}
+
+type UserInterest = {
+    index: bigint;
+    accrued: TokenAmount;
+    withdrawn: TokenAmount;
+};
+type YieldSolvency = {
+    held: TokenAmount;
+    needed: TokenAmount;
+    surplus: TokenAmount;
+    solvent: boolean;
+};
+type YieldState = YieldSolvency & {
+    totalPy: TokenAmount;
+    totalAccrued: TokenAmount;
+    pyIndex: bigint;
+    yieldFeeBps: number;
+    yieldFeePct: number;
+    expiry: number;
+    expiryDate: Date;
+    expired: boolean;
+    paused: boolean;
+};
+/** Client for the PT/YT engine. The engine contract itself is the YT token. */
+declare class YieldEngineClient {
+    private readonly network;
+    private readonly soroban;
+    private readonly signer?;
+    constructor(network: SpieldNetworkConfig, soroban: SorobanClient, signer?: SpieldSigner | undefined);
+    private get contract();
+    getYtBalance(input: {
+        owner: string;
+    }): Promise<TokenAmount>;
+    getClaimableInterest(input: {
+        owner: string;
+    }): Promise<TokenAmount>;
+    getInterest(input: {
+        owner: string;
+    }): Promise<UserInterest>;
+    getSolvency(): Promise<YieldSolvency>;
+    getState(): Promise<YieldState>;
+    mintPy(input: {
+        srIn: string | number | bigint;
+        receiver?: string;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    redeemPy(input: {
+        amount: string | number | bigint;
+        receiver?: string;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    claimYield(input?: {
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    transferYt(input: {
+        to: string;
+        amount: string | number | bigint;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    /** Permissionless expiry-index stamp; only succeeds at or after expiry. */
+    stampExpiryIndex(input?: {
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    /** Keep both a holder's YT balance and interest entries alive. Permissionless on the latest ABI. */
+    bumpHolder(input?: {
+        owner?: string;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+}
+
+type SrPortfolio = {
+    owner: string;
+    balances: Awaited<ReturnType<SrTokensClient['getBalances']>>;
+    srAsUsdc: ReturnType<typeof tokenAmount>;
+    claimableYield: ReturnType<typeof tokenAmount>;
+    claimableYieldAsUsdc: ReturnType<typeof tokenAmount>;
+    interest: UserInterest;
+    lpPosition: SrLpPosition;
+    fixedReceipts: SrVaultReceipt[];
+    hasPtTrustline: boolean;
+};
+declare class SrPortfolioClient {
+    private readonly tokens;
+    private readonly sr;
+    private readonly yieldEngine;
+    private readonly market;
+    private readonly vault;
+    private readonly decimals;
+    constructor(tokens: SrTokensClient, sr: StandardizedReturnClient, yieldEngine: YieldEngineClient, market: SrMarketClient, vault: SrVaultClient, decimals: number);
+    getPortfolio(input: {
+        owner: string;
+        maxReceiptScan?: number;
+    }): Promise<SrPortfolio>;
+}
+
+declare class SrProtocolClient {
+    private readonly sr;
+    private readonly strategy;
+    private readonly yieldEngine;
+    private readonly market;
+    private readonly vault;
+    constructor(sr: StandardizedReturnClient, strategy: BlendStrategyClient, yieldEngine: YieldEngineClient, market: SrMarketClient, vault: SrVaultClient);
+    getHealth(): Promise<{
+        sr: SrState;
+        strategy: BlendStrategyState;
+        yieldEngine: YieldSolvency & {
+            totalPy: TokenAmount;
+            totalAccrued: TokenAmount;
+            pyIndex: bigint;
+            yieldFeeBps: number;
+            yieldFeePct: number;
+            expiry: number;
+            expiryDate: Date;
+            expired: boolean;
+            paused: boolean;
+        };
+        market: SrMarketStats;
+        vault: SrVaultStats;
+    }>;
+    getSolvency(): Promise<YieldSolvency>;
+}
+
+declare const DEFAULT_ROUTER_SLIPPAGE_BPS = 100;
+/** One-transaction USDC routes that fit against the deployed Blend-backed stack. */
+declare class SrRouterClient {
+    private readonly network;
+    private readonly soroban;
+    private readonly signer?;
+    constructor(network: SpieldNetworkConfig, soroban: SorobanClient, signer?: SpieldSigner | undefined);
+    private get contract();
+    /**
+     * The basis for `minOut`: what the REAL entry point would pay, falling back to the quote.
+     *
+     * `FINAL_CHECK.md` V2-01 — the market synchronizes SR on every value-moving call, but `quote_*`
+     * is a view and cannot. A quote therefore lags, and for a sale it reports MORE than the trade
+     * will pay; sizing `minOut` from it can revert the trade on its own slippage bound.
+     *
+     * Simulation runs the same synchronized code path the submission runs, so its answer is the one
+     * that executes. It legitimately returns `null` (unaffordable size, unfillable route, older
+     * deployment) — in which case the quote is used exactly as before.
+     */
+    private executableBasis;
+    private quote;
+    quoteBuyPt(input: {
+        usdcIn: string | number | bigint;
+    }): Promise<TokenAmount>;
+    quoteBuyYt(input: {
+        ytOut: string | number | bigint;
+    }): Promise<TokenAmount>;
+    quoteSellPt(input: {
+        ptIn: string | number | bigint;
+    }): Promise<TokenAmount>;
+    quoteSellYt(input: {
+        ytIn: string | number | bigint;
+    }): Promise<TokenAmount>;
+    quoteRedeemPy(input: {
+        amount: string | number | bigint;
+    }): Promise<TokenAmount>;
+    quoteClaimYield(input: {
+        owner: string;
+    }): Promise<TokenAmount>;
+    buyPt(input: {
+        usdcIn: string | number | bigint;
+        minPtOut?: string | number | bigint;
+        slippageBps?: number;
+        deadlineLedger?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    sellPt(input: {
+        ptIn: string | number | bigint;
+        minUsdcOut?: string | number | bigint;
+        slippageBps?: number;
+        deadlineLedger?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    redeemPy(input: {
+        amount: string | number | bigint;
+        minUsdcOut?: string | number | bigint;
+        slippageBps?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+    claimYield(input?: {
+        minUsdcOut?: string | number | bigint;
+        slippageBps?: number;
+        signer?: SpieldSigner;
+    }): Promise<TransactionResult>;
+}
+
+type TwoStepTransactionResult = {
+    first?: TransactionResult;
+    second: TransactionResult;
+};
+/**
+ * The Spield protocol client. Every namespace targets the SR-based contracts:
+ * USDC wraps into SR, SR splits into PT + YT, and PT trades against SR on the market.
+ */
+declare class SpieldClient {
+    readonly network: SpieldNetworkConfig;
+    /** Wrap USDC into yield-bearing SR shares, and unwrap fully or partially. */
+    readonly sr: StandardizedReturnClient;
+    /** Blend rate guard, position value, and currently withdrawable liquidity. */
+    readonly strategy: BlendStrategyClient;
+    /** Mint/redeem PT + YT, read and claim interest, transfer YT. */
+    readonly yield: YieldEngineClient;
+    /** PT/SR quotes, PT and YT trades, liquidity. */
+    readonly market: SrMarketClient;
+    /** Fixed-rate quotes, receipts, deposit, redeem, harvest. */
+    readonly vault: SrVaultClient;
+    /** One-transaction USDC routes for PT, redemption, and yield claims. */
+    readonly router: SrRouterClient;
+    /** USDC/SR/PT/YT balances and the single required PT trustline. */
+    readonly tokens: SrTokensClient;
+    /** Wallet-wide balances, interest, LP position, and vault receipts. */
+    readonly portfolio: SrPortfolioClient;
+    /** Cross-contract health and yield-engine solvency. */
+    readonly protocol: SrProtocolClient;
+    private readonly signer?;
+    constructor(options?: SpieldClientOptions);
+    /** All-in USDC cost for an exact YT face amount, using the deployed two-step route. */
+    quoteBuyYtFromUsdc(input: {
+        ytOut: string | number | bigint;
+    }): Promise<TokenAmount>;
+    /**
+     * Live-safe YT purchase: wrap only the missing SR, then buy YT. The one-call router version exceeds
+     * the deployed Blend pool's Soroban budget, so this deliberately uses up to two signatures.
+     */
+    buyYtFromUsdc(input: {
+        ytOut: string | number | bigint;
+        signer?: SpieldSigner;
+        onProgress?: (step: 'wrap' | 'buy', index: number, total: number) => void;
+    }): Promise<TwoStepTransactionResult>;
+    /**
+     * Live-safe YT exit: sell to SR, then unwrap the actual proceeds. The combined router route no
+     * longer fits the deployed Blend-backed stack after the SR partial-exit/cap upgrade.
+     */
+    sellYtToUsdc(input: {
+        ytIn: string | number | bigint;
+        signer?: SpieldSigner;
+        onProgress?: (step: 'sell' | 'unwrap', index: number, total: number) => void;
+    }): Promise<TwoStepTransactionResult>;
+}
+
+declare class SpieldSdkError extends Error {
+    readonly code: string;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, code: string, cause?: unknown | undefined);
+}
+declare class SpieldValidationError extends SpieldSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SpieldSignerError extends SpieldSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SpieldRpcError extends SpieldSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SpieldContractError extends SpieldSdkError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SpieldConfigurationError extends SpieldSdkError {
+    constructor(message: string, cause?: unknown);
+}
+
+export { BlendStrategyClient, type BlendStrategyRateBound, type BlendStrategyState, type CallOptions, DEFAULT_ROUTER_SLIPPAGE_BPS, FreighterSigner, ManualSigner, type PtTrustlineStatus, SCALAR_12, STELLAR_NETWORK_PASSPHRASES, SpieldClient, type SpieldClientOptions, SpieldConfigurationError, SpieldContractError, type SpieldNetworkConfig, type SpieldNetworkKey, SpieldRpcError, SpieldSdkError, type SpieldSigner, SpieldSignerError, SpieldValidationError, type SrFixedRateQuote, type SrLpPosition, SrMarketClient, type SrMarketQuote, type SrMarketStats, type SrPortfolio, SrPortfolioClient, SrProtocolClient, SrRouterClient, type SrState, type SrTokenKey, SrTokensClient, SrVaultClient, type SrVaultReceipt, type SrVaultStats, type SrVaultSurplus, StandardizedReturnClient, type TokenAmount, type TokenSymbol, type TransactionResult, type TwoStepTransactionResult, type UserInterest, YT_MAX_IN_PAD_BPS, YieldEngineClient, type YieldSolvency, type YieldState, assertNonNegativeAmount, customNetwork, fromBaseUnits, fromScalar12, testnet, toBaseUnits, tokenAmount };