@symmetry-hq/sdk 1.0.1

package/src/instructions/management/luts.ts

@@ -0,0 +1,157 @@
+import BN from 'bn.js';
+import { AccountMeta, PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+
+import {
+    ADDRESS_LOOKUP_TABLE_PROGRAM_ID, BASKETS_V3_PROGRAM_ID, PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT,
+    PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT
+} from '../../constants';
+import { getGlobalConfigPda, 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;
+
+    const globalConfig = getGlobalConfigPda();
+    const hasOldTemp = !oldTempLookupTable0.equals(PublicKey.default)
+                    && !oldTempLookupTable1.equals(PublicKey.default);
+
+    const data = Buffer.concat([
+      CREATE_BASKET_LOOKUP_TABLES_DISCRIMINATOR,
+      Buffer.from(new BN(slot).toArray("le", 8)),
+    ]);
+
+    const keys: AccountMeta[] = [
+      { pubkey: signer, isSigner: true, isWritable: true },
+      { pubkey: basket, isSigner: false, isWritable: true },
+      { pubkey: globalConfig, isSigner: false, isWritable: false },
+      { pubkey: hasOldTemp ? oldTempLookupTable0 : PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT, isSigner: false, isWritable: true },
+      { pubkey: hasOldTemp ? oldTempLookupTable1 : PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT, isSigner: false, isWritable: true },
+      { pubkey: newTempLookupTable0, isSigner: false, isWritable: true },
+      { pubkey: newTempLookupTable1, isSigner: false, isWritable: true },
+    ];
+
+    if (hasOldTemp) {
+      keys.push(
+        { pubkey: getLookupTableInfoAccount(oldTempLookupTable0), isSigner: false, isWritable: true },
+        { pubkey: getLookupTableInfoAccount(oldTempLookupTable1), isSigner: false, isWritable: true },
+      );
+    } 
+    else {
+      keys.push(
+        { pubkey: BASKETS_V3_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: BASKETS_V3_PROGRAM_ID, isSigner: false, isWritable: false },
+      );
+    }
+
+    keys.push(
+      { pubkey: ADDRESS_LOOKUP_TABLE_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: SystemProgram.programId, 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;
+      additionalAccounts: 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: SystemProgram.programId, isWritable: false, isSigner: false },
+      ...params.additionalAccounts.map(pubkey => ({pubkey, 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: getLookupTableInfoAccount(params.activeLookupTable0), isWritable: true, isSigner: false },
+      { pubkey: getLookupTableInfoAccount(params.activeLookupTable1), isWritable: true, isSigner: false },
+      { pubkey: ADDRESS_LOOKUP_TABLE_PROGRAM_ID, isWritable: false, isSigner: false },
+      { pubkey: SystemProgram.programId, 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: SystemProgram.programId, 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,151 @@
+import { randomBytes } from 'crypto';
+
+import BN from 'bn.js';
+import { getAssociatedTokenAddressSync } from '@solana/spl-token';
+import { AddressLookupTableProgram, PublicKey } from '@solana/web3.js';
+
+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 WITHDRAW_BASKET_FEES_SEED = Buffer.from("withdraw_basket_fees");
+export const BASKET_SEED = Buffer.from("basket");
+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 TOKEN_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(randomBytes(16));
+}
+
+export function getBasketTokenMintPda(basketId: number) {
+    return PublicKey.findProgramAddressSync([
+        MINT_SEED,
+        new BN(basketId).toArrayLike(Buffer, "le", 8)
+    ], BASKETS_V3_PROGRAM_ID)[0];
+}
+
+export function getBasketState(mint: PublicKey) {
+    return PublicKey.findProgramAddressSync([
+        BASKET_SEED,
+        mint.toBuffer()
+    ], BASKETS_V3_PROGRAM_ID)[0];
+}
+
+
+export function getBountyVaultPda() {
+    return PublicKey.findProgramAddressSync([
+        BOUNTY_VAULT_SEED,
+    ], 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 getWithdrawBasketFeesPda(basket: PublicKey, feeType: number) {
+    return PublicKey.findProgramAddressSync([
+        WITHDRAW_BASKET_FEES_SEED,
+        basket.toBuffer(),
+        Buffer.from([feeType]) // u8, not u64
+    ], BASKETS_V3_PROGRAM_ID)[0];
+}
+
+export function getGlobalConfigPda() {
+    return PublicKey.findProgramAddressSync([
+        GLOBAL_CONFIG_SEED
+    ], BASKETS_V3_PROGRAM_ID)[0];
+}
+
+export function getRentPayerPda() {
+    return PublicKey.findProgramAddressSync([
+        RENT_PAYER_SEED
+    ], BASKETS_V3_PROGRAM_ID)[0];
+}
+
+export function getIntentPda(
+    basket: PublicKey,
+    intentSeedArray: Uint8Array,
+    editType: number,
+) {
+    return PublicKey.findProgramAddressSync([
+        basket.toBuffer(),
+        intentSeedArray,
+        Uint8Array.from([editType]),
+    ], BASKETS_V3_PROGRAM_ID)[0];
+}
+
+export function getRebalanceIntentPda(
+    basket: PublicKey,
+    owner: PublicKey,
+) {
+    return PublicKey.findProgramAddressSync([
+        REBALANCE_INTENT_SEED,
+        basket.toBuffer(),
+        owner.toBuffer(),
+    ], BASKETS_V3_PROGRAM_ID)[0];
+}
+
+export function getMetadataAccount(
+    tokenMint: PublicKey
+): PublicKey {
+    return PublicKey.findProgramAddressSync(
+        [
+            Buffer.from("metadata"),
+            TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+            tokenMint.toBuffer(),
+        ],
+        TOKEN_METADATA_PROGRAM_ID
+    )[0];
+}
+
+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,
+    tokenProgram?: PublicKey
+): PublicKey {
+    return getAssociatedTokenAddressSync(tokenMint, wallet, true, tokenProgram);
+}

package/src/instructions/user/deposit.ts

@@ -0,0 +1,143 @@
+import BN from 'bn.js';
+import {
+    ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID
+} from '@solana/spl-token';
+import {
+    PublicKey, SystemProgram, TransactionInstruction
+} from '@solana/web3.js';
+
+import { BASKETS_V3_PROGRAM_ID } from '../../constants';
+import {
+    getAta, getBasketFeesPda, getGlobalConfigPda,
+    getRebalanceIntentPda
+} from '../pda';
+
+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 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;
+
+    let ixs: TransactionInstruction[] = [];
+
+    let batch_size = 5;
+    for (let i = 0; i < contributions.length; i += batch_size) {
+        let batch_contributions = contributions.slice(i, i + batch_size);
+        let amounts = batch_contributions.map((contribution) => contribution.amount);
+        while (amounts.length < 10) amounts.push(0);
+        const amountsBuffer = Buffer.concat(
+            amounts.map((amount) => Buffer.from(new BN(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: SystemProgram.programId, isSigner: false, isWritable: false },
+        ];
+    
+        // remaining accounts
+        batch_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 });
+        });
+    
+        ixs.push(
+            new TransactionInstruction({
+                keys,
+                programId: BASKETS_V3_PROGRAM_ID,
+                data,
+            })
+        );
+    }
+
+    return ixs;
+}
+
+
+export function lockDepositsIx(params: {
+    owner: PublicKey;
+    basket: PublicKey;
+}): TransactionInstruction {
+    const { owner, basket } = params;
+    let rebalanceIntent = getRebalanceIntentPda(basket, owner);
+    let globalConfig = getGlobalConfigPda();
+
+    const keys = [
+        { pubkey: params.owner, isSigner: true , isWritable: true},
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: globalConfig, isSigner: false, isWritable: false },
+    ];
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data: LOCK_DEPOSITS_DISCRIMINATOR,
+    });
+}
+
+
+export function mintBasketIx(params: {
+    keeper: PublicKey;
+    basket: PublicKey;
+    basketTokenMint: PublicKey;
+    buyer: PublicKey;
+    basketRebalanceIntent?: PublicKey;
+}): TransactionInstruction {
+
+    const { keeper, basket, basketTokenMint, buyer } = params;
+    let rebalanceIntent = getRebalanceIntentPda(basket, buyer);
+
+    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: params.basketRebalanceIntent ?? BASKETS_V3_PROGRAM_ID, isWritable: params.basketRebalanceIntent ? true : false, 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: SystemProgram.programId, 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,53 @@
+import { PublicKey } from "@solana/web3.js";
+import { BASKETS_V3_PROGRAM_ID } from "../../constants";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { getAta, getRebalanceIntentPda } from "../pda";
+import { TransactionInstruction } from "@solana/web3.js";
+import { SystemProgram } from "@solana/web3.js";
+
+const REDEEM_TOKENS_DISCRIMINATOR = Buffer.from([83, 49, 112, 2, 105, 193, 106, 126]);
+
+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: SystemProgram.programId, isSigner: false, isWritable: false },
+    ];
+
+    // remaining accounts
+    params.tokenMints.forEach((mint) => {
+        keys.push({ pubkey: mint, isWritable: false, isSigner: false });
+        keys.push({ pubkey: getAta(owner, mint), isWritable: true, isSigner: false });
+        keys.push({ pubkey: getAta(basket, mint), isWritable: true, isSigner: false });
+    });
+
+    const discriminator = REDEEM_TOKENS_DISCRIMINATOR;
+
+    const data = discriminator;
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}

package/src/jup.ts

@@ -0,0 +1,113 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+
+export function processJupInstruction(instruction: {
+    programId: string;
+    accounts: {
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }[];
+    data: string;
+}): TransactionInstruction {
+    return {
+        programId: new PublicKey(instruction.programId),
+        keys: instruction.accounts.map((a: {
+            pubkey: string;
+            isSigner: boolean;
+            isWritable: boolean;
+        }) => ({
+            ...a,
+            pubkey: new PublicKey(a.pubkey)
+        })),
+        data: Buffer.from(instruction.data, "base64")
+    };
+}
+
+export async function getJupQuote(params: {
+    keeper: PublicKey,
+    basketMintIn: PublicKey,
+    basketMintOut: PublicKey,
+    basketAmountIn: number,
+    basketAmountOut: number,
+    swapMode: "exact_in" | "exact_out" | "ioc",
+    apiKey: string,
+    maxJupAccounts: number,
+}): Promise<{
+    mode: string,
+    inputMint: string,
+    outputMint: string,
+    inAmount: number,
+    outAmount: number,
+    swapUsdValue: number,
+    routePlan: any,
+    transaction: string,
+}> {
+    let options = {method: 'GET', headers: {'x-api-key': params.apiKey}};
+    let reqUrl = 'https://api.jup.ag/swap/v1/quote' +
+        '?inputMint=' + params.basketMintOut.toBase58() +
+        '&outputMint=' + params.basketMintIn.toBase58() +
+        '&amount=' + (params.swapMode == "exact_in" ? params.basketAmountIn : params.basketAmountOut) +
+        '&swapMode=' + (params.swapMode == "exact_in" ? "ExactOut" : "ExactIn") +
+        '&maxAccounts=' + params.maxJupAccounts;
+    let res = await fetch(reqUrl, options).then(res => res.json())
+    return res;
+}
+
+export async function getJupSwapInstructions(params: {
+    keeper: PublicKey,
+    quoteResponse: any,
+    apiKey: string,
+}): Promise<any> {
+    let reqUrl = 'https://api.jup.ag/swap/v1/swap-instructions'
+    let body = {
+        userPublicKey: params.keeper.toBase58(),
+        quoteResponse: params.quoteResponse,
+        wrapAndUnwrapSol: false,
+        useTokenLedger: true,
+    }
+    let options = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': params.apiKey
+        },
+        body: JSON.stringify(body),
+    };
+    let res = await fetch(reqUrl, options).then(res => res.json())
+    return res;
+}
+
+export async function getJupTokenLedgerAndSwapInstructions(params: {
+    keeper: PublicKey,
+    basketMintIn: PublicKey,
+    basketMintOut: PublicKey,
+    basketAmountIn: number,
+    basketAmountOut: number,
+    swapMode: "exact_in" | "exact_out" | "ioc",
+    apiKey: string,
+    maxJupAccounts: number,
+}): Promise<{
+    tokenLedgerInstruction: TransactionInstruction,
+    swapInstruction: TransactionInstruction,
+    addressLookupTableAddresses: PublicKey[],
+    quoteResponse: any,
+}> {
+    try {
+    let quoteResponse = await getJupQuote(params);
+    let swapInstructions = await getJupSwapInstructions({ ...params, quoteResponse });
+    return {
+        tokenLedgerInstruction: processJupInstruction(swapInstructions.tokenLedgerInstruction),
+        swapInstruction: processJupInstruction(swapInstructions.swapInstruction),
+        addressLookupTableAddresses: swapInstructions.addressLookupTableAddresses.map((a: string) => new PublicKey(a)),
+        quoteResponse: quoteResponse,
+    };
+    } catch (e) {
+        console.log("Error getting Jup Instructions:", params.basketMintOut.toBase58(), params.basketMintIn.toBase58(), params.basketAmountOut);
+        return {
+            tokenLedgerInstruction: undefined as any,
+            swapInstruction: undefined as any,
+            addressLookupTableAddresses: [],
+            quoteResponse: undefined,
+        };
+    }
+}