@elmntl/jlpd-sdk 0.1.11 → 0.13.4

package/dist/jlpd-strategy/settle-yield.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSettleYieldIx = createSettleYieldIx;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+const ata_1 = require("../common/ata");
+// ---------------------------------------------------------------------------
+// Internal raw builder
+// ---------------------------------------------------------------------------
+/**
+ * Build the on-chain `settle_yield` instruction from explicit account inputs.
+ *
+ * settle_yield takes no params -- instruction data is just the 8-byte discriminator.
+ *
+ * Accounts (15 total):
+ *   0: config (JlpdConfig PDA)
+ *   1: manager_role (ManagerRole PDA)
+ *   2: hedge_state (HedgeState PDA, mut -- resets swap-churn accumulator)
+ *   3: vault_jlp_ata (JLP ATA owned by config)
+ *   4: stv_0 (BTC strategy_state, mut)
+ *   5: stv_1 (ETH strategy_state, mut)
+ *   6: stv_2 (SOL strategy_state, mut)
+ *   7: stv_3 (USDC strategy_state, mut)
+ *   8: stv_4 (JupUSD strategy_state, mut)
+ *   9: doves_btc_usd (oracle)
+ *  10: doves_eth_usd (oracle)
+ *  11: doves_sol_usd (oracle)
+ *  12: jlp_pool (Jupiter Perps Pool)
+ *  13: jlp_mint_account
+ *  14: manager (signer)
+ *  15+: remaining_accounts, in this EXACT order:
+ *       [0 .. 2*enabled_hedge_slots) -- (position, vault_state) pairs per
+ *         ENABLED hedge slot, then the manifest + earn block (one account per
+ *         non-default hedge manifest slot). Empty while the hedge is disabled.
+ *       [.. remainder) -- the JLP pool custody accounts, in pool `custodies`
+ *         Vec order (6 today). REQUIRED on mainnet even when the hedge is off
+ *         (consumed by `compute_live_jlp_price`).
+ */
+function buildRawSettleYieldIx(args, programId = constants_1.PROGRAM_ID) {
+    const { config, managerRole, hedgeState, vaultJlpAta, stv0, stv1, stv2, stv3, stv4, dovesBtcUsd, dovesEthUsd, dovesSolUsd, jlpPool, jlpMintAccount, manager, hedgeAccounts = [], custodyAccounts, } = args;
+    // Instruction data: just the 8-byte discriminator (no params)
+    const data = Buffer.alloc(8);
+    constants_1.IX_SETTLE_YIELD.copy(data, 0);
+    const keys = [
+        { pubkey: config, isSigner: false, isWritable: true },
+        { pubkey: managerRole, isSigner: false, isWritable: false },
+        { pubkey: hedgeState, isSigner: false, isWritable: true },
+        { pubkey: vaultJlpAta, isSigner: false, isWritable: false },
+        { pubkey: stv0, isSigner: false, isWritable: true },
+        { pubkey: stv1, isSigner: false, isWritable: true },
+        { pubkey: stv2, isSigner: false, isWritable: true },
+        { pubkey: stv3, isSigner: false, isWritable: true },
+        { pubkey: stv4, isSigner: false, isWritable: true },
+        { pubkey: dovesBtcUsd, isSigner: false, isWritable: false },
+        { pubkey: dovesEthUsd, isSigner: false, isWritable: false },
+        { pubkey: dovesSolUsd, isSigner: false, isWritable: false },
+        { pubkey: jlpPool, isSigner: false, isWritable: false },
+        { pubkey: jlpMintAccount, isSigner: false, isWritable: false },
+        { pubkey: manager, isSigner: true, isWritable: false },
+        ...hedgeAccounts,
+        ...custodyAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false })),
+    ];
+    return new web3_js_1.TransactionInstruction({ keys, programId, data });
+}
+// ---------------------------------------------------------------------------
+// Public instruction builder
+// ---------------------------------------------------------------------------
+/**
+ * Build a `settle_yield` instruction with automatic PDA derivation.
+ *
+ * Requires the 5 base asset mints in order: [BTC, ETH, SOL, USDC, JupUSD].
+ * These must match the `base_asset_mints` array on the JlpdConfig account.
+ *
+ * Naming follows the SDK convention: low-level instruction builders are named
+ * `create*Ix` (this is the canonical name); high-level transaction wrappers
+ * (if any) are named `build*Transaction`.
+ */
+function createSettleYieldIx(args) {
+    const { manager, baseAssetMints, jlpMint = constants_1.JLP_MINT, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, programId = constants_1.PROGRAM_ID, hedgeAccounts, custodyAccounts, priceOracleBtc = constants_1.DOVES_BTC_USD, priceOracleEth = constants_1.DOVES_ETH_USD, priceOracleSol = constants_1.DOVES_SOL_USD, } = args;
+    // Derive PDAs
+    const [config] = (0, pda_1.findJlpdConfigPda)(programId);
+    const [managerRole] = (0, pda_1.findJlpdManagerRolePda)(config, manager, programId);
+    const [hedgeState] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("hedge"), config.toBuffer()], programId);
+    // Derive strategy_state PDAs for all 5 base assets
+    const [stv0] = (0, pda_1.findStrategyStatePda)(baseAssetMints[0], programId);
+    const [stv1] = (0, pda_1.findStrategyStatePda)(baseAssetMints[1], programId);
+    const [stv2] = (0, pda_1.findStrategyStatePda)(baseAssetMints[2], programId);
+    const [stv3] = (0, pda_1.findStrategyStatePda)(baseAssetMints[3], programId);
+    const [stv4] = (0, pda_1.findStrategyStatePda)(baseAssetMints[4], programId);
+    // Derive vault JLP ATA (owned by config PDA)
+    const vaultJlpAta = (0, ata_1.findAta)(jlpMint, config, tokenProgram);
+    return buildRawSettleYieldIx({
+        config,
+        managerRole,
+        hedgeState,
+        vaultJlpAta,
+        stv0,
+        stv1,
+        stv2,
+        stv3,
+        stv4,
+        dovesBtcUsd: priceOracleBtc,
+        dovesEthUsd: priceOracleEth,
+        dovesSolUsd: priceOracleSol,
+        jlpPool: constants_1.JLP_POOL_ACCOUNT,
+        jlpMintAccount: jlpMint,
+        manager,
+        hedgeAccounts,
+        custodyAccounts,
+    }, programId);
+}

package/dist/jlpd-strategy/swap-jlp.d.ts

@@ -0,0 +1,198 @@
+import { PublicKey, TransactionInstruction, AddressLookupTableAccount, AccountMeta } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+import BN from "bn.js";
+import { fetchJlpStrategyState } from "./accounts";
+/** Direction of the JLP swap */
+export type SwapDirection = "BaseToJlp" | "JlpToBase";
+/** Arguments for building a swap_jlp instruction */
+export interface CreateSwapJlpIxArgs {
+    manager: PublicKey;
+    config: PublicKey;
+    managerRole: PublicKey;
+    strategyState: PublicKey;
+    strategyBaseAta: PublicKey;
+    strategyJlpAta: PublicKey;
+    vaultJlpAta: PublicKey;
+    baseMint: PublicKey;
+    jlpMint: PublicKey;
+    tokenProgram: PublicKey;
+    jupiterProgram: PublicKey;
+    /**
+     * Doves price-feed account for this base asset. Must match
+     * strategy_state.price_oracle on-chain. Stablecoins (USDC/JupUSD) use
+     * PublicKey.default — the program ignores the oracle for $1-pegged assets.
+     */
+    priceOracle: PublicKey;
+    /** Jupiter Perps JLP pool account — must equal the on-chain JLP_POOL_ACCOUNT. */
+    jlpPool: PublicKey;
+    /** JLP mint account (raw) for pool-price supply read — equals config.jlp_mint. */
+    jlpMintAccount: PublicKey;
+    direction: SwapDirection;
+    amount: bigint | BN;
+    minOut: bigint | BN;
+    jupiterData: Buffer | Uint8Array;
+    remainingAccounts?: AccountMeta[];
+}
+/** Jupiter swap quote response */
+export interface JupiterQuote {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    otherAmountThreshold: string;
+    swapMode: string;
+    slippageBps: number;
+    priceImpactPct: string;
+    routePlan: unknown[];
+    contextSlot?: number;
+    timeTaken?: number;
+}
+/** Parsed Jupiter swap instruction from the API */
+export interface JupiterSwapInstruction {
+    programId: string;
+    data: string;
+    accounts: {
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }[];
+}
+/** Jupiter swap-instructions API response */
+export interface JupiterSwapInstructionsResponse {
+    tokenLedgerInstruction: JupiterSwapInstruction | null;
+    computeBudgetInstructions: JupiterSwapInstruction[];
+    setupInstructions: JupiterSwapInstruction[];
+    swapInstruction: JupiterSwapInstruction;
+    cleanupInstruction: JupiterSwapInstruction | null;
+    addressLookupTableAddresses: string[];
+}
+/**
+ * Build the on-chain `swap_jlp` instruction.
+ *
+ * Instruction data layout (Anchor Borsh):
+ *   [8-byte disc, 1-byte direction, 8-byte amount (LE), 8-byte min_out (LE),
+ *    4-byte jupiter_data_len (LE), ...jupiter_data_bytes]
+ */
+export declare function createSwapJlpIx(args: CreateSwapJlpIxArgs, programId?: PublicKey): TransactionInstruction;
+/**
+ * Fetch a swap quote from Jupiter's v1 quote API.
+ */
+export declare function getJupiterSwapQuote(args: {
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    amount: number | bigint;
+    slippageBps?: number;
+    maxAccounts?: number;
+}): Promise<JupiterQuote>;
+/**
+ * Fetch swap instructions from Jupiter's v1 swap-instructions API.
+ *
+ * @param quoteResponse The quote from getJupiterSwapQuote
+ * @param userPublicKey The account that signs the swap -- for JLPD this is the strategy_state PDA
+ * @param destinationTokenAccount Optional override for the destination token account.
+ *   For base_to_base_swap: must be base_out_ata (ATA owned by strategy_state_OUT) so
+ *   Jupiter routes output tokens there instead of to userPublicKey's default ATA.
+ *   For swap_jlp: omit — Jupiter defaults destination to userPublicKey's ATA which is correct.
+ */
+export declare function getJupiterSwapInstructions(args: {
+    quoteResponse: JupiterQuote;
+    userPublicKey: PublicKey;
+    destinationTokenAccount?: PublicKey;
+}): Promise<{
+    swapInstructionData: Buffer;
+    remainingAccounts: AccountMeta[];
+    addressLookupTableAddresses: string[];
+    /** Decoded compute-budget instructions from Jupiter. Must be prepended to the tx. */
+    computeBudgetInstructions: TransactionInstruction[];
+}>;
+/**
+ * Build a complete swap_jlp transaction with Jupiter quote + instructions + ALTs.
+ *
+ * This is the main function the frontend calls. It:
+ * 1. Derives all PDAs (config, manager_role, strategy_state, ATAs)
+ * 2. Gets Jupiter quote
+ * 3. Gets Jupiter swap instructions
+ * 4. Builds the swap_jlp instruction with remaining accounts
+ * 5. Returns instructions + ALTs for a versioned transaction
+ */
+export declare function buildSwapJlpTransaction(args: {
+    connection: SolanaConnection;
+    manager: PublicKey;
+    baseMint: PublicKey;
+    direction: SwapDirection;
+    amount: bigint;
+    slippageBps?: number;
+    jlpMint?: PublicKey;
+    tokenProgram?: PublicKey;
+    programId?: PublicKey;
+    /**
+     * Doves price-feed account for this base asset. Must equal
+     * strategy_state.price_oracle on-chain.
+     *
+     * - For non-stable assets (BTC/ETH/SOL): if omitted the strategy state is
+     *   fetched from the chain to read the stored feed. Provide this when you
+     *   already have the strategy state in memory to avoid an extra RPC call.
+     * - For stable assets (USDC/JupUSD): pass `PublicKey.default` or omit —
+     *   the program uses a hardcoded $1 price and ignores the oracle account.
+     */
+    priceOracle?: PublicKey;
+    /**
+     * Pre-fetched strategy state (optional). When provided AND the asset is not a stable,
+     * the internal strategy-state fetch is skipped, saving one RPC call. Also used to
+     * thread the decoded `swapArb` field for BaseToJlp without a second fetch.
+     *
+     * Callers that already have the strategy state (e.g. `buildJlpToBaseRebalance`)
+     * should pass it here to avoid redundant fetches.
+     */
+    prefetchedStrategyState?: Awaited<ReturnType<typeof fetchJlpStrategyState>>;
+}): Promise<{
+    instructions: TransactionInstruction[];
+    addressLookupTables: AddressLookupTableAccount[];
+    /** Actual input amount from Jupiter quote (may differ from requested amount) */
+    quoteInAmount: bigint;
+    /**
+     * minOut encoded in the swap_jlp instruction data (= quote.otherAmountThreshold).
+     * Returned explicitly so callers do not need to locate and parse the swap_jlp ix
+     * inside the instruction array (whose index can shift when compute-budget ixs are
+     * prepended).
+     */
+    minOut: bigint;
+}>;
+export interface RebalanceArgs {
+    connection: SolanaConnection;
+    manager: PublicKey;
+    baseMint: PublicKey;
+    vaultId: number;
+    direction: SwapDirection;
+    /** Base amount (BaseToJlp) or JLP amount (JlpToBase) */
+    amount: bigint;
+    slippageBps?: number;
+    /** Pass from frontend to skip RPC balance lookups */
+    liquidity?: {
+        strategyAtaBalance: bigint;
+        vaultAtaBalance: bigint;
+    };
+    jlpMint?: PublicKey;
+    tokenProgram?: PublicKey;
+    programId?: PublicKey;
+    pStvProgramId?: PublicKey;
+}
+export interface RebalanceResult {
+    /** Tx 1 instructions (deposit_to_strategy pre-fill, or empty) */
+    preInstructions: TransactionInstruction[];
+    /** Tx 2 instructions (swap_jlp, optionally + withdraw_from_strategy) */
+    instructions: TransactionInstruction[];
+    /** Tx 3 instructions (post-sweep route to Jupiter Lend, or empty) */
+    postInstructions: TransactionInstruction[];
+    addressLookupTables: AddressLookupTableAccount[];
+    routeDescription: string;
+}
+/**
+ * Build a complete rebalance transaction set for JLPD strategy.
+ *
+ * For BaseToJlp: auto-detects liquidity location and builds
+ * deposit_to_strategy + swap_jlp (tries 1 tx, falls back to 2 if needed).
+ *
+ * For JlpToBase: builds swap_jlp + withdraw_from_strategy in 1 tx.
+ */
+export declare function buildRebalanceTransaction(args: RebalanceArgs): Promise<RebalanceResult>;