@elemental-stv-core/sdk 0.9.2 → 0.11.0

package/dist/common/buffer.d.ts

@@ -2,6 +2,8 @@ import { PublicKey } from "@solana/web3.js";
 import BN from "bn.js";
 export declare function readPubkey(data: Buffer, offset: number): PublicKey;
 export declare function readU64(data: Buffer, offset: number): BN;
+/** Read a signed little-endian i64 as a BN (two's-complement aware). */
+export declare function readI64(data: Buffer, offset: number): BN;
 export declare function readU32(data: Buffer, offset: number): number;
 export declare function readU16(data: Buffer, offset: number): number;
 export declare function readU8(data: Buffer, offset: number): number;
@@ -10,3 +12,4 @@ export declare function writeOptionalPubkey(parts: number[], value: PublicKey |
 export declare function writeOptionalU64(parts: number[], value: BN | number | undefined | null): void;
 export declare function writeOptionalU32(parts: number[], value: number | undefined | null): void;
 export declare function writeOptionalU16(parts: number[], value: number | undefined | null): void;
+export declare function writeOptionalU8(parts: number[], value: number | undefined | null): void;

package/dist/common/buffer.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readPubkey = readPubkey;
 exports.readU64 = readU64;
+exports.readI64 = readI64;
 exports.readU32 = readU32;
 exports.readU16 = readU16;
 exports.readU8 = readU8;
@@ -13,6 +14,7 @@ exports.writeOptionalPubkey = writeOptionalPubkey;
 exports.writeOptionalU64 = writeOptionalU64;
 exports.writeOptionalU32 = writeOptionalU32;
 exports.writeOptionalU16 = writeOptionalU16;
+exports.writeOptionalU8 = writeOptionalU8;
 const web3_js_1 = require("@solana/web3.js");
 const bn_js_1 = __importDefault(require("bn.js"));
 // ---------------------------------------------------------------------------
@@ -37,6 +39,11 @@ function readU64(data, offset) {
     checkBounds(data, offset, 8, "readU64");
     return new bn_js_1.default(data.subarray(offset, offset + 8), "le");
 }
+/** Read a signed little-endian i64 as a BN (two's-complement aware). */
+function readI64(data, offset) {
+    checkBounds(data, offset, 8, "readI64");
+    return new bn_js_1.default(data.readBigInt64LE(offset).toString());
+}
 function readU32(data, offset) {
     checkBounds(data, offset, 4, "readU32");
     return data.readUInt32LE(offset);
@@ -97,3 +104,15 @@ function writeOptionalU16(parts, value) {
         parts.push(0x00);
     }
 }
+function writeOptionalU8(parts, value) {
+    if (value != null) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xff) {
+            throw new Error(`writeOptionalU8: value out of range (0..255): ${value}`);
+        }
+        parts.push(0x01);
+        parts.push(value);
+    }
+    else {
+        parts.push(0x00);
+    }
+}

package/dist/elemental-lend/instructions.d.ts

@@ -13,6 +13,12 @@ export interface InitOrUpdateStrategyArgs {
     addProtocol?: PublicKey | null;
     removeProtocol?: PublicKey | null;
     newAdmin?: PublicKey | null;
+    /**
+     * One-shot legacy backfill of `manager_count` (update path only) — set to the true
+     * live ManagerRole count on a strategy that predates the counter, so the
+     * close_strategy `manager_count == 0` gate is effective. Omit on normal calls.
+     */
+    managerCount?: number | null;
     remainingAccounts?: AccountMeta[];
 }
 export declare function createInitOrUpdateStrategyIx(args: InitOrUpdateStrategyArgs, programId?: PublicKey): TransactionInstruction;
@@ -23,6 +29,8 @@ export interface KvaultDepositArgs {
     depositorBaseAta: PublicKey;
     depositorSharesAta: PublicKey;
     amount: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
     remainingAccounts: AccountMeta[];
 }
 export declare function createKvaultDepositIx(args: KvaultDepositArgs, programId?: PublicKey): TransactionInstruction;
@@ -33,6 +41,8 @@ export interface KvaultWithdrawArgs {
     depositorBaseAta: PublicKey;
     depositorSharesAta: PublicKey;
     shares: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
     remainingAccounts: AccountMeta[];
 }
 export declare function createKvaultWithdrawIx(args: KvaultWithdrawArgs, programId?: PublicKey): TransactionInstruction;
@@ -43,6 +53,8 @@ export interface JupLendDepositArgs {
     depositorBaseAta: PublicKey;
     depositorFtokenAta: PublicKey;
     amount: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
     remainingAccounts: AccountMeta[];
 }
 export declare function createJupLendDepositIx(args: JupLendDepositArgs, programId?: PublicKey): TransactionInstruction;
@@ -53,6 +65,8 @@ export interface JupLendWithdrawArgs {
     depositorBaseAta: PublicKey;
     depositorFtokenAta: PublicKey;
     amount: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
     remainingAccounts: AccountMeta[];
 }
 export declare function createJupLendWithdrawIx(args: JupLendWithdrawArgs, programId?: PublicKey): TransactionInstruction;

package/dist/elemental-lend/instructions.js

@@ -58,12 +58,20 @@ function serializeInitOrUpdateStrategyParams(args) {
     else {
         parts.push(0x00);
     }
+    // manager_count: Option<u8> (last field; update-only backfill)
+    if (args.managerCount != null) {
+        parts.push(0x01);
+        parts.push(args.managerCount & 0xff);
+    }
+    else {
+        parts.push(0x00);
+    }
     return Buffer.from(parts);
 }
 function createInitOrUpdateStrategyIx(args, programId = constants_1.PROGRAM_ID) {
-    const { admin, strategyState, baseMint, strategyBaseAta, tokenProgram, systemProgram = web3_js_1.SystemProgram.programId, associatedTokenProgram = spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, authority, flags, addProtocol, removeProtocol, newAdmin, remainingAccounts = [], } = args;
+    const { admin, strategyState, baseMint, strategyBaseAta, tokenProgram, systemProgram = web3_js_1.SystemProgram.programId, associatedTokenProgram = spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, authority, flags, addProtocol, removeProtocol, newAdmin, managerCount, remainingAccounts = [], } = args;
     const params = serializeInitOrUpdateStrategyParams({
-        newAdmin, authority, flags, addProtocol, removeProtocol,
+        newAdmin, authority, flags, addProtocol, removeProtocol, managerCount,
     });
     const data = Buffer.concat([constants_1.IX_INIT_OR_UPDATE_STRATEGY, params]);
     return new web3_js_1.TransactionInstruction({
@@ -82,9 +90,10 @@ function createInitOrUpdateStrategyIx(args, programId = constants_1.PROGRAM_ID)
     });
 }
 function createKvaultDepositIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, strategyState, managerRole, depositorBaseAta, depositorSharesAta, amount, remainingAccounts } = args;
+    const { manager, strategyState, managerRole, depositorBaseAta, depositorSharesAta, amount, minOut = 0, remainingAccounts } = args;
     const data = [...constants_1.IX_KVAULT_DEPOSIT];
     (0, buffer_1.writeU64)(data, amount);
+    (0, buffer_1.writeU64)(data, minOut); // min_shares_out
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: manager, isSigner: true, isWritable: true },
@@ -99,9 +108,10 @@ function createKvaultDepositIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createKvaultWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, strategyState, managerRole, depositorBaseAta, depositorSharesAta, shares, remainingAccounts } = args;
+    const { manager, strategyState, managerRole, depositorBaseAta, depositorSharesAta, shares, minOut = 0, remainingAccounts } = args;
     const data = [...constants_1.IX_KVAULT_WITHDRAW];
     (0, buffer_1.writeU64)(data, shares);
+    (0, buffer_1.writeU64)(data, minOut); // min_base_out
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: manager, isSigner: true, isWritable: true },
@@ -116,9 +126,10 @@ function createKvaultWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createJupLendDepositIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, strategyState, managerRole, depositorBaseAta, depositorFtokenAta, amount, remainingAccounts } = args;
+    const { manager, strategyState, managerRole, depositorBaseAta, depositorFtokenAta, amount, minOut = 0, remainingAccounts } = args;
     const data = [...constants_1.IX_JUP_LEND_DEPOSIT];
     (0, buffer_1.writeU64)(data, amount);
+    (0, buffer_1.writeU64)(data, minOut); // min_ftokens_out
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: manager, isSigner: true, isWritable: true },
@@ -133,9 +144,10 @@ function createJupLendDepositIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createJupLendWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, strategyState, managerRole, depositorBaseAta, depositorFtokenAta, amount, remainingAccounts } = args;
+    const { manager, strategyState, managerRole, depositorBaseAta, depositorFtokenAta, amount, minOut = 0, remainingAccounts } = args;
     const data = [...constants_1.IX_JUP_LEND_WITHDRAW];
     (0, buffer_1.writeU64)(data, amount);
+    (0, buffer_1.writeU64)(data, minOut); // min_base_out
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: manager, isSigner: true, isWritable: true },

package/dist/elemental-lend/protocol-actions.d.ts

@@ -27,6 +27,12 @@ export interface ProtocolActionArgs {
     action: ProtocolAction;
     /** Amount in base token units (e.g. USDC lamports) */
     amount: bigint;
+    /**
+     * Minimum protocol-receipt out (deposit: min shares/fTokens; withdraw: min base).
+     * On-chain the handler reverts if the CPI yields less (and always requires > 0).
+     * Defaults to 0n (non-zero still enforced; 0 opts out of slippage protection).
+     */
+    minOut?: bigint;
     baseMint: PublicKey;
     /** Token program for the base mint (defaults to SPL Token) */
     tokenProgram?: PublicKey;

package/dist/elemental-lend/protocol-actions.js

@@ -30,7 +30,7 @@ const jupiter_lend_1 = require("./jupiter-lend");
  * @returns TransactionInstruction[] ready for sendSmartTx
  */
 async function buildProtocolActionIxs(args) {
-    const { connection, manager, protocol, protocolType, action, amount, baseMint, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, jupLendPool, programId = constants_1.PROGRAM_ID, } = args;
+    const { connection, manager, protocol, protocolType, action, amount, minOut = 0n, baseMint, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, jupLendPool, programId = constants_1.PROGRAM_ID, } = args;
     const [strategyStatePda] = args.strategyState
         ? [args.strategyState]
         : (0, pda_1.findStrategyStatePda)(baseMint, programId);
@@ -46,6 +46,7 @@ async function buildProtocolActionIxs(args) {
             protocol,
             action,
             amount,
+            minOut,
             baseMint,
             tokenProgram,
             pool: jupLendPool ?? jupiter_lend_1.JUP_LEND_POOLS[baseMint.toBase58()] ?? jupiter_lend_1.USDC_POOL,
@@ -62,6 +63,7 @@ async function buildProtocolActionIxs(args) {
             vaultState: protocol,
             action,
             amount,
+            minOut,
             baseMint,
             tokenProgram,
             programId,
@@ -69,7 +71,7 @@ async function buildProtocolActionIxs(args) {
     }
 }
 function buildJupLendActionIxs(params) {
-    const { manager, strategyStatePda, strategyBaseAta, managerRolePda, action, amount, tokenProgram, pool, programId, } = params;
+    const { manager, strategyStatePda, strategyBaseAta, managerRolePda, action, amount, minOut, tokenProgram, pool, programId, } = params;
     const strategyFtokenAta = (0, ata_1.findAta)(pool.fTokenMint, strategyStatePda, tokenProgram);
     const JUP_LEND_PROG = new web3_js_1.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9");
     // Fixed accounts for the Anchor instruction
@@ -96,9 +98,12 @@ function buildJupLendActionIxs(params) {
             { pubkey: JUP_LEND_PROG, isSigner: false, isWritable: false },
         ];
     }
+    // Data: disc(8) + amount(8) + min_out(8) [deposit: min_ftokens_out, withdraw: min_base_out].
     const amountBuf = Buffer.alloc(8);
     amountBuf.writeBigUInt64LE(amount, 0);
-    const ixData = Buffer.concat([disc, amountBuf]);
+    const minOutBuf = Buffer.alloc(8);
+    minOutBuf.writeBigUInt64LE(minOut, 0);
+    const ixData = Buffer.concat([disc, amountBuf, minOutBuf]);
     const ix = new web3_js_1.TransactionInstruction({
         keys: [...fixedAccounts, ...remainingAccounts],
         programId,
@@ -107,7 +112,7 @@ function buildJupLendActionIxs(params) {
     return Promise.resolve([ix]);
 }
 async function buildKvaultActionIxs(params) {
-    const { connection, manager, strategyStatePda, strategyBaseAta, managerRolePda, vaultState, action, amount, baseMint, tokenProgram, programId, } = params;
+    const { connection, manager, strategyStatePda, strategyBaseAta, managerRolePda, vaultState, action, amount, minOut, baseMint, tokenProgram, programId, } = params;
     // Read vault state for reserve data (needed for both deposit and withdraw)
     const vaultStateInfo = await connection.getAccountInfo(vaultState);
     if (!vaultStateInfo)
@@ -154,18 +159,21 @@ async function buildKvaultActionIxs(params) {
         { pubkey: strategySharesAta, isSigner: false, isWritable: true },
     ];
     if (action === "deposit") {
-        return buildKvaultDepositIxs(fixedAccounts, vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, programId);
+        return buildKvaultDepositIxs(fixedAccounts, vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId);
     }
     else {
-        return buildKvaultWithdrawIxs(connection, fixedAccounts, vaultState, vaultData, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, programId);
+        return buildKvaultWithdrawIxs(connection, fixedAccounts, vaultState, vaultData, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId);
     }
 }
-function buildKvaultDepositIxs(fixedAccounts, vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, programId) {
+function buildKvaultDepositIxs(fixedAccounts, vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId) {
     const disc = Buffer.from(constants_1.IX_KVAULT_DEPOSIT);
     const remainingAccounts = (0, kamino_vault_1.buildKvaultDepositAccounts)(vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves).map((a) => ({ ...a, isSigner: false }));
+    // Data: disc(8) + amount(8) + min_shares_out(8).
     const amountBuf = Buffer.alloc(8);
     amountBuf.writeBigUInt64LE(amount, 0);
-    const ixData = Buffer.concat([disc, amountBuf]);
+    const minOutBuf = Buffer.alloc(8);
+    minOutBuf.writeBigUInt64LE(minOut, 0);
+    const ixData = Buffer.concat([disc, amountBuf, minOutBuf]);
     const ix = new web3_js_1.TransactionInstruction({
         keys: [...fixedAccounts, ...remainingAccounts],
         programId,
@@ -173,7 +181,7 @@ function buildKvaultDepositIxs(fixedAccounts, vaultState, strategyStatePda, stra
     });
     return Promise.resolve([ix]);
 }
-async function buildKvaultWithdrawIxs(connection, fixedAccounts, vaultState, vaultData, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, programId) {
+async function buildKvaultWithdrawIxs(connection, fixedAccounts, vaultState, vaultData, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId) {
     const disc = Buffer.from(constants_1.IX_KVAULT_WITHDRAW);
     // Convert base amount to kvToken shares
     const sharesIssued = vaultData.readBigUInt64LE(232);
@@ -221,9 +229,12 @@ async function buildKvaultWithdrawIxs(connection, fixedAccounts, vaultState, vau
             remainingAccounts.push({ pubkey: r.lendingMarket, isSigner: false, isWritable: false });
         }
     }
+    // Data: disc(8) + shares(8) + min_base_out(8). minOut is the base-out floor.
     const sharesBuf = Buffer.alloc(8);
     sharesBuf.writeBigUInt64LE(withdrawShares, 0);
-    const ixData = Buffer.concat([disc, sharesBuf]);
+    const minOutBuf = Buffer.alloc(8);
+    minOutBuf.writeBigUInt64LE(minOut, 0);
+    const ixData = Buffer.concat([disc, sharesBuf, minOutBuf]);
     const ix = new web3_js_1.TransactionInstruction({
         keys: [...fixedAccounts, ...remainingAccounts],
         programId,

package/dist/jlpd-strategy/accounts.d.ts

@@ -50,7 +50,10 @@ export declare function deserializeManagerRole(data: Buffer): ManagerRole;
  *   [108..112]  _headerPadding                  [u8; 4]
  *   --- Custom JLPD fields (112 bytes) ---
  *   [112..120]  baseLoaned                      u64      (base assets swapped into JLP)
- *   [120..224]  _reserved                       [u8; 104]
+ *   [120..128]  swapArb                         i64      (signed arb accumulator; read as BN)
+ *   [128..160]  priceOracle                     Pubkey   (per-strategy Doves price feed)
+ *   [160..192]  _reserved                       [u8; 32]
+ *   [192..224]  _reserved2                      [u8; 32]
  */
 export declare function deserializeJlpStrategyState(data: Buffer): JlpStrategyState;
 /**

package/dist/jlpd-strategy/accounts.js

@@ -107,7 +107,10 @@ function deserializeManagerRole(data) {
  *   [108..112]  _headerPadding                  [u8; 4]
  *   --- Custom JLPD fields (112 bytes) ---
  *   [112..120]  baseLoaned                      u64      (base assets swapped into JLP)
- *   [120..224]  _reserved                       [u8; 104]
+ *   [120..128]  swapArb                         i64      (signed arb accumulator; read as BN)
+ *   [128..160]  priceOracle                     Pubkey   (per-strategy Doves price feed)
+ *   [160..192]  _reserved                       [u8; 32]
+ *   [192..224]  _reserved2                      [u8; 32]
  */
 function deserializeJlpStrategyState(data) {
     if (data.length < constants_1.STRATEGY_STATE_SIZE) {
@@ -130,6 +133,8 @@ function deserializeJlpStrategyState(data) {
         bump: (0, buffer_1.readU8)(data, 107),
         // Custom
         baseLoaned: (0, buffer_1.readU64)(data, 112),
+        swapArb: (0, buffer_1.readI64)(data, 120),
+        priceOracle: (0, buffer_1.readPubkey)(data, 128),
     };
 }
 /**

package/dist/jlpd-strategy/adapter.d.ts

@@ -45,16 +45,26 @@ export interface AdapterManageArgs {
     managerRole: PublicKey;
     adapterState: PublicKey;
     adapterProgram: PublicKey;
-    /** Adapter instruction discriminator (e.g. ADAPTER_DISC_BORROW) */
+    /** Adapter instruction discriminator (>= 0x03; e.g. ADAPTER_DISC_BORROW) */
     adapterDisc: number;
-    amount: BN | number;
-    /** Protocol-specific remaining accounts for the adapter CPI */
+    /**
+     * Opaque payload forwarded verbatim after the discriminator. Provide either
+     * `data` (raw bytes) or `amount` (convenience: packed as u64 LE, which is
+     * what jlpd-lend-adapter's verbs expect).
+     */
+    data?: Buffer;
+    amount?: BN | number;
+    /**
+     * Protocol-specific remaining accounts for the adapter CPI. NOTE: the adapter
+     * authorizes on its `authority` (the config PDA, propagated as signer) — do
+     * NOT pass an adapter ManagerRole here; that system was retired.
+     */
     remainingAccounts?: AccountMeta[];
 }
 /**
- * Build `adapter_manage` instruction.
+ * Build `adapter_manage` instruction (Adapter Interface v1, opaque passthrough).
  *
- * Routes borrow/repay/earn operations through JLPD for config PDA signer propagation.
- * Anchor data: [8-byte disc, AdapterManageParams(u8 + u64)]
+ * Routes a management op (disc >= 0x03) through JLPD for config PDA signer
+ * propagation. Anchor data: [8-byte ix disc, adapter_disc: u8, data: Vec<u8>].
  */
 export declare function createAdapterManageIx(args: AdapterManageArgs, programId?: PublicKey): TransactionInstruction;

package/dist/jlpd-strategy/adapter.js

@@ -61,26 +61,38 @@ exports.ADAPTER_DISC_DEPOSIT_EARN = 0x04;
 exports.ADAPTER_DISC_WITHDRAW_EARN = 0x05;
 exports.ADAPTER_DISC_REPAY = 0x06;
 /**
- * Build `adapter_manage` instruction.
+ * Build `adapter_manage` instruction (Adapter Interface v1, opaque passthrough).
  *
- * Routes borrow/repay/earn operations through JLPD for config PDA signer propagation.
- * Anchor data: [8-byte disc, AdapterManageParams(u8 + u64)]
+ * Routes a management op (disc >= 0x03) through JLPD for config PDA signer
+ * propagation. Anchor data: [8-byte ix disc, adapter_disc: u8, data: Vec<u8>].
  */
 function createAdapterManageIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, config, managerRole, adapterState, adapterProgram, adapterDisc, amount, remainingAccounts = [], } = args;
-    // Anchor data: [8-byte disc, adapter_disc: u8, amount: u64]
-    const data = Buffer.alloc(17);
+    const { manager, config, managerRole, adapterState, adapterProgram, adapterDisc, data: rawData, amount, remainingAccounts = [], } = args;
+    // Resolve the opaque payload: explicit bytes, or a u64-LE amount.
+    let payload;
+    if (rawData !== undefined) {
+        payload = rawData;
+    }
+    else if (amount !== undefined) {
+        const amtBn = typeof amount === "number" ? new bn_js_1.default(amount) : amount;
+        payload = amtBn.toArrayLike(Buffer, "le", 8);
+    }
+    else {
+        throw new Error("createAdapterManageIx: provide either `data` or `amount`");
+    }
+    // Anchor data: [8-byte ix disc][adapter_disc: u8][Vec<u8>: u32 LE len + bytes]
+    const data = Buffer.alloc(8 + 1 + 4 + payload.length);
     constants_1.IX_ADAPTER_MANAGE.copy(data, 0);
     data[8] = adapterDisc;
-    const amtBuf = typeof amount === "number" ? new bn_js_1.default(amount) : amount;
-    amtBuf.toArrayLike(Buffer, "le", 8).copy(data, 9);
+    data.writeUInt32LE(payload.length, 9);
+    payload.copy(data, 13);
     return new web3_js_1.TransactionInstruction({
         programId,
         keys: [
             { pubkey: manager, isSigner: true, isWritable: false },
             { pubkey: config, isSigner: false, isWritable: true },
             { pubkey: managerRole, isSigner: false, isWritable: false },
-            // remaining_accounts: [adapter_state, adapter_program, ...jupiter accounts]
+            // remaining_accounts: [adapter_state, adapter_program, ...protocol accounts]
             { pubkey: adapterState, isSigner: false, isWritable: true },
             { pubkey: adapterProgram, isSigner: false, isWritable: false },
             ...remainingAccounts,

package/dist/jlpd-strategy/base-to-base-swap.d.ts

@@ -0,0 +1,74 @@
+import { PublicKey, TransactionInstruction, AddressLookupTableAccount, AccountMeta } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+import BN from "bn.js";
+import { type JupiterQuote } from "./swap-jlp";
+/** Arguments for building a base_to_base_swap instruction. */
+export interface CreateBaseToBaseSwapIxArgs {
+    manager: PublicKey;
+    config: PublicKey;
+    managerRole: PublicKey;
+    strategyStateIn: PublicKey;
+    strategyStateOut: PublicKey;
+    baseInAta: PublicKey;
+    baseOutAta: PublicKey;
+    baseInMint: PublicKey;
+    baseOutMint: PublicKey;
+    tokenProgram: PublicKey;
+    jupiterProgram: PublicKey;
+    priceOracleIn: PublicKey;
+    priceOracleOut: PublicKey;
+    amountIn: bigint | BN;
+    minOut: bigint | BN;
+    jupiterData: Buffer | Uint8Array;
+    remainingAccounts?: AccountMeta[];
+}
+/**
+ * Build the on-chain `base_to_base_swap` instruction.
+ *
+ * Instruction data layout (Anchor Borsh):
+ *   [8-byte disc, 8-byte amount_in (LE), 8-byte min_out (LE),
+ *    4-byte jupiter_data_len (LE), ...jupiter_data_bytes]
+ */
+export declare function createBaseToBaseSwapIx(args: CreateBaseToBaseSwapIxArgs, programId?: PublicKey): TransactionInstruction;
+/**
+ * Build a complete base_to_base_swap transaction:
+ *   1. Derive PDAs for both strategies
+ *   2. Resolve oracle accounts (from strategy_state.price_oracle on-chain, or overrides)
+ *   3. Get Jupiter quote (base_in → base_out)
+ *   4. Get Jupiter swap instructions (strategy_state_in PDA signs)
+ *   5. Build instruction + return ALTs
+ *
+ * Oracle resolution:
+ *   - Stablecoins (USDC/JupUSD): always PublicKey.default (program ignores oracle for $1 assets).
+ *   - Volatile assets: use caller-supplied override, or fetch strategy_state on-chain
+ *     to read the stored price_oracle field. To avoid two extra RPC calls, pass
+ *     priceOracleIn/priceOracleOut when you already have the strategy states.
+ */
+export declare function buildBaseToBaseSwapTransaction(args: {
+    connection: SolanaConnection;
+    manager: PublicKey;
+    baseInMint: PublicKey;
+    baseOutMint: PublicKey;
+    /** Amount of base_in to swap, raw u64. */
+    amountIn: bigint;
+    /**
+     * Override oracle for base_in. If omitted and base_in is not a stable,
+     * the strategy_state_in account is fetched to read price_oracle.
+     */
+    priceOracleIn?: PublicKey;
+    /**
+     * Override oracle for base_out. If omitted and base_out is not a stable,
+     * the strategy_state_out account is fetched to read price_oracle.
+     */
+    priceOracleOut?: PublicKey;
+    slippageBps?: number;
+    tokenProgram?: PublicKey;
+    programId?: PublicKey;
+}): Promise<{
+    instructions: TransactionInstruction[];
+    addressLookupTables: AddressLookupTableAccount[];
+    quoteInAmount: bigint;
+    quoteOutAmount: bigint;
+    minOut: bigint;
+    quote: JupiterQuote;
+}>;