@0dotxyz/p0-ts-sdk 2.3.0-alpha.3 → 2.3.0-alpha.5

package/dist/vendor.d.ts

@@ -27206,11 +27206,11 @@ interface TitanSwapQuoteResult {
     timeTaken?: number;
 }
 declare function buildSwapQuoteResult(route: {
-    inAmount: number;
-    outAmount: number;
+    inAmount: number | bigint;
+    outAmount: number | bigint;
     slippageBps: number;
     platformFee?: {
-        amount: number;
+        amount: number | bigint;
         fee_bps: number;
     };
     contextSlot?: number;
@@ -27613,6 +27613,221 @@ interface ExponentStripContext {
     computeStrippedPtNative(syInNative: bigint): bigint;
 }
 
+/**
+ * Accounts required by `wrapper_merge` — the core instruction that merges PT **and**
+ * redeems the resulting SY into the underlying **base** token in one go (so the buy leg can
+ * swap a normal token, not the un-swappable SY). The 16 fixed accounts mirror the IDL's
+ * `WrapperMerge` struct (same vault-side fields as `merge`, minus the SY destination order);
+ * `remainingAccounts` is the assembled `[...redeem, ...cpi]` list and `redeemSyAccountsUntil`
+ * marks the boundary between them.
+ */
+interface ExponentWrapperMergeAccounts {
+    /** Position owner / signer (the marginfi account authority). */
+    owner: PublicKey;
+    /** Owner's SY token account (intermediate; the redeem consumes it). */
+    syAta: PublicKey;
+    /** The maturity vault address. */
+    vault: PublicKey;
+    /** `Vault.escrow_sy`. */
+    escrowSy: PublicKey;
+    /** Owner's YT token account (source; empty/0 after maturity). */
+    ytAta: PublicKey;
+    /** Owner's PT token account (source; holds the withdrawn PT). */
+    ptAta: PublicKey;
+    /** `Vault.mint_yt`. */
+    mintYt: PublicKey;
+    /** `Vault.mint_pt`. */
+    mintPt: PublicKey;
+    /** `Vault.authority`. */
+    authority: PublicKey;
+    /** `Vault.address_lookup_table`. */
+    addressLookupTable: PublicKey;
+    /** `Vault.yield_position` (the vault robot yield position). */
+    yieldPosition: PublicKey;
+    /** `Vault.sy_program`. */
+    syProgram: PublicKey;
+    /** SPL token program for the PT/YT/SY mints (defaults to classic Token). */
+    tokenProgram?: PublicKey;
+    /**
+     * Assembled SY-program remaining accounts: the flavor's `redeem_sy` accounts first
+     * (count = `redeemSyAccountsUntil`), then the vault's deduped `withdraw_sy ++ get_sy_state`
+     * CPI accounts. The redeem's first account is the owner and keeps its signer flag.
+     */
+    remainingAccounts: AccountMeta$1[];
+    /** Number of leading `remainingAccounts` that are the flavor redeem accounts. */
+    redeemSyAccountsUntil: number;
+}
+interface ResolveExponentWrapperMergeContextParams {
+    connection: Connection;
+    /** Position owner / signer (the marginfi account authority). */
+    owner: PublicKey;
+    /** The maturity vault, or… */
+    vault?: PublicKey;
+    /** …the `MarketTwo` address (its `vault` is read). One of `vault`/`market` is required. */
+    market?: PublicKey;
+    /**
+     * The flavor's underlying **base** token (e.g. bulkSOL). Required — it isn't on the
+     * vault; the caller supplies it (config). The redeem unwraps SY into this token.
+     */
+    baseMint: PublicKey;
+    /** Token program for the base mint (defaults to classic Token). */
+    baseTokenProgram?: PublicKey;
+    /** Token program for the PT/YT mints (Exponent uses classic Token). */
+    ptYtTokenProgram?: PublicKey;
+    /** Token program for the SY mint (may be token-2022). Defaults to classic Token. */
+    syTokenProgram?: PublicKey;
+}
+/**
+ * Resolved inputs for the roll's redeem leg: the `wrapper_merge` accounts, the SPL
+ * stake-pool refresh that must run before it (so the SY↔base rate is current), the base
+ * token the swap leg consumes, and a helper to size the redeemed base from the vault rates.
+ */
+interface ExponentWrapperMergeContext {
+    vaultAddress: PublicKey;
+    vault: ExponentVault;
+    wrapperMergeAccounts: ExponentWrapperMergeAccounts;
+    /**
+     * Instruction(s) the flavor requires *before* `wrapper_merge` (for an SPL-stake-pool LST
+     * like bulkSOL, the stake pool's `UpdateStakePoolBalance` refresh). Empty for flavors that
+     * need none.
+     */
+    preInstructions: TransactionInstruction[];
+    /** The vault's address lookup table — add it to the transaction's lookup tables. */
+    addressLookupTable: AddressLookupTableAccount;
+    /** The redeemed underlying base token (swap-leg input). */
+    baseToken: {
+        mint: PublicKey;
+        decimals: number;
+        tokenProgram: PublicKey;
+    };
+    /** ATAs the bundle touches and must create idempotently (sy, pt, yt, base). */
+    setupMints: {
+        mint: PublicKey;
+        tokenProgram: PublicKey;
+    }[];
+    /**
+     * Native base the wrapper yields for a native PT amount: `merge` gives
+     * `sy = floor(pt × sy_for_pt / pt_supply)`, then the redeem gives
+     * `base = floor(sy × sy_exchange_rate)`. Feed into the swap-engine input sizing.
+     */
+    computeRedeemedBaseNative(ptAmountNative: bigint): bigint;
+}
+
+/**
+ * The SY-program CPI account lists a CLMM `trade_pt` appends as remaining accounts.
+ * Order (from the SDK's `ixTradePt`): `getSyState` ++ `getPositionState` ++ `depositSy`
+ * ++ `withdrawSy`, then de-duplicated. Each is referenced by an index into the market's
+ * address lookup table.
+ */
+interface ExponentMarketThreeCpiAccounts {
+    getSyState: ExponentCpiInterfaceContext[];
+    getPositionState: ExponentCpiInterfaceContext[];
+    depositSy: ExponentCpiInterfaceContext[];
+    withdrawSy: ExponentCpiInterfaceContext[];
+}
+/** The subset of an Exponent `MarketThree` (CLMM) pool account that `trade_pt` needs. */
+interface ExponentMarketThree {
+    /** The pool's own address (`self_address` / the account key). */
+    selfAddress: PublicKey;
+    mintPt: PublicKey;
+    mintSy: PublicKey;
+    vault: PublicKey;
+    /** The single `ticks` account holding the pool's tick tree (not per-tick-array accounts). */
+    ticks: PublicKey;
+    /** Pool PT liquidity escrow (`token_pt_escrow`). */
+    tokenPtEscrow: PublicKey;
+    /** Pool SY liquidity escrow (`token_sy_escrow`). */
+    tokenSyEscrow: PublicKey;
+    /** SY account holding treasury fees (`token_fee_treasury_sy`). */
+    tokenFeeTreasurySy: PublicKey;
+    /** PT account holding treasury fees (`token_fee_treasury_pt`). */
+    tokenFeeTreasuryPt: PublicKey;
+    addressLookupTable: PublicKey;
+    syProgram: PublicKey;
+    statusFlags: number;
+    /** SY-program CPI account lists, referenced by ALT index. */
+    cpiAccounts: ExponentMarketThreeCpiAccounts;
+}
+/**
+ * `SwapDirection` arg of the CLMM `trade_pt` instruction (a `u8`). `SyToPt` buys PT with
+ * SY (the roll's buy leg); `PtToSy` sells PT for SY.
+ */
+declare enum ExponentSwapDirection {
+    PtToSy = 0,
+    SyToPt = 1
+}
+/**
+ * Accounts required by the CLMM `trade_pt`. The first 14 are the fixed
+ * `#[derive(Accounts)]` accounts; `remainingAccounts` are the SY-program CPI accounts
+ * (already resolved from the market ALT and de-duplicated).
+ */
+interface ExponentClmmTradePtAccounts {
+    /** Trader / signer (the marginfi account authority). */
+    trader: PublicKey;
+    /** The `MarketThree` (CLMM pool) address. */
+    market: PublicKey;
+    /** The pool's `ticks` account. */
+    ticks: PublicKey;
+    /** Trader's SY token account (source of the SY spent buying PT). */
+    tokenSyTrader: PublicKey;
+    /** Trader's PT token account (destination of the bought PT). */
+    tokenPtTrader: PublicKey;
+    /** `MarketThree.token_sy_escrow`. */
+    tokenSyEscrow: PublicKey;
+    /** `MarketThree.token_pt_escrow`. */
+    tokenPtEscrow: PublicKey;
+    /** `MarketThree.address_lookup_table`. */
+    addressLookupTable: PublicKey;
+    /** `MarketThree.sy_program`. */
+    syProgram: PublicKey;
+    /** `MarketThree.token_fee_treasury_sy`. */
+    tokenFeeTreasurySy: PublicKey;
+    /** `MarketThree.token_fee_treasury_pt`. */
+    tokenFeeTreasuryPt: PublicKey;
+    /** SPL token program for the PT/SY mints (defaults to the classic Token program). */
+    tokenProgram?: PublicKey;
+    /**
+     * SY-program CPI accounts (`getSyState` ++ `getPositionState` ++ `depositSy` ++
+     * `withdrawSy`, de-duplicated), pubkeys already resolved from the market ALT. Appended
+     * after the 14 fixed accounts.
+     */
+    remainingAccounts: AccountMeta$1[];
+}
+interface ResolveExponentClmmTradePtContextParams {
+    connection: Connection;
+    /** Trader / signer (the marginfi account authority). */
+    owner: PublicKey;
+    /** The successor maturity's `MarketThree` (CLMM pool) where the new PT trades. */
+    market: PublicKey;
+    /** Token program for the PT mint (Exponent uses the classic Token program). */
+    ptTokenProgram?: PublicKey;
+    /** Token program for the SY mint. Defaults to classic Token. */
+    syTokenProgram?: PublicKey;
+}
+/**
+ * Resolved inputs for a native CLMM `trade_pt` (SY → PT) on an Exponent `MarketThree`:
+ * the fully-resolved `trade_pt` accounts (including the ALT-derived SY-CPI remaining
+ * accounts), the market ALT to add to the transaction's lookup tables, and the SY/PT
+ * token info. Feed `tradePtAccounts` + `addressLookupTable` into the roll's buy leg.
+ */
+interface ExponentClmmTradePtContext {
+    marketAddress: PublicKey;
+    market: ExponentMarketThree;
+    tradePtAccounts: ExponentClmmTradePtAccounts;
+    /** The market's address lookup table account — must be carried by the transaction. */
+    addressLookupTable: AddressLookupTableAccount;
+    sy: {
+        mint: PublicKey;
+        decimals: number;
+        tokenProgram: PublicKey;
+    };
+    pt: {
+        mint: PublicKey;
+        decimals: number;
+        tokenProgram: PublicKey;
+    };
+}
+
 /**
  * Exponent Finance program IDs (mainnet), taken from the official SDK's
  * `@exponent-labs/exponent-sdk` `environment.js`.
@@ -28219,113 +28434,802 @@ declare const EXPONENT_CORE_IDL: {
         docs?: undefined;
     })[];
 };
-
-/**
- * Exponent's high-precision `Number` is a little-endian U256 (`[u64; 4]`) scaled by 1e12
- * (`precise_number::ONE`). See exponent-core `libraries/precise_number`.
- */
-declare const EXPONENT_NUMBER_DENOM: BigNumber;
-/** Convert a decoded Exponent `Number` (LE `[u64; 4]` U256) to a scaled BigNumber. */
-declare function exponentNumberToBigNumber(raw: unknown): BigNumber;
-/** Decode a raw `Vault` account buffer into {@link ExponentVault}. */
-declare function decodeExponentVault(data: Buffer): ExponentVault;
-/** Decode a `MarketTwo` account and return its `vault` address. */
-declare function decodeExponentMarketVault(data: Buffer): PublicKey;
-/** Decode a raw `MarketTwo` account buffer into {@link ExponentMarketTwo}. */
-declare function decodeExponentMarketTwo(data: Buffer): ExponentMarketTwo;
-/** Fetch + decode an Exponent `MarketTwo` account. */
-declare function fetchExponentMarketTwo(connection: Connection, market: PublicKey): Promise<ExponentMarketTwo>;
-/** Fetch + decode an Exponent `Vault` account. */
-declare function fetchExponentVault(connection: Connection, vault: PublicKey): Promise<ExponentVault>;
-/** Fetch a `MarketTwo` account and resolve + fetch its `Vault`. */
-declare function fetchExponentVaultFromMarket(connection: Connection, market: PublicKey): Promise<{
-    vault: PublicKey;
-    account: ExponentVault;
-}>;
-/** Read an SPL mint's decimals (classic + token-2022 share the offset-44 layout). */
-declare function getMintDecimals(connection: Connection, mint: PublicKey): Promise<number>;
-
-/** Derive the Anchor event-CPI authority PDA for the Exponent core program. */
-declare function deriveExponentEventAuthority(): PublicKey;
-
-/**
- * Resolve everything `makeRollPtTx` needs for an Exponent PT roll by decoding the maturity
- * `Vault` (every vault-side `merge` account is a `has_one` field on it), deriving the
- * owner's PT/YT/SY token accounts, and resolving the SY-program CPI remaining accounts
- * (`get_sy_state ++ withdraw_sy`) from the vault's address lookup table.
- */
-declare function resolveExponentMergeContext(params: ResolveExponentMergeContextParams): Promise<ExponentMergeContext>;
-/**
- * Resolve everything `makeRollPtTx` needs to buy the successor PT natively (SY → PT,
- * no unwrap, no external aggregator) by trading on the successor maturity's `MarketTwo`.
- *
- * Decodes the market, resolves the SY-program CPI accounts from the market's address
- * lookup table (every `CpiInterfaceContext` is an ALT index), and derives the owner's
- * SY/PT token accounts. The returned {@link ExponentTradePtContext.addressLookupTable}
- * must be added to the transaction's lookup tables.
- */
-declare function resolveExponentTradePtContext(params: ResolveExponentTradePtContextParams): Promise<ExponentTradePtContext>;
-/**
- * Resolve everything needed to `strip` SY → PT + YT on an Exponent vault (the buy leg that
- * *mints* the successor PT, unbounded by AMM depth). Decodes the vault, derives the owner's
- * SY/PT/YT token accounts, resolves the `deposit_sy` CPI remaining accounts from the vault's
- * address lookup table, and exposes the last-seen SY exchange rate for sizing the minted PT.
- */
-declare function resolveExponentStripContext(params: ResolveExponentStripContextParams): Promise<ExponentStripContext>;
-
-/**
- * Build the Exponent `merge(amount)` instruction — redeems `amount` PT (post-maturity,
- * 1:1, no AMM/slippage) into SY at `sySrcDstAta`.
- *
- * @param accounts resolved merge accounts (see {@link ExponentMergeAccounts})
- * @param amountNative PT amount to redeem, in native units (u64)
- */
-declare function makeExponentMergeIx(accounts: ExponentMergeAccounts, amountNative: bigint): TransactionInstruction;
-/**
- * Signed `trade_pt` args for **buying** PT with SY (the roll's buy leg).
- *
- * The program's convention is signed-from-the-trader's-perspective: a buy makes PT flow
- * *to* the trader (`net_trader_pt > 0`) and SY flow *away* (`sy_constraint < 0`, the most
- * negative SY balance change the trader will tolerate — i.e. the max SY spent).
- *
- * @param ptOutNative   exact PT the trader receives (native u64). Set to a conservative
- *                      floor; the trade gives exactly this many PT.
- * @param maxSyInNative max SY the trader is willing to spend (native u64).
- */
-declare function exponentBuyPtArgs({ ptOutNative, maxSyInNative, }: {
-    ptOutNative: bigint;
-    maxSyInNative: bigint;
-}): {
-    netTraderPt: bigint;
-    syConstraint: bigint;
-};
-/**
- * Build the Exponent `trade_pt(net_trader_pt, sy_constraint)` instruction — an
- * implied-APY AMM trade of SY ↔ PT on a `MarketTwo`. For a buy use {@link exponentBuyPtArgs}.
- *
- * Pricing PT reads the SY exchange rate on-chain, so `accounts.remainingAccounts` (the
- * flavor's SY-program CPI accounts, resolved from the market ALT) are appended after the
- * 12 fixed accounts, and the transaction must carry the market's address lookup table.
- *
- * @param accounts resolved trade accounts (see {@link ExponentTradePtAccounts})
- * @param args     signed `net_trader_pt` / `sy_constraint` (i64 LE)
- */
-declare function makeExponentTradePtIx(accounts: ExponentTradePtAccounts, args: {
-    netTraderPt: bigint;
-    syConstraint: bigint;
-}): TransactionInstruction;
 /**
- * Build the Exponent `strip(amount)` instruction — splits `amount` SY into PT + YT on an
- * active vault. The minted PT lands in `ptDst`, the YT in `ytDst`. Because PT is minted (not
- * swapped), this is the buy leg for rolling more PT than a thin AMM pool could provide.
- *
- * Pricing PT/YT reads the SY rate on-chain, so `accounts.remainingAccounts` (the flavor's
- * `deposit_sy` CPI accounts, resolved from the vault ALT) are appended after the 15 fixed
- * accounts, and the transaction must carry the vault's address lookup table.
- *
- * @param accounts resolved strip accounts (see {@link ExponentStripAccounts})
- * @param amountNative SY amount to strip, in native units (u64)
+ * Raw Exponent CLMM IDL (`@exponent-labs/exponent-clmm-idl`, program `XPC1MM…` /
+ * "MarketThree"). Used to Borsh-decode the `MarketThree` pool account; its `address`
+ * field is the live CLMM program id. The matured-PT roll buys the successor PT directly
+ * on this PT/SY CLMM via `trade_pt` (SY → PT), with no base round-trip or aggregator.
  */
-declare function makeExponentStripIx(accounts: ExponentStripAccounts, amountNative: bigint): TransactionInstruction;
+declare const EXPONENT_CLMM_IDL: {
+    address: string;
+    metadata: {
+        name: string;
+        version: string;
+        spec: string;
+        description: string;
+    };
+    instructions: ({
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        returns: {
+            defined: {
+                name: string;
+            };
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            docs?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            writable?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            docs?: undefined;
+        })[];
+        args: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: {
+                option: string;
+            };
+        })[];
+        returns: {
+            defined: {
+                name: string;
+            };
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: {
+                defined: {
+                    name: string;
+                };
+            };
+        }[];
+        returns?: undefined;
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer: boolean;
+        } | {
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+        })[];
+        args: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: {
+                option: string;
+            };
+        })[];
+        returns?: undefined;
+        docs?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            docs?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            writable?: undefined;
+            signer?: undefined;
+        })[];
+        args: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: {
+                defined: {
+                    name: string;
+                };
+            };
+        })[];
+        returns: {
+            defined: {
+                name: string;
+            };
+        };
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            docs?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            docs?: undefined;
+        })[];
+        args: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: {
+                defined: {
+                    name: string;
+                };
+                option?: undefined;
+            };
+        } | {
+            name: string;
+            type: {
+                option: string;
+                defined?: undefined;
+            };
+        })[];
+        returns: {
+            defined: {
+                name: string;
+            };
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            docs?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            writable?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            docs?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        returns: {
+            defined: {
+                name: string;
+            };
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            docs?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            docs?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        returns?: undefined;
+        docs?: undefined;
+    })[];
+    accounts: {
+        name: string;
+        discriminator: number[];
+    }[];
+    events: {
+        name: string;
+        discriminator: number[];
+    }[];
+    errors: {
+        code: number;
+        name: string;
+        msg: string;
+    }[];
+    types: ({
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    option: string;
+                    defined?: undefined;
+                };
+            } | {
+                name: string;
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                    option?: undefined;
+                };
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+        repr?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            variants: ({
+                name: string;
+                fields?: undefined;
+            } | {
+                name: string;
+                fields: string[];
+            })[];
+            fields?: undefined;
+        };
+        docs?: undefined;
+        repr?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                docs: string[];
+                type: string;
+            } | {
+                name: string;
+                type: string;
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    array: (string | number)[];
+                };
+                docs?: undefined;
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+        repr?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                docs: string[];
+                type: {
+                    vec: {
+                        defined: {
+                            name: string;
+                        };
+                        vec?: undefined;
+                    };
+                };
+            } | {
+                name: string;
+                docs: string[];
+                type: {
+                    vec: {
+                        vec: {
+                            defined: {
+                                name: string;
+                            };
+                        };
+                        defined?: undefined;
+                    };
+                };
+            })[];
+            variants?: undefined;
+        };
+        repr?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                docs: string[];
+                type: string;
+            } | {
+                name: string;
+                type: string;
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                };
+                docs?: undefined;
+            })[];
+            variants?: undefined;
+        };
+        repr?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            variants: ({
+                name: string;
+                fields: string[];
+            } | {
+                name: string;
+                fields: {
+                    name: string;
+                    type: {
+                        defined: {
+                            name: string;
+                        };
+                    };
+                }[];
+            } | {
+                name: string;
+                fields: {
+                    name: string;
+                    type: string;
+                }[];
+            })[];
+            fields?: undefined;
+        };
+        docs?: undefined;
+        repr?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        repr: {
+            kind: string;
+        };
+        type: {
+            kind: string;
+            fields: {
+                array: (string | number)[];
+            }[];
+            variants?: undefined;
+        };
+    } | {
+        name: string;
+        docs: string[];
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                docs: string[];
+                type: string;
+            } | {
+                name: string;
+                docs: string[];
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                };
+            } | {
+                name: string;
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                };
+                docs?: undefined;
+            })[];
+            variants?: undefined;
+        };
+        repr?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: {
+                name: string;
+                type: {
+                    vec: string;
+                };
+            }[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+        repr?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                docs: string[];
+                type: string;
+            } | {
+                name: string;
+                docs: string[];
+                type: {
+                    array: (string | number)[];
+                    defined?: undefined;
+                    vec?: undefined;
+                };
+            } | {
+                name: string;
+                docs: string[];
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                    array?: undefined;
+                    vec?: undefined;
+                };
+            } | {
+                name: string;
+                type: string;
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    vec: {
+                        defined: {
+                            name: string;
+                        };
+                    };
+                    array?: undefined;
+                    defined?: undefined;
+                };
+                docs?: undefined;
+            } | {
+                name: string;
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                    array?: undefined;
+                    vec?: undefined;
+                };
+                docs?: undefined;
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+        repr?: undefined;
+    })[];
+};
+
+/**
+ * Exponent's high-precision `Number` is a little-endian U256 (`[u64; 4]`) scaled by 1e12
+ * (`precise_number::ONE`). See exponent-core `libraries/precise_number`.
+ */
+declare const EXPONENT_NUMBER_DENOM: BigNumber;
+/** Convert a decoded Exponent `Number` (LE `[u64; 4]` U256) to a scaled BigNumber. */
+declare function exponentNumberToBigNumber(raw: unknown): BigNumber;
+/** Decode a raw `Vault` account buffer into {@link ExponentVault}. */
+declare function decodeExponentVault(data: Buffer): ExponentVault;
+/** Decode a `MarketTwo` account and return its `vault` address. */
+declare function decodeExponentMarketVault(data: Buffer): PublicKey;
+/** Decode a raw `MarketTwo` account buffer into {@link ExponentMarketTwo}. */
+declare function decodeExponentMarketTwo(data: Buffer): ExponentMarketTwo;
+/** Fetch + decode an Exponent `MarketTwo` account. */
+declare function fetchExponentMarketTwo(connection: Connection, market: PublicKey): Promise<ExponentMarketTwo>;
+/** Decode a raw `MarketThree` (CLMM) pool account buffer into {@link ExponentMarketThree}. */
+declare function decodeExponentMarketThree(data: Buffer): ExponentMarketThree;
+/** Fetch + decode an Exponent `MarketThree` (CLMM) pool account. */
+declare function fetchExponentMarketThree(connection: Connection, market: PublicKey): Promise<ExponentMarketThree>;
+/** Fetch + decode an Exponent `Vault` account. */
+declare function fetchExponentVault(connection: Connection, vault: PublicKey): Promise<ExponentVault>;
+/** Fetch a `MarketTwo` account and resolve + fetch its `Vault`. */
+declare function fetchExponentVaultFromMarket(connection: Connection, market: PublicKey): Promise<{
+    vault: PublicKey;
+    account: ExponentVault;
+}>;
+/** Read an SPL mint's decimals (classic + token-2022 share the offset-44 layout). */
+declare function getMintDecimals(connection: Connection, mint: PublicKey): Promise<number>;
+
+/** Derive the Anchor event-CPI authority PDA for the Exponent core program. */
+declare function deriveExponentEventAuthority(): PublicKey;
+/** Derive the Anchor event-CPI authority PDA for the Exponent CLMM (`MarketThree`) program. */
+declare function deriveExponentClmmEventAuthority(): PublicKey;
+
+/**
+ * Resolve everything `makeRollPtTx` needs for an Exponent PT roll by decoding the maturity
+ * `Vault` (every vault-side `merge` account is a `has_one` field on it), deriving the
+ * owner's PT/YT/SY token accounts, and resolving the SY-program CPI remaining accounts
+ * (`get_sy_state ++ withdraw_sy`) from the vault's address lookup table.
+ */
+declare function resolveExponentMergeContext(params: ResolveExponentMergeContextParams): Promise<ExponentMergeContext>;
+/**
+ * Resolve everything `makeRollPtTx` needs to buy the successor PT natively (SY → PT,
+ * no unwrap, no external aggregator) by trading on the successor maturity's `MarketTwo`.
+ *
+ * Decodes the market, resolves the SY-program CPI accounts from the market's address
+ * lookup table (every `CpiInterfaceContext` is an ALT index), and derives the owner's
+ * SY/PT token accounts. The returned {@link ExponentTradePtContext.addressLookupTable}
+ * must be added to the transaction's lookup tables.
+ */
+declare function resolveExponentTradePtContext(params: ResolveExponentTradePtContextParams): Promise<ExponentTradePtContext>;
+/**
+ * Resolve everything the roll needs to buy the successor PT natively on its **CLMM**
+ * (`MarketThree`) pool — SY → PT in one on-chain trade, no base unwrap and no external
+ * aggregator. The newer maturities (e.g. October bulkSOL) only list a CLMM PT/SY pool (no
+ * `MarketTwo`, no order book), so this is the direct buy leg.
+ *
+ * Decodes the pool, resolves its SY-program CPI accounts from the pool's address lookup
+ * table (each `CpiInterfaceContext` is an ALT index), de-duplicates them, and derives the
+ * owner's SY/PT token accounts. The returned {@link ExponentClmmTradePtContext.addressLookupTable}
+ * must be added to the transaction's lookup tables. The pool uses a single `ticks` account,
+ * so the resolved account set is fixed regardless of trade size.
+ */
+declare function resolveExponentClmmTradePtContext(params: ResolveExponentClmmTradePtContextParams): Promise<ExponentClmmTradePtContext>;
+/**
+ * Resolve everything needed to `strip` SY → PT + YT on an Exponent vault (the buy leg that
+ * *mints* the successor PT, unbounded by AMM depth). Decodes the vault, derives the owner's
+ * SY/PT/YT token accounts, resolves the `deposit_sy` CPI remaining accounts from the vault's
+ * address lookup table, and exposes the last-seen SY exchange rate for sizing the minted PT.
+ */
+declare function resolveExponentStripContext(params: ResolveExponentStripContextParams): Promise<ExponentStripContext>;
+/**
+ * Resolve everything the roll's redeem leg needs to turn matured PT into the underlying
+ * **base** token via `wrapper_merge` (merge PT → SY, then CPI-redeem SY → base, in one ix) —
+ * so the buy leg swaps a normal token, not the un-swappable SY.
+ *
+ * Decodes the maturity `Vault`, derives the owner's SY/PT/YT/base token accounts, assembles
+ * the flavor redeem accounts (all derivable: the generic SY state is `get_sy_state[0]`, the
+ * SPL stake pool is `get_sy_state[3]`, the base escrow is `ATA(syState, baseMint)`), appends
+ * the vault's `withdraw_sy ++ get_sy_state` CPI accounts, and builds the stake-pool refresh
+ * that must run first. Validated byte-for-byte against the Exponent SDK's `ixMergeToBase`.
+ */
+declare function resolveExponentWrapperMergeContext(params: ResolveExponentWrapperMergeContextParams): Promise<ExponentWrapperMergeContext>;
+
+/**
+ * Build the Exponent `merge(amount)` instruction — redeems `amount` PT (post-maturity,
+ * 1:1, no AMM/slippage) into SY at `sySrcDstAta`.
+ *
+ * @param accounts resolved merge accounts (see {@link ExponentMergeAccounts})
+ * @param amountNative PT amount to redeem, in native units (u64)
+ */
+declare function makeExponentMergeIx(accounts: ExponentMergeAccounts, amountNative: bigint): TransactionInstruction;
+/**
+ * Signed `trade_pt` args for **buying** PT with SY (the roll's buy leg).
+ *
+ * The program's convention is signed-from-the-trader's-perspective: a buy makes PT flow
+ * *to* the trader (`net_trader_pt > 0`) and SY flow *away* (`sy_constraint < 0`, the most
+ * negative SY balance change the trader will tolerate — i.e. the max SY spent).
+ *
+ * @param ptOutNative   exact PT the trader receives (native u64). Set to a conservative
+ *                      floor; the trade gives exactly this many PT.
+ * @param maxSyInNative max SY the trader is willing to spend (native u64).
+ */
+declare function exponentBuyPtArgs({ ptOutNative, maxSyInNative, }: {
+    ptOutNative: bigint;
+    maxSyInNative: bigint;
+}): {
+    netTraderPt: bigint;
+    syConstraint: bigint;
+};
+/**
+ * Build the Exponent `trade_pt(net_trader_pt, sy_constraint)` instruction — an
+ * implied-APY AMM trade of SY ↔ PT on a `MarketTwo`. For a buy use {@link exponentBuyPtArgs}.
+ *
+ * Pricing PT reads the SY exchange rate on-chain, so `accounts.remainingAccounts` (the
+ * flavor's SY-program CPI accounts, resolved from the market ALT) are appended after the
+ * 12 fixed accounts, and the transaction must carry the market's address lookup table.
+ *
+ * @param accounts resolved trade accounts (see {@link ExponentTradePtAccounts})
+ * @param args     signed `net_trader_pt` / `sy_constraint` (i64 LE)
+ */
+declare function makeExponentTradePtIx(accounts: ExponentTradePtAccounts, args: {
+    netTraderPt: bigint;
+    syConstraint: bigint;
+}): TransactionInstruction;
+/**
+ * Build the Exponent `strip(amount)` instruction — splits `amount` SY into PT + YT on an
+ * active vault. The minted PT lands in `ptDst`, the YT in `ytDst`. Because PT is minted (not
+ * swapped), this is the buy leg for rolling more PT than a thin AMM pool could provide.
+ *
+ * Pricing PT/YT reads the SY rate on-chain, so `accounts.remainingAccounts` (the flavor's
+ * `deposit_sy` CPI accounts, resolved from the vault ALT) are appended after the 15 fixed
+ * accounts, and the transaction must carry the vault's address lookup table.
+ *
+ * @param accounts resolved strip accounts (see {@link ExponentStripAccounts})
+ * @param amountNative SY amount to strip, in native units (u64)
+ */
+declare function makeExponentStripIx(accounts: ExponentStripAccounts, amountNative: bigint): TransactionInstruction;
+/**
+ * Build the Exponent `wrapper_merge(amount_py, redeem_sy_accounts_until)` instruction —
+ * redeems `amountPyNative` PT into the underlying base token at the owner's base ATA.
+ *
+ * The remaining accounts are `[...flavor redeem accounts, ...vault SY-CPI accounts]`;
+ * `redeemSyAccountsUntil` tells the program where the redeem accounts end. The redeem's first
+ * account is the owner and keeps its signer flag (the SY-CPI accounts are forced non-signer,
+ * resolved upstream). The transaction must carry the vault's address lookup table.
+ *
+ * @param accounts resolved wrapper-merge accounts (see {@link ExponentWrapperMergeAccounts})
+ * @param args     `amountPyNative` (u64) PT to redeem + `redeemSyAccountsUntil` (u8)
+ */
+declare function makeExponentWrapperMergeIx(accounts: ExponentWrapperMergeAccounts, args: {
+    amountPyNative: bigint;
+    redeemSyAccountsUntil: number;
+}): TransactionInstruction;
+/**
+ * Build the SPL Stake Pool `UpdateStakePoolBalance` instruction — refreshes a stake pool's
+ * total-lamports / pool-token-supply so the pool↔token exchange rate is current for the
+ * epoch. An SPL-stake-pool SY flavor (e.g. bulkSOL) requires this immediately before
+ * `wrapper_merge`, otherwise the redeem reads a stale SY↔base rate.
+ *
+ * Account order matches the SPL Stake Pool program's `UpdateStakePoolBalance`.
+ */
+declare function makeSplStakePoolUpdateBalanceIx(accounts: {
+    stakePoolProgram: PublicKey;
+    stakePool: PublicKey;
+    withdrawAuthority: PublicKey;
+    validatorList: PublicKey;
+    reserveStake: PublicKey;
+    managerFeeAccount: PublicKey;
+    poolMint: PublicKey;
+    tokenProgram?: PublicKey;
+}): TransactionInstruction;
+/**
+ * Signed `trade_pt` args for **buying** PT with SY on the CLMM (the roll's buy leg).
+ *
+ * `amountIn` is the exact SY spent; `swapDirection` is `SyToPt`; `amountOutConstraint` is
+ * the minimum PT out (slippage floor); `priceSpotLimit` (ln-implied-APY limit) is left unset.
+ *
+ * @param amountInSyNative SY to spend (native u64).
+ * @param minPtOutNative   minimum PT to receive (native u64) — the swap reverts below this.
+ */
+declare function exponentClmmBuyPtArgs({ amountInSyNative, minPtOutNative, }: {
+    amountInSyNative: bigint;
+    minPtOutNative: bigint;
+}): {
+    amountIn: bigint;
+    swapDirection: ExponentSwapDirection;
+    amountOutConstraint: bigint | null;
+    priceSpotLimit: null;
+};
+/**
+ * Build the CLMM `trade_pt(amount_in, swap_direction, amount_out_constraint, price_spot_limit)`
+ * instruction — an implied-APY AMM trade of SY ↔ PT on a `MarketThree` pool. For a buy use
+ * {@link exponentClmmBuyPtArgs}.
+ *
+ * Pricing PT reads the SY exchange rate on-chain, so `accounts.remainingAccounts` (the SY-CPI
+ * accounts resolved from the market ALT) are appended after the 14 fixed accounts, and the
+ * transaction must carry the market's address lookup table.
+ *
+ * @param accounts resolved trade accounts (see {@link ExponentClmmTradePtAccounts})
+ * @param args     `amountIn` (u64) + `swapDirection` (u8) + `amountOutConstraint` (Option<u64>)
+ *                 + `priceSpotLimit` (Option<f64>, always `null` here)
+ */
+declare function makeExponentClmmTradePtIx(accounts: ExponentClmmTradePtAccounts, args: {
+    amountIn: bigint;
+    swapDirection: ExponentSwapDirection;
+    amountOutConstraint: bigint | null;
+    priceSpotLimit: null;
+}): TransactionInstruction;
 
-export { ACCOUNT_SIZE, ACCOUNT_TYPE_SIZE, ASSOCIATED_TOKEN_PROGRAM_ID, type Account, AccountLayout, type AccountMeta, AccountState, AccountType, type ApproveInstructionData, type Base, type ClientRequest, type CloseAccountInstructionData, ConnectionClosed, CorpAction, CurvePointFields, DEFAULT_RECENT_SLOT_DURATION_MS, DRIFT_IDL, DRIFT_PROGRAM_ID, type DriftIdlType, type DriftInterestRateCurvePoint, DriftRewards, DriftRewardsJSON, DriftSpotBalanceType, DriftSpotMarket, DriftSpotMarketJSON, type DriftSpotMarketRaw, type DriftState, type DriftStateJSON, DriftUser, DriftUserJSON, type DriftUserRaw, DriftUserStats, DriftUserStatsJSON, EXPONENT_CLMM_PROGRAM_ID, EXPONENT_CORE_IDL, EXPONENT_CORE_PROGRAM_ID, EXPONENT_EVENT_AUTHORITY_SEED, EXPONENT_GENERIC_SY_PROGRAM_ID, EXPONENT_JITO_RESTAKING_SY_PROGRAM_ID, EXPONENT_KAMINO_SY_PROGRAM_ID, EXPONENT_MARGINFI_SY_PROGRAM_ID, EXPONENT_NUMBER_DENOM, EXPONENT_ORDERBOOK_PROGRAM_ID, EXPONENT_PERENA_SY_PROGRAM_ID, EXPONENT_VAULTS_PROGRAM_ID, type Ema, ErrorResponse, type ExponentCpiInterfaceContext, type ExponentMarketTwo, type ExponentMarketTwoCpiAccounts, type ExponentMergeAccounts, type ExponentMergeContext, type ExponentStripAccounts, type ExponentStripContext, type ExponentTradePtAccounts, type ExponentTradePtContext, type ExponentVault, ExtensionType, FARMS_PROGRAM_ID, FarmStateJSON, FarmStateRaw, FeeStructure, FeeStructureJSON, HistoricalIndexData, HistoricalOracleData, type InitializeAccountInstructionData, type Instruction, InsuranceFund, JUP_EXCHANGE_PRICES_PRECISION, JUP_LEND_IDL, JUP_LEND_PROGRAM_ID, JUP_LIQUIDITY_IDL, JUP_LIQUIDITY_PROGRAM_ID, JUP_MAX_REWARDS_RATE, JUP_REWARDS_PROGRAM_ID, JUP_SECONDS_PER_YEAR, type JupLendIdlType, type JupLendInterestRateCurvePoint, type JupLendRewardsResult, JupLendingRewardsRateModel, JupLendingRewardsRateModelJSON, type JupLendingRewardsRateModelRaw, JupLendingState, JupLendingStateJSON, type JupLendingStateRaw, type JupLiquidityIdlType, JupRateModel, JupRateModelJSON, type JupRateModelRaw, JupTokenReserve, JupTokenReserveJSON, type JupTokenReserveRaw, KFARMS_IDL, KLEND_ACCOUNT_CODER, KLEND_IDL, KLEND_PROGRAM_ID, type KaminoReserveCurveData, type KfarmsIdlType, type KlendIdlType, type KlendInterestRateCurvePoint, LENGTH_SIZE, MAX_SLOT_DIFFERENCE, MEMO_PROGRAM_ID, MINT_SIZE, MULTISIG_SIZE, type Mint, MintLayout, type Multisig, MultisigLayout, NATIVE_MINT, ONE, ONE_HUNDRED_PCT_IN_BPS, ONE_YEAR, ObligationJSON, ObligationRaw, OracleGuardRails, OracleGuardRailsJSON, PERCENTAGE_PRECISION, PERCENTAGE_PRECISION_EXP, type PlatformFee, PoolBalance, type Price, type PriceComponent, type PriceData, PriceStatus, PriceType, type Pubkey, type QuoteSwapStreamResponse, type QuoteUpdateParams, REFRESH_OBLIGATION_DISCRIMINATOR, type RawAccount, type RawMint, type RawMultisig, type RefreshObligationAccounts, type RequestData, ReserveJSON, ReserveRaw, type ResolveExponentMergeContextParams, type ResolveExponentStripContextParams, type ResolveExponentTradePtContextParams, type ResponseData, type ResponseError, type ResponseSuccess, type ResponseWithStream, RewardInfoFields, type RoutePlanStep, SEED_BASE_REFERRER_STATE, SEED_BASE_REFERRER_TOKEN_STATE, SEED_BASE_SHORT_URL, SEED_BASE_USER_METADATA, SEED_DRIFT_SIGNER, SEED_DRIFT_STATE, SEED_FEE_RECEIVER, SEED_F_TOKEN_MINT, SEED_LENDING, SEED_LENDING_ADMIN, SEED_LENDING_MARKET_AUTH, SEED_LENDING_REWARDS_RATE_MODEL, SEED_LIQUIDITY, SEED_RATE_MODEL, SEED_RESERVE, SEED_RESERVE_COLL_MINT, SEED_RESERVE_COLL_SUPPLY, SEED_RESERVE_LIQ_SUPPLY, SEED_SPOT_MARKET, SEED_SPOT_MARKET_VAULT, SEED_USER, SEED_USER_CLAIM, SEED_USER_STATE, SEED_USER_STATS, SEED_USER_SUPPLY_POSITION, SLOTS_PER_DAY, SLOTS_PER_HOUR, SLOTS_PER_MINUTE, SLOTS_PER_SECOND, SLOTS_PER_YEAR, SPOT_MARKET_RATE_PRECISION, SPOT_MARKET_RATE_PRECISION_EXP, SPOT_MARKET_UTILIZATION_PRECISION, SPOT_MARKET_UTILIZATION_PRECISION_EXP, type SerializedInstruction, type SerializedSwapRoute, type ServerMessage, SinglePoolInstruction, SplAccountType, SpotPosition, type StakeAccount, type StopStreamRequest, type StopStreamResponse, type StreamData, type StreamDataPayload, type StreamEnd, StreamError, type StreamStart, SwapMode, type SwapParams, type SwapQuoteRequest, type SwapQuotes, type SwapRoute, SwapVersion, type SyncNativeInstructionData, TEN, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, TYPE_SIZE, type TitanGatewayQuoteParams, type TitanGatewayQuoteResponse, type TitanProxyExactOutResponse, type TitanProxySwapQuoteResponse, type TitanSwapQuoteResult, type TitanTemplateLut, type TitanTransactionTemplate, TokenAccountNotFoundError, TokenError, TokenInstruction, TokenInvalidAccountError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, TokenInvalidInstructionDataError, TokenInvalidInstructionKeysError, TokenInvalidInstructionProgramError, TokenInvalidInstructionTypeError, TokenInvalidMintError, TokenInvalidOwnerError, TokenOwnerOffCurveError, TokenUnsupportedInstructionError, type TransactionParams, type TransactionTemplate, type TransactionTemplateLut, type TransferCheckedInstructionData, type Uint64, V1Client, ZERO, addSigners, approveInstructionData, buildSwapQuoteResult, buildTitanTemplate, calculateAPYFromAPR, calculateDriftBorrowAPR, calculateDriftBorrowAPY, calculateDriftBorrowRate, calculateDriftDepositRate, calculateDriftInterestRate, calculateDriftLendingAPR, calculateDriftLendingAPY, calculateDriftUtilization, calculateJupLendBorrowRate, calculateJupLendLiquiditySupplyRate, calculateJupLendNewExchangePrice, calculateJupLendRewardsRate, calculateJupLendRewardsRateForExchangePrice, calculateJupLendSupplyAPY, calculateJupLendSupplyRate, calculateJupLendTotalAssets, calculateKaminoEstimatedBorrowRate, calculateKaminoEstimatedSupplyRate, calculateKaminoSupplyAPY, calculateRewardApy, calculateSlotAdjustmentFactor, calculateUtilizationRatio, closeAccountInstructionData, createAccountIx, createApproveInstruction, createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction, createCloseAccountInstruction, createInitializeAccountInstruction, createMemoInstruction, createPoolOnrampIx, createSyncNativeInstruction, createTransferCheckedInstruction, decodeDriftSpotMarketData, decodeDriftStateData, decodeDriftUserData, decodeDriftUserStatsData, decodeExponentMarketTwo, decodeExponentMarketVault, decodeExponentVault, decodeFarmDataRaw, decodeJupLendingRewardsRateModelData, decodeJupLendingStateData, decodeJupRateModelData, decodeJupTokenReserveData, decodeKlendObligationData, decodeKlendReserveData, deriveBaseObligation, deriveDriftSigner, deriveDriftSpotMarket, deriveDriftSpotMarketVault, deriveDriftState, deriveDriftUser, deriveDriftUserStats, deriveExponentEventAuthority, deriveFeeReceiver, deriveJupLendClaimAccount, deriveJupLendFTokenMint, deriveJupLendLending, deriveJupLendLendingAdmin, deriveJupLendLendingPdas, deriveJupLendLendingRewardsRateModel, deriveJupLendLiquidity, deriveJupLendLiquiditySupplyPositionPda, deriveJupLendLiquidityVaultAta, deriveJupLendRateModel, deriveJupLendTokenReserve, deriveLendingMarketAuthority, deriveObligation, deriveReferrerState, deriveReferrerTokenState, deriveReserveCollateralMint, deriveReserveCollateralSupply, deriveReserveLiquiditySupply, deriveShortUrl, deriveUserMetadata, deriveUserState, deserializeSerializedInstruction, deserializeTitanWireInstruction, driftRewardsRawToDto, driftSpotMarketRawToDto, driftStateRawToDto, driftUserRawToDto, driftUserStatsRawToDto, dtoToDriftRewardsRaw, dtoToDriftSpotMarketRaw, dtoToDriftStateRaw, dtoToDriftUserRaw, dtoToDriftUserStatsRaw, dtoToFarmRaw, dtoToJupLendingRewardsRateModelRaw, dtoToJupLendingStateRaw, dtoToJupRateModelRaw, dtoToJupTokenReserveRaw, dtoToObligationRaw, dtoToReserveRaw, encodeTitanTemplate, exponentBuyPtArgs, exponentNumberToBigNumber, farmRawToDto, fetchExponentMarketTwo, fetchExponentVault, fetchExponentVaultFromMarket, fetchTitanQuoteSwapV3, findMplMetadataAddress, findPoolAddress, findPoolMintAddress, findPoolMintAddressByVoteAccount, findPoolMintAuthorityAddress, findPoolMplAuthorityAddress, findPoolOnRampAddress, findPoolStakeAddress, findPoolStakeAuthorityAddress, generateDriftReserveCurve, generateJupLendSupplyCurve, generateKaminoReserveCurve, getAccount, getAccountLen, getAllDerivedDriftAccounts, getAllDerivedJupLendAccounts, getAllDerivedKaminoAccounts, getAllRequiredMarkets, getAssociatedTokenAddressSync, getDriftRewards, getDriftTokenAmount, getFixedHostInterestRate, getJupLendRewards, getKaminoBorrowRate, getKaminoTotalSupply, getMinimumBalanceForRentExemptAccount, getMinimumBalanceForRentExemptAccountWithExtensions, getMint, getMintDecimals, getMultipleAccounts, getProtocolTakeRatePct, getReserveRewardsApy, getRewardPerTimeUnitSecond, getStakeAccount, initializeAccountInstructionData, initializeStakedPoolIxs, initializeStakedPoolTx, instructionToTitanWire, interpolateLinear, jupLendingRewardsRateModelRawToDto, jupLendingStateRawToDto, jupRateModelRawToDto, jupTokenReserveRawToDto, layout, lutToTitanWire, makeExponentMergeIx, makeExponentStripIx, makeExponentTradePtIx, makeRefreshObligationIx, makeRefreshReservesBatchIx, makeRefreshingIxs, makeUpdateJupLendRate, makeUpdateJupLendRateIx, makeUpdateSpotMarketCumulativeInterestIx, makeUpdateSpotMarketIx, obligationRawToDto, parsePriceData, parsePriceInfo, replenishPoolIx, reserveRawToDto, resolveExponentMergeContext, resolveExponentStripContext, resolveExponentTradePtContext, resolveLookupTables, scaledSupplies, selectBestRoute, selectGatewayRoute, slotAdjustmentFactor, syncNativeInstructionData, transferCheckedInstructionData, truncateBorrowCurve, unpackAccount };
+export { ACCOUNT_SIZE, ACCOUNT_TYPE_SIZE, ASSOCIATED_TOKEN_PROGRAM_ID, type Account, AccountLayout, type AccountMeta, AccountState, AccountType, type ApproveInstructionData, type Base, type ClientRequest, type CloseAccountInstructionData, ConnectionClosed, CorpAction, CurvePointFields, DEFAULT_RECENT_SLOT_DURATION_MS, DRIFT_IDL, DRIFT_PROGRAM_ID, type DriftIdlType, type DriftInterestRateCurvePoint, DriftRewards, DriftRewardsJSON, DriftSpotBalanceType, DriftSpotMarket, DriftSpotMarketJSON, type DriftSpotMarketRaw, type DriftState, type DriftStateJSON, DriftUser, DriftUserJSON, type DriftUserRaw, DriftUserStats, DriftUserStatsJSON, EXPONENT_CLMM_IDL, EXPONENT_CLMM_PROGRAM_ID, EXPONENT_CORE_IDL, EXPONENT_CORE_PROGRAM_ID, EXPONENT_EVENT_AUTHORITY_SEED, EXPONENT_GENERIC_SY_PROGRAM_ID, EXPONENT_JITO_RESTAKING_SY_PROGRAM_ID, EXPONENT_KAMINO_SY_PROGRAM_ID, EXPONENT_MARGINFI_SY_PROGRAM_ID, EXPONENT_NUMBER_DENOM, EXPONENT_ORDERBOOK_PROGRAM_ID, EXPONENT_PERENA_SY_PROGRAM_ID, EXPONENT_VAULTS_PROGRAM_ID, type Ema, ErrorResponse, type ExponentClmmTradePtAccounts, type ExponentClmmTradePtContext, type ExponentCpiInterfaceContext, type ExponentMarketThree, type ExponentMarketThreeCpiAccounts, type ExponentMarketTwo, type ExponentMarketTwoCpiAccounts, type ExponentMergeAccounts, type ExponentMergeContext, type ExponentStripAccounts, type ExponentStripContext, ExponentSwapDirection, type ExponentTradePtAccounts, type ExponentTradePtContext, type ExponentVault, type ExponentWrapperMergeAccounts, type ExponentWrapperMergeContext, ExtensionType, FARMS_PROGRAM_ID, FarmStateJSON, FarmStateRaw, FeeStructure, FeeStructureJSON, HistoricalIndexData, HistoricalOracleData, type InitializeAccountInstructionData, type Instruction, InsuranceFund, JUP_EXCHANGE_PRICES_PRECISION, JUP_LEND_IDL, JUP_LEND_PROGRAM_ID, JUP_LIQUIDITY_IDL, JUP_LIQUIDITY_PROGRAM_ID, JUP_MAX_REWARDS_RATE, JUP_REWARDS_PROGRAM_ID, JUP_SECONDS_PER_YEAR, type JupLendIdlType, type JupLendInterestRateCurvePoint, type JupLendRewardsResult, JupLendingRewardsRateModel, JupLendingRewardsRateModelJSON, type JupLendingRewardsRateModelRaw, JupLendingState, JupLendingStateJSON, type JupLendingStateRaw, type JupLiquidityIdlType, JupRateModel, JupRateModelJSON, type JupRateModelRaw, JupTokenReserve, JupTokenReserveJSON, type JupTokenReserveRaw, KFARMS_IDL, KLEND_ACCOUNT_CODER, KLEND_IDL, KLEND_PROGRAM_ID, type KaminoReserveCurveData, type KfarmsIdlType, type KlendIdlType, type KlendInterestRateCurvePoint, LENGTH_SIZE, MAX_SLOT_DIFFERENCE, MEMO_PROGRAM_ID, MINT_SIZE, MULTISIG_SIZE, type Mint, MintLayout, type Multisig, MultisigLayout, NATIVE_MINT, ONE, ONE_HUNDRED_PCT_IN_BPS, ONE_YEAR, ObligationJSON, ObligationRaw, OracleGuardRails, OracleGuardRailsJSON, PERCENTAGE_PRECISION, PERCENTAGE_PRECISION_EXP, type PlatformFee, PoolBalance, type Price, type PriceComponent, type PriceData, PriceStatus, PriceType, type Pubkey, type QuoteSwapStreamResponse, type QuoteUpdateParams, REFRESH_OBLIGATION_DISCRIMINATOR, type RawAccount, type RawMint, type RawMultisig, type RefreshObligationAccounts, type RequestData, ReserveJSON, ReserveRaw, type ResolveExponentClmmTradePtContextParams, type ResolveExponentMergeContextParams, type ResolveExponentStripContextParams, type ResolveExponentTradePtContextParams, type ResolveExponentWrapperMergeContextParams, type ResponseData, type ResponseError, type ResponseSuccess, type ResponseWithStream, RewardInfoFields, type RoutePlanStep, SEED_BASE_REFERRER_STATE, SEED_BASE_REFERRER_TOKEN_STATE, SEED_BASE_SHORT_URL, SEED_BASE_USER_METADATA, SEED_DRIFT_SIGNER, SEED_DRIFT_STATE, SEED_FEE_RECEIVER, SEED_F_TOKEN_MINT, SEED_LENDING, SEED_LENDING_ADMIN, SEED_LENDING_MARKET_AUTH, SEED_LENDING_REWARDS_RATE_MODEL, SEED_LIQUIDITY, SEED_RATE_MODEL, SEED_RESERVE, SEED_RESERVE_COLL_MINT, SEED_RESERVE_COLL_SUPPLY, SEED_RESERVE_LIQ_SUPPLY, SEED_SPOT_MARKET, SEED_SPOT_MARKET_VAULT, SEED_USER, SEED_USER_CLAIM, SEED_USER_STATE, SEED_USER_STATS, SEED_USER_SUPPLY_POSITION, SLOTS_PER_DAY, SLOTS_PER_HOUR, SLOTS_PER_MINUTE, SLOTS_PER_SECOND, SLOTS_PER_YEAR, SPOT_MARKET_RATE_PRECISION, SPOT_MARKET_RATE_PRECISION_EXP, SPOT_MARKET_UTILIZATION_PRECISION, SPOT_MARKET_UTILIZATION_PRECISION_EXP, type SerializedInstruction, type SerializedSwapRoute, type ServerMessage, SinglePoolInstruction, SplAccountType, SpotPosition, type StakeAccount, type StopStreamRequest, type StopStreamResponse, type StreamData, type StreamDataPayload, type StreamEnd, StreamError, type StreamStart, SwapMode, type SwapParams, type SwapQuoteRequest, type SwapQuotes, type SwapRoute, SwapVersion, type SyncNativeInstructionData, TEN, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, TYPE_SIZE, type TitanGatewayQuoteParams, type TitanGatewayQuoteResponse, type TitanProxyExactOutResponse, type TitanProxySwapQuoteResponse, type TitanSwapQuoteResult, type TitanTemplateLut, type TitanTransactionTemplate, TokenAccountNotFoundError, TokenError, TokenInstruction, TokenInvalidAccountError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, TokenInvalidInstructionDataError, TokenInvalidInstructionKeysError, TokenInvalidInstructionProgramError, TokenInvalidInstructionTypeError, TokenInvalidMintError, TokenInvalidOwnerError, TokenOwnerOffCurveError, TokenUnsupportedInstructionError, type TransactionParams, type TransactionTemplate, type TransactionTemplateLut, type TransferCheckedInstructionData, type Uint64, V1Client, ZERO, addSigners, approveInstructionData, buildSwapQuoteResult, buildTitanTemplate, calculateAPYFromAPR, calculateDriftBorrowAPR, calculateDriftBorrowAPY, calculateDriftBorrowRate, calculateDriftDepositRate, calculateDriftInterestRate, calculateDriftLendingAPR, calculateDriftLendingAPY, calculateDriftUtilization, calculateJupLendBorrowRate, calculateJupLendLiquiditySupplyRate, calculateJupLendNewExchangePrice, calculateJupLendRewardsRate, calculateJupLendRewardsRateForExchangePrice, calculateJupLendSupplyAPY, calculateJupLendSupplyRate, calculateJupLendTotalAssets, calculateKaminoEstimatedBorrowRate, calculateKaminoEstimatedSupplyRate, calculateKaminoSupplyAPY, calculateRewardApy, calculateSlotAdjustmentFactor, calculateUtilizationRatio, closeAccountInstructionData, createAccountIx, createApproveInstruction, createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction, createCloseAccountInstruction, createInitializeAccountInstruction, createMemoInstruction, createPoolOnrampIx, createSyncNativeInstruction, createTransferCheckedInstruction, decodeDriftSpotMarketData, decodeDriftStateData, decodeDriftUserData, decodeDriftUserStatsData, decodeExponentMarketThree, decodeExponentMarketTwo, decodeExponentMarketVault, decodeExponentVault, decodeFarmDataRaw, decodeJupLendingRewardsRateModelData, decodeJupLendingStateData, decodeJupRateModelData, decodeJupTokenReserveData, decodeKlendObligationData, decodeKlendReserveData, deriveBaseObligation, deriveDriftSigner, deriveDriftSpotMarket, deriveDriftSpotMarketVault, deriveDriftState, deriveDriftUser, deriveDriftUserStats, deriveExponentClmmEventAuthority, deriveExponentEventAuthority, deriveFeeReceiver, deriveJupLendClaimAccount, deriveJupLendFTokenMint, deriveJupLendLending, deriveJupLendLendingAdmin, deriveJupLendLendingPdas, deriveJupLendLendingRewardsRateModel, deriveJupLendLiquidity, deriveJupLendLiquiditySupplyPositionPda, deriveJupLendLiquidityVaultAta, deriveJupLendRateModel, deriveJupLendTokenReserve, deriveLendingMarketAuthority, deriveObligation, deriveReferrerState, deriveReferrerTokenState, deriveReserveCollateralMint, deriveReserveCollateralSupply, deriveReserveLiquiditySupply, deriveShortUrl, deriveUserMetadata, deriveUserState, deserializeSerializedInstruction, deserializeTitanWireInstruction, driftRewardsRawToDto, driftSpotMarketRawToDto, driftStateRawToDto, driftUserRawToDto, driftUserStatsRawToDto, dtoToDriftRewardsRaw, dtoToDriftSpotMarketRaw, dtoToDriftStateRaw, dtoToDriftUserRaw, dtoToDriftUserStatsRaw, dtoToFarmRaw, dtoToJupLendingRewardsRateModelRaw, dtoToJupLendingStateRaw, dtoToJupRateModelRaw, dtoToJupTokenReserveRaw, dtoToObligationRaw, dtoToReserveRaw, encodeTitanTemplate, exponentBuyPtArgs, exponentClmmBuyPtArgs, exponentNumberToBigNumber, farmRawToDto, fetchExponentMarketThree, fetchExponentMarketTwo, fetchExponentVault, fetchExponentVaultFromMarket, fetchTitanQuoteSwapV3, findMplMetadataAddress, findPoolAddress, findPoolMintAddress, findPoolMintAddressByVoteAccount, findPoolMintAuthorityAddress, findPoolMplAuthorityAddress, findPoolOnRampAddress, findPoolStakeAddress, findPoolStakeAuthorityAddress, generateDriftReserveCurve, generateJupLendSupplyCurve, generateKaminoReserveCurve, getAccount, getAccountLen, getAllDerivedDriftAccounts, getAllDerivedJupLendAccounts, getAllDerivedKaminoAccounts, getAllRequiredMarkets, getAssociatedTokenAddressSync, getDriftRewards, getDriftTokenAmount, getFixedHostInterestRate, getJupLendRewards, getKaminoBorrowRate, getKaminoTotalSupply, getMinimumBalanceForRentExemptAccount, getMinimumBalanceForRentExemptAccountWithExtensions, getMint, getMintDecimals, getMultipleAccounts, getProtocolTakeRatePct, getReserveRewardsApy, getRewardPerTimeUnitSecond, getStakeAccount, initializeAccountInstructionData, initializeStakedPoolIxs, initializeStakedPoolTx, instructionToTitanWire, interpolateLinear, jupLendingRewardsRateModelRawToDto, jupLendingStateRawToDto, jupRateModelRawToDto, jupTokenReserveRawToDto, layout, lutToTitanWire, makeExponentClmmTradePtIx, makeExponentMergeIx, makeExponentStripIx, makeExponentTradePtIx, makeExponentWrapperMergeIx, makeRefreshObligationIx, makeRefreshReservesBatchIx, makeRefreshingIxs, makeSplStakePoolUpdateBalanceIx, makeUpdateJupLendRate, makeUpdateJupLendRateIx, makeUpdateSpotMarketCumulativeInterestIx, makeUpdateSpotMarketIx, obligationRawToDto, parsePriceData, parsePriceInfo, replenishPoolIx, reserveRawToDto, resolveExponentClmmTradePtContext, resolveExponentMergeContext, resolveExponentStripContext, resolveExponentTradePtContext, resolveExponentWrapperMergeContext, resolveLookupTables, scaledSupplies, selectBestRoute, selectGatewayRoute, slotAdjustmentFactor, syncNativeInstructionData, transferCheckedInstructionData, truncateBorrowCurve, unpackAccount };