@symmetry-hq/temp-v3-sdk 0.0.1

package/src/instructions/management/luts.ts

@@ -0,0 +1,134 @@
+import { BN, Program } from '@coral-xyz/anchor';
+import { SYSTEM_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/native/system';
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+import { ADDRESS_LOOKUP_TABLE_PROGRAM_ID, BASKETS_V3_PROGRAM_ID } from '../../constants';
+import { getLookupTableInfoAccount } from '../pda';
+
+
+const CREATE_BASKET_LOOKUP_TABLES_DISCRIMINATOR = Buffer.from([227,98,152,128,87,46,244,99]);
+const EXTEND_BASKET_LOOKUP_TABLES_DISCRIMINATOR = Buffer.from([98, 129, 153, 127, 181, 160, 117, 74]);
+const OVERWRITE_BASKET_LOOKUP_TABLES_DISCRIMINATOR = Buffer.from([197, 116, 189, 147, 222, 188, 6, 165]);
+const CLOSE_DEACTIVATED_LOOKUP_TABLE_DISCRIMINATOR = Buffer.from([19, 4, 214, 20, 26, 43, 71, 233]);
+
+
+export function createBasketLookupTablesInstruction(params: {
+    signer: PublicKey;
+    basket: PublicKey;
+    oldTempLookupTable0: PublicKey;
+    oldTempLookupTable1: PublicKey;
+    newTempLookupTable0: PublicKey;
+    newTempLookupTable1: PublicKey;
+    slot: number;
+}): TransactionInstruction {
+    const {
+      signer,
+      basket,
+      oldTempLookupTable0,
+      oldTempLookupTable1,
+      newTempLookupTable0,
+      newTempLookupTable1,
+      slot,
+    } = params;
+
+    let newTempLookupTableInfo0 = getLookupTableInfoAccount(newTempLookupTable0);
+    let newTempLookupTableInfo1 = getLookupTableInfoAccount(newTempLookupTable1);
+
+    const data = Buffer.concat([
+      CREATE_BASKET_LOOKUP_TABLES_DISCRIMINATOR,
+      new BN(slot).toArray("le", 8),
+    ]);
+
+    const keys = [
+      { pubkey: signer, isSigner: true, isWritable: true },
+      { pubkey: basket, isSigner: false, isWritable: true },
+      { pubkey: oldTempLookupTable0, isSigner: false, isWritable: true },
+      { pubkey: oldTempLookupTable1, isSigner: false, isWritable: true },
+      { pubkey: newTempLookupTable0, isSigner: false, isWritable: true },
+      { pubkey: newTempLookupTable1, isSigner: false, isWritable: true },
+      { pubkey: newTempLookupTableInfo0, isSigner: false, isWritable: true },
+      { pubkey: newTempLookupTableInfo1, isSigner: false, isWritable: true },
+      { pubkey: ADDRESS_LOOKUP_TABLE_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+    ];
+
+  return new TransactionInstruction({
+    keys,
+    programId: BASKETS_V3_PROGRAM_ID,
+    data,
+  });
+}
+
+export function extendBasketLookupTablesIx(
+    params: {
+      signer: PublicKey;
+      basket: PublicKey;
+      tempLookupTable0: PublicKey;
+      tempLookupTable1: PublicKey;
+}): TransactionInstruction {
+
+    const keys = [
+      { pubkey: params.signer, isWritable: true, isSigner: true },
+      { pubkey: params.basket, isWritable: true, isSigner: false },
+      { pubkey: params.tempLookupTable0, isWritable: true, isSigner: false },
+      { pubkey: params.tempLookupTable1, isWritable: true, isSigner: false },
+      { pubkey: ADDRESS_LOOKUP_TABLE_PROGRAM_ID, isWritable: false, isSigner: false },
+      { pubkey: SYSTEM_PROGRAM_ID, isWritable: false, isSigner: false },
+    ];
+
+    return new TransactionInstruction({
+      keys,
+      programId: BASKETS_V3_PROGRAM_ID,
+      data: EXTEND_BASKET_LOOKUP_TABLES_DISCRIMINATOR,
+    });
+}
+
+export function overwriteBasketLookupTablesIx(
+    params: {
+      signer: PublicKey;
+      basket: PublicKey;
+      tempLookupTable0: PublicKey;
+      tempLookupTable1: PublicKey;
+      activeLookupTable0: PublicKey;
+      activeLookupTable1: PublicKey;
+    
+}): TransactionInstruction {
+
+    const keys = [
+      { pubkey: params.signer, isWritable: true, isSigner: true },
+      { pubkey: params.basket, isWritable: true, isSigner: false },
+      { pubkey: params.tempLookupTable0, isWritable: true, isSigner: false },
+      { pubkey: params.tempLookupTable1, isWritable: true, isSigner: false },
+      { pubkey: params.activeLookupTable0, isWritable: true, isSigner: false },
+      { pubkey: params.activeLookupTable1, isWritable: true, isSigner: false },
+      { pubkey: SYSTEM_PROGRAM_ID, isWritable: false, isSigner: false },
+    ];
+
+    return new TransactionInstruction({
+      keys,
+      programId: BASKETS_V3_PROGRAM_ID,
+      data: OVERWRITE_BASKET_LOOKUP_TABLES_DISCRIMINATOR,
+    });
+}
+
+export function closeDeactivatedLookupTableIx(params: {
+    rentPayer: PublicKey,
+    basket: PublicKey,
+    lookupTable: PublicKey
+}): TransactionInstruction {
+    let lookupTableInfo = getLookupTableInfoAccount(params.lookupTable);
+
+    const keys = [
+      { pubkey: params.rentPayer, isWritable: true, isSigner: false },
+      { pubkey: params.basket, isWritable: true, isSigner: false },
+      { pubkey: params.lookupTable, isWritable: true, isSigner: false },
+      { pubkey: lookupTableInfo, isWritable: true, isSigner: false },
+      { pubkey: ADDRESS_LOOKUP_TABLE_PROGRAM_ID, isWritable: false, isSigner: false },
+      { pubkey: SYSTEM_PROGRAM_ID, isWritable: false, isSigner: false },
+    ];
+
+    return new TransactionInstruction({
+      keys,
+      programId: BASKETS_V3_PROGRAM_ID,
+      data: CLOSE_DEACTIVATED_LOOKUP_TABLE_DISCRIMINATOR,
+    });
+}

package/src/instructions/pda.ts

@@ -0,0 +1,160 @@
+import { AddressLookupTableProgram, Connection, PublicKey } from "@solana/web3.js";
+import { Metaplex } from "@metaplex-foundation/js";
+import { getAssociatedTokenAddressSync } from "@solana/spl-token";
+import { parse, v4 } from "uuid";
+import { BASKETS_V3_PROGRAM_ID } from "../constants";
+
+export const GLOBAL_CONFIG_SEED = Buffer.from("global_config");
+export const BASKET_FEES_SEED = Buffer.from("basket_fees");
+export const MINT_SEED = Buffer.from("mint");
+export const RENT_PAYER_SEED = Buffer.from("rent_payer");
+export const BOUNTY_VAULT_SEED = Buffer.from("bounty_vault");
+export const REBALANCE_INTENT_SEED = Buffer.from("rebalance_intent");
+
+export const WSOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
+/// TODO: Devnet
+export const USDC_MINT = new PublicKey("USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNXemT");
+
+export const PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT = new PublicKey("Dpw1EAVrSB1ibxiDQyTAW6Zip3J4Btk2x4SgApQCeFbX");
+export const PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT = new PublicKey("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE");
+
+export const METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+
+
+export function serializeString(input: string): Uint8Array {
+    const utf8 = new TextEncoder().encode(input);
+    const length = utf8.length;
+
+    const out = new Uint8Array(4 + length);
+
+    // encode length as little-endian u32
+    out[0] = length & 0xff;
+    out[1] = (length >> 8) & 0xff;
+    out[2] = (length >> 16) & 0xff;
+    out[3] = (length >> 24) & 0xff;
+
+    // copy utf8 bytes after the 4-byte length
+    out.set(utf8, 4);
+
+    return out;
+}
+
+export function getRandomSeed(): number[] {
+    return Array.from(parse(v4()));
+}
+
+export function getBasketState(seeds: number[]) {
+    return PublicKey.findProgramAddressSync(
+        [Uint8Array.from(seeds)],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}
+
+export function getBountyVaultPda() {
+    return PublicKey.findProgramAddressSync(
+        [
+            BOUNTY_VAULT_SEED,
+        ],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}
+
+export function getBasketTokenMintPda(basket: PublicKey) {
+    return PublicKey.findProgramAddressSync(
+        [
+            MINT_SEED,
+            basket.toBuffer()
+        ],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}
+
+export function getBasketFeesPda(basket: PublicKey) {
+    return PublicKey.findProgramAddressSync(
+        [
+            BASKET_FEES_SEED,
+            basket.toBuffer()
+        ],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}
+
+export function getGlobalConfigPda() {
+    return PublicKey.findProgramAddressSync(
+        [
+            GLOBAL_CONFIG_SEED
+        ],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}
+
+export function getIntentPda(
+    basket: PublicKey,
+    manager: PublicKey,
+    editType: number,
+) {
+    return PublicKey.findProgramAddressSync(
+        [
+            basket.toBuffer(),
+            manager.toBuffer(),
+            Uint8Array.from([editType]), 
+        ],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}
+
+export function getRebalanceIntentPda(
+    basket: PublicKey,
+    buyer: PublicKey,
+) {
+    return PublicKey.findProgramAddressSync(
+        [
+            REBALANCE_INTENT_SEED,
+            basket.toBuffer(),
+            buyer.toBuffer(),
+        ],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}
+
+export function getMetadataAccount(
+    tokenMint: PublicKey
+): PublicKey {
+    const metaplex = Metaplex.make(new Connection("https://api.devnet.solana.com"));
+    return metaplex.nfts().pdas().metadata({ mint: tokenMint });
+}
+
+export function getLookupTableAccount(
+    creator: PublicKey,
+    slot: number,
+): PublicKey {
+    const ixAndPubkey = AddressLookupTableProgram.createLookupTable({
+        authority: creator,
+        recentSlot: slot,
+        payer: creator,
+    });
+    return ixAndPubkey[1];
+}
+
+export function getLookupTableInfoAccount(
+    lookupTable: PublicKey,
+): PublicKey {
+    return PublicKey.findProgramAddressSync(
+        [lookupTable.toBuffer()],
+        BASKETS_V3_PROGRAM_ID,
+    )[0];
+}
+
+export function getAta(
+    wallet: PublicKey,
+    tokenMint: PublicKey,
+): PublicKey {
+    return getAssociatedTokenAddressSync(tokenMint, wallet, true);
+}
+
+export function getRentPayerPda() {
+    return PublicKey.findProgramAddressSync(
+        [RENT_PAYER_SEED],
+        BASKETS_V3_PROGRAM_ID
+    )[0];
+}

package/src/instructions/user/deposit.ts

@@ -0,0 +1,237 @@
+import { PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RENT_PUBKEY } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+import { BASKETS_V3_PROGRAM_ID } from "../../constants";
+import { getAta, getBasketFeesPda, getBasketTokenMintPda, getBountyVaultPda, getGlobalConfigPda, getRebalanceIntentPda, getRentPayerPda } from "../pda";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { SYSTEM_PROGRAM_ID } from "@coral-xyz/anchor/dist/cjs/native/system";
+import { TransactionInstruction } from "@solana/web3.js";
+
+const CREATE_USER_REBALANCE_INTENT_ACCOUNT = Buffer.from([212, 23, 1, 46, 192, 87, 74, 196]);
+const RESIZE_REBALANCE_INTENT_HANDLER = Buffer.from([71, 204, 243, 183, 209, 118, 111, 94]);
+const CREATE_DEPOSIT_STATE_DISCRIMINATOR = Buffer.from([66, 42, 217, 222, 49, 159, 36, 188]);
+const DEPOSIT_TOKENS_DISCRIMINATOR = Buffer.from([88, 92, 158, 219, 83, 71, 239, 164]);
+const LOCK_DEPOSITS_DISCRIMINATOR = Buffer.from([64, 238, 171, 198, 135, 253, 37, 9]);
+const MINT_BASKET_DISCRIMINATOR = Buffer.from([161, 207, 48, 45, 7, 156, 233, 143]);
+
+
+export function createUserRebalanceIntentIx(params: {
+    user: PublicKey,
+    basket: PublicKey,
+}): TransactionInstruction {
+
+    const {user, basket } = params
+
+    let rebalanceIntent = getRebalanceIntentPda(basket, user);
+    let rentPayerPda = getRentPayerPda();
+    let globalConfig = getGlobalConfigPda();
+
+    const keys = [
+        { pubkey: user, isSigner: true, isWritable: true },
+        { pubkey: basket, isSigner: false, isWritable: true},
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true},
+        { pubkey: rentPayerPda, isSigner: false, isWritable: true },
+        { pubkey: globalConfig, isSigner: false, isWritable: true},
+        { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false},
+        { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false}
+    ];
+
+    const data = CREATE_USER_REBALANCE_INTENT_ACCOUNT;
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data
+    });
+}
+
+export function resizeRebalanceIntentIx(
+    rebalanceIntent: PublicKey
+): TransactionInstruction {
+    
+    const data = RESIZE_REBALANCE_INTENT_HANDLER;
+
+    const keys = [
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true}
+    ];
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data
+    });
+}
+
+export function depositStateIx(
+    params: {
+        buyer: PublicKey,
+        basket: PublicKey,
+        bountyMint: PublicKey,
+        rebalanceIntentRentPayer: PublicKey,
+        rebalanceSlippageBps: number, // u16
+        executionStartTime: number // u64
+    }
+){
+    const {
+        buyer,
+        basket,
+        bountyMint,
+        rebalanceIntentRentPayer,
+        rebalanceSlippageBps,
+        executionStartTime,
+    } = params;
+
+    let rebalanceIntent = getRebalanceIntentPda(basket, buyer);
+    let basketTokenMint = getBasketTokenMintPda(basket);
+    let globalConfig = getGlobalConfigPda();
+    let rentPayerPda = getRentPayerPda();
+    let bountyVault = getBountyVaultPda();
+    let bountyVaultAta = getAta(bountyVault, bountyMint);
+    let buyerBountyAta = getAta(buyer, bountyMint);
+    let buyerBasketAta = getAta(buyer, basketTokenMint);
+    
+    const rebalanceIntentRentPayerBuf = rebalanceIntentRentPayer.toBuffer();
+    const rebalanceSlippageBuf = Buffer.from(new BN(rebalanceSlippageBps).toArray("le", 2));
+    const executionStartBuf = Buffer.from(new BN(executionStartTime).toArray("le", 8));
+
+    const data = Buffer.concat([
+        CREATE_DEPOSIT_STATE_DISCRIMINATOR,
+        rebalanceIntentRentPayerBuf,
+        rebalanceSlippageBuf,
+        executionStartBuf
+    ]);
+    const keys = [
+        { pubkey: buyer, isSigner: true, isWritable: true },
+        { pubkey: basket, isSigner: false, isWritable: true },
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: rentPayerPda, isSigner: false, isWritable: true },
+        { pubkey: basketTokenMint, isSigner: false, isWritable: false },
+        { pubkey: buyerBasketAta, isSigner: false, isWritable: true },
+        { pubkey: globalConfig, isSigner: false, isWritable: false },
+        { pubkey: bountyMint, isSigner: false, isWritable: false },
+        { pubkey: buyerBountyAta, isSigner: false, isWritable: true },
+        { pubkey: bountyVault, isSigner: false, isWritable: true },
+        { pubkey: bountyVaultAta, isSigner: false, isWritable: true },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        // { pubkey: rebalanceIntent, isSigner: false, isWritable: true } // remaining accounts
+    ];
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}
+
+
+export function depositTokensIx(params: {
+    owner: PublicKey;
+    basket: PublicKey;
+    contributions: {mint: PublicKey, amount: number}[]; // length 10
+}): TransactionInstruction{
+
+    const { owner, basket, contributions } = params;
+
+    let rebalanceIntent = getRebalanceIntentPda(basket, owner);
+
+    const discriminator = DEPOSIT_TOKENS_DISCRIMINATOR;
+    const amountsBuffer = Buffer.concat(
+        contributions.map((contribution) => Buffer.from(new BN(contribution.amount).toArray("le", 8)))
+    );
+    const data = Buffer.concat([discriminator, amountsBuffer]);
+
+    const keys = [
+        { pubkey: owner, isSigner: true, isWritable: true },
+        { pubkey: basket, isSigner: false, isWritable: true },
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+    ];
+
+    // remaining accounts
+    contributions.forEach((contribution) => {
+        let mint = contribution.mint;
+        let ownerAta = getAta(owner, mint);
+        let basketAta = getAta(basket, mint);
+        keys.push({ pubkey: mint, isSigner: false, isWritable: false });
+        keys.push({ pubkey: ownerAta, isSigner: false, isWritable: true });
+        keys.push({ pubkey: basketAta, isSigner: false, isWritable: true });
+    });
+
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}
+
+
+
+export function lockDepositsIx(params: {
+    owner: PublicKey;
+    basket: PublicKey;
+}): TransactionInstruction {
+    const { owner, basket } = params;
+    let rebalanceIntent = getRebalanceIntentPda(basket, owner);
+
+    const keys = [
+        { pubkey: params.owner, isSigner: true , isWritable: true},
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+    ];
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data: LOCK_DEPOSITS_DISCRIMINATOR,
+    });
+}
+
+
+export function mintBasketIx(params: {
+    keeper: PublicKey;
+    basket: PublicKey;
+    buyer: PublicKey;
+}): TransactionInstruction {
+
+    const { keeper, basket, buyer } = params;
+    let rebalanceIntent = getRebalanceIntentPda(basket, buyer);
+
+    let basketTokenMint = getBasketTokenMintPda(basket);
+
+    let basketFees = getBasketFeesPda(basket);
+
+    let globalConfig = getGlobalConfigPda();
+
+    let buyerBasketATA = getAta(buyer, basketTokenMint);
+    let basketFeesAta = getAta(basketFees, basketTokenMint);
+
+    const keys = [
+        { pubkey: keeper, isWritable: true, isSigner: true },
+        { pubkey: basket, isWritable: true, isSigner: false },
+        { pubkey: rebalanceIntent, isWritable: true, isSigner: false },
+        { pubkey: basketTokenMint, isWritable: true, isSigner: false },
+        { pubkey: buyer, isWritable: true, isSigner: false },
+        { pubkey: buyerBasketATA, isWritable: true, isSigner: false },
+        { pubkey: globalConfig, isWritable: false, isSigner: false },
+        { pubkey: basketFees, isWritable: true, isSigner: false },
+        { pubkey: basketFeesAta, isWritable: true, isSigner: false },
+        { pubkey: TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+        { pubkey: TOKEN_2022_PROGRAM_ID, isWritable: false, isSigner: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+        { pubkey: SYSTEM_PROGRAM_ID, isWritable: false, isSigner: false },
+    ];
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data: MINT_BASKET_DISCRIMINATOR,
+    });
+}
+
+
+

package/src/instructions/user/withdraw.ts

@@ -0,0 +1,130 @@
+import { PublicKey } from "@solana/web3.js";
+import { BASKETS_V3_PROGRAM_ID } from "../../constants";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { BN } from "@coral-xyz/anchor";
+import { getAta, getBasketTokenMintPda, getBountyVaultPda, getGlobalConfigPda, getRebalanceIntentPda, getRentPayerPda } from "../pda";
+import { SYSTEM_PROGRAM_ID } from "@coral-xyz/anchor/dist/cjs/native/system";
+import { TransactionInstruction } from "@solana/web3.js";
+
+
+const CREATE_WITHDRAW_STATE_DISCRIMINATOR = Buffer.from([161, 45, 253, 59, 110, 240, 65, 3]);
+const REDEEM_TOKENS_DISCRIMINATOR = Buffer.from([83, 49, 112, 2, 105, 193, 106, 126]);
+
+
+export function createWithdrawStateIx(params: {
+    seller: PublicKey;
+    basket: PublicKey;
+    withdrawAmount: number;
+    rebalanceSlippageBps: number;
+    executionStartTime: number;
+    bountyMint: PublicKey;
+}){
+    const {
+        seller,
+        basket,
+        withdrawAmount,
+        rebalanceSlippageBps,
+        executionStartTime,
+        bountyMint,
+    } = params;
+
+    let rebalanceIntent = getRebalanceIntentPda(basket, seller);
+    let rentPayerPda = getRentPayerPda();
+    let basketTokenMint = getBasketTokenMintPda(basket);
+    let globalConfig = getGlobalConfigPda();
+    let bountyVault = getBountyVaultPda();
+
+    let sellerBasketAta = getAta(seller, basketTokenMint);
+    let sellerBountyAta = getAta(seller, bountyMint);
+    let bountyVaultAta = getAta(bountyVault, bountyMint);
+
+    let basketRebalanceIntent = getRebalanceIntentPda(basket, basket);
+
+    const data = Buffer.concat([
+        CREATE_WITHDRAW_STATE_DISCRIMINATOR,
+        Buffer.from(new BN(withdrawAmount).toArray("le", 8)),
+        Buffer.from(new BN(rebalanceSlippageBps).toArray("le", 2)),
+        Buffer.from(new BN(executionStartTime).toArray("le", 8)),
+    ]);
+
+
+    const keys = [
+        { pubkey: seller, isSigner: true, isWritable: true },
+        { pubkey: basket, isSigner: false, isWritable: true },
+        { pubkey: basketRebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: rentPayerPda, isSigner: false, isWritable: true },
+        { pubkey: basketTokenMint, isSigner: false, isWritable: false },
+        { pubkey: sellerBasketAta, isSigner: false, isWritable: true },
+        { pubkey: globalConfig, isSigner: false, isWritable: false },
+        { pubkey: bountyMint, isSigner: false, isWritable: false },
+        { pubkey: sellerBountyAta, isSigner: false, isWritable: true },
+        { pubkey: bountyVault, isSigner: false, isWritable: true },
+        { pubkey: bountyVaultAta, isSigner: false, isWritable: true },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: false } // remaining accounts
+    ];
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}
+
+
+
+export function redeemTokensIx(
+    params: {
+        keeper: PublicKey;
+        basket: PublicKey;
+        owner: PublicKey;
+        tokenMints: PublicKey[]; 
+    },
+): TransactionInstruction {
+    const {
+        keeper,
+        basket,
+        owner,
+    } = params;
+
+    let rebalanceIntent = getRebalanceIntentPda(basket, owner);
+
+    const keys = [
+        { pubkey: keeper, isSigner: true, isWritable: true },
+        { pubkey: basket, isSigner: false, isWritable: true },
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: owner, isSigner: false, isWritable: true },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+    ];
+
+    // remaining accounts
+    params.tokenMints.forEach((mint) => {
+        keys.push({ pubkey: mint, isWritable: false, isSigner: false });
+        const ownerAta = getAssociatedTokenAddressSync(
+            mint,
+            owner
+        );
+        keys.push({ pubkey: ownerAta, isWritable: true, isSigner: false });
+        const basketAta = getAssociatedTokenAddressSync(
+            mint,
+            basket
+        );
+        keys.push({ pubkey: basketAta, isWritable: true, isSigner: false });
+    });
+
+    const discriminator = REDEEM_TOKENS_DISCRIMINATOR;
+
+    const data = discriminator;
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}