@symmetry-hq/temp-v3-sdk 0.0.1

package/dist/states/basket.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchBasket = fetchBasket;
+exports.fetchBaskets = fetchBaskets;
+const web3_js_1 = require("@solana/web3.js");
+const basket_1 = require("../layouts/basket");
+const idl_1 = require("../idl/idl");
+function fetchBasket(connection, basketAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const basket = yield connection.getAccountInfo(basketAddress);
+        if (!basket) {
+            throw new Error("Basket not found");
+        }
+        return basket_1.BasketLayout.decode(basket.data);
+    });
+}
+function fetchBaskets(connection, filters) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(basket_1.BasketLayout.getSpan());
+        console.log(basket_1.LookupTablesLayout.getSpan());
+        console.log(basket_1.AssetLayout.getSpan());
+        let accountFilters = [
+            { dataSize: 8 + basket_1.BasketLayout.getSpan() },
+        ];
+        for (const filter of filters) {
+            if (filter.filterType === "host") {
+                accountFilters.push({ memcmp: {
+                        offset: 8 + 1 + 16 + 32 + 32 + 8 + 16 + 8,
+                        bytes: filter.filterValue.toBase58()
+                    } });
+            }
+            else if (filter.filterType === "creator") {
+                accountFilters.push({ memcmp: {
+                        offset: 8 + 1 + 16 + 32 + 32 + 8 + 16 + 8 + 32,
+                        bytes: filter.filterValue.toBase58()
+                    } });
+            }
+        }
+        const accounts = yield connection
+            .getProgramAccounts(new web3_js_1.PublicKey(idl_1.IDL.address), {
+            commitment: "confirmed",
+            filters: accountFilters,
+            encoding: 'base64'
+        });
+        const baskets = accounts.map(account => basket_1.BasketLayout.decode(account.account.data.slice(8)));
+        return baskets;
+    });
+}

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const src_1 = require("./src");
+const anchor_1 = require("@coral-xyz/anchor");
+let connection = new web3_js_1.Connection("https://api.devnet.solana.com");
+function testStates() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let sdk = new src_1.BasketsSdk({
+            connection: connection,
+        });
+        console.log("SDK created");
+        let x = yield sdk.createBasketTx({
+            creator: web3_js_1.PublicKey.default,
+            host: web3_js_1.PublicKey.default,
+            startPrice: { exponent: new anchor_1.BN(1), numerator: new anchor_1.BN(1) },
+            hostFees: { hostDepositFeeBps: 0, hostManagementFeeBps: 0, hostPerformanceFeeBps: 0 },
+            metadataParams: { name: "Test Basket", symbol: "TB", uri: "https://test.com" },
+            metadataModificationDelay: new anchor_1.BN(0),
+        });
+        console.log(x);
+        let baskets = yield sdk.fetchAllBaskets();
+        console.log(baskets.map(basket => basket.ownAddress.toBase58()));
+        let intents = yield sdk.fetchAllIntents();
+        console.log(intents.map(intent => intent.manager.toBase58()));
+        let rebalanceIntents = yield sdk.fetchAllRebalanceIntents();
+        console.log(rebalanceIntents.map(rebalanceIntent => rebalanceIntent.owner.toBase58()));
+    });
+}
+testStates();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@symmetry-hq/temp-v3-sdk",
+  "version": "0.0.1",
+  "description": "Symmetry Baskets V3 SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepare": "npm run build",
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "symmetry",
+    "baskets",
+    "sdk"
+  ],
+  "author": "Sandstorm",
+  "license": "ISC",
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1",
+    "@coral-xyz/borsh": "^0.31.1",
+    "@metaplex-foundation/js": "^0.20.1",
+    "@pythnetwork/hermes-client": "^2.1.0",
+    "@pythnetwork/pyth-solana-receiver": "^0.13.0",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
+    "decimal.js": "^10.6.0",
+    "uuid": "^13.0.0"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,24 @@
+import { BN } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+
+
+export const BASKETS_V3_PROGRAM_ID = new PublicKey("BASKT7aKd8n7ibpUbwLP3Wiyxyi3yoiXsxBk4Hpumate");
+
+export const METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+export const ADDRESS_LOOKUP_TABLE_PROGRAM_ID = new PublicKey("AddressLookupTab1e1111111111111111111111111");
+export const RENT_SYSVAR_ID = new PublicKey("SysvarRent111111111111111111111111111111111");
+
+export const WSOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
+// export const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+export const USDC_MINT = new PublicKey("USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNXemT");
+export const PYTH_SOL_ACCOUNT = new PublicKey("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE");
+export const PYTH_USDC_ACCOUNT = new PublicKey("Dpw1EAVrSB1ibxiDQyTAW6Zip3J4Btk2x4SgApQCeFbX");
+
+export const BOUNTY_MINT =  new PublicKey("49hY35FvJ8KimFrkGL1X89GSve1C1ZVoLPeQBUHXCouy");
+
+export const INTENT_TASK_DATA_SIZE = 600;
+export const MAX_MANAGERS_PER_BASKET = 10;
+
+export const MAX_SUPPORTED_TOKENS_PER_BASKET: number = 100;
+export const MAX_ORACLES_PER_TOKEN: number = 4;
+export const MAX_EXTRA_DATA_PER_ORACLE: number = 4;

package/src/index.ts

@@ -0,0 +1,260 @@
+import { AnchorProvider, BN, Program, Wallet } from '@coral-xyz/anchor';
+import { Connection, Keypair, PublicKey, TransactionSignature } from '@solana/web3.js';
+
+import { BOUNTY_MINT } from './constants';
+import {
+    createBasketIx, createBasketStateAccountIx, resizeBasketStateIx
+} from './instructions/management/createBasket';
+import { createEditBasketIntentIx, editBasketIx } from './instructions/management/edit';
+import {
+    getBasketState, getBasketTokenMintPda, getIntentPda, getLookupTableAccount, getMetadataAccount,
+    getRandomSeed
+} from './instructions/pda';
+import { Basket } from './layouts/basket';
+import { Fraction } from './layouts/fraction';
+import { EditData, HostFees, Intent, MetadataParams, TaskType } from './layouts/intents/intent';
+import { RebalanceIntent } from './layouts/intents/rebalanceIntent';
+import { fetchBasket, fetchBaskets } from './states/basket';
+import { fetchIntents } from './states/intents/intent';
+import { fetchRebalanceIntents } from './states/intents/rebalanceIntent';
+import { prepareV0Transactions, sendV0Transactions, VersionedTxs } from './txUtils';
+
+export const COMPUTE_UNITS = 1_000_000;
+export const PRIORITY_FEE = 100_000;
+export const JUPITER_API_KEY = "https://quote-api.jup.ag/v6/";
+export const MAX_JUPITER_ACCOUNTS = 35;
+
+
+export class BasketsSdk {
+
+    private sdkParams: {
+        payer: PublicKey,
+        connection: Connection,
+        priorityFee: number,
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+    }
+
+    constructor(params: {
+        connection: Connection,
+        payer?: PublicKey,
+        priorityFee?: number,
+        jupiterApiKey?: string,
+        maxAllowedAccounts?: number,
+    }) {
+        this.sdkParams = {
+            connection: params.connection,
+            payer: params.payer ?? Keypair.generate().publicKey,
+            priorityFee: params.priorityFee ?? PRIORITY_FEE,
+            jupiterApiKey: params.jupiterApiKey ?? JUPITER_API_KEY,
+            maxAllowedAccounts: params.maxAllowedAccounts ?? MAX_JUPITER_ACCOUNTS,
+        };
+    }
+
+    async setPayer(payer: PublicKey) {
+        this.sdkParams.payer = payer;
+    }
+
+    async getBasket(params: {
+        basket: PublicKey;
+    }): Promise<Basket> {
+        const basketState = await fetchBasket(this.sdkParams.connection, params.basket);
+        return basketState;
+    }
+
+    async fetchAllBaskets(): Promise<Basket[]> {
+        const baskets = await fetchBaskets(this.sdkParams.connection, []);
+        return baskets;
+    }
+
+    async fetchAllIntents(): Promise<Intent[]> {
+        const intents = await fetchIntents(this.sdkParams.connection, []);
+        return intents;
+    }
+
+    async fetchAllRebalanceIntents(): Promise<RebalanceIntent[]> {
+        const rebalanceIntents = await fetchRebalanceIntents(this.sdkParams.connection, []);
+        return rebalanceIntents;
+    }
+
+    async createBasketTx(params: {
+        creator: PublicKey, 
+        host: PublicKey, 
+        startPrice: Fraction,
+        hostFees: HostFees,
+        metadataParams: MetadataParams,
+        metadataModificationDelay: BN,
+    }): Promise<VersionedTxs> {
+        const {
+            creator,
+            host,
+            startPrice,
+            hostFees,
+            metadataParams,
+            metadataModificationDelay
+        } = params;
+
+        // generate random seed
+        const basketSeeds = getRandomSeed();
+        let basket = getBasketState(basketSeeds);
+        const slot = await this.sdkParams.connection.getSlot();
+        
+        let ix = createBasketIx({
+            basket,
+            seed: basketSeeds,
+            slot,
+            creator,
+            host,
+            startPrice,
+            hostFees,
+            metadataParams,
+            metadataModificationDelay
+        });
+
+        let preIx = createBasketStateAccountIx({
+            creator,
+            seed: basketSeeds,
+            basket
+        });
+
+        let preIx2 = resizeBasketStateIx({
+            basket
+        });
+
+        let vtxs = await prepareV0Transactions({
+            connection: this.sdkParams.connection,
+            payer: creator,
+            priorityFee: this.sdkParams.priorityFee ?? 1000000,
+            multipleIxs: [[preIx, preIx2, preIx2, ix]],
+            multipleLookupTableAddresses: [],
+            signers: [[]],
+            batches: [1],
+        });
+
+        return vtxs;
+    }
+
+
+    async createEditBasketIntentTx(params: {
+        manager: PublicKey,
+        basket: Basket,
+        editType: TaskType,
+        editData: EditData,
+        useBounty: number,
+    }): Promise<VersionedTxs>{
+        const {
+            manager,
+            basket,
+            editType,
+            editData,
+            useBounty
+        } = params;
+
+        let ix = createEditBasketIntentIx({
+            manager,
+            basket: basket.ownAddress,
+            bountyMint: BOUNTY_MINT,
+            editType,
+            editData,
+            useBounty
+        });
+      
+        let ix2 = null; 
+        let modificationDelay;
+        
+        switch(editType) {
+            case 1: modificationDelay = basket.settings.schedule.modificationDelay;
+            case 2: modificationDelay = basket.settings.feeSettings.modificationDelay;
+            case 3: modificationDelay = basket.settings.managerSettings.modificationDelay;
+            case 4: modificationDelay = basket.settings.automationSettings.modificationDelay;
+            case 5: modificationDelay = basket.settings.lpSettings.modificationDelay;
+            case 6: modificationDelay = basket.settings.metadataSettings.modificationDelay;
+            case 7: modificationDelay = basket.settings.addTokenDelay;
+            case 8: modificationDelay = basket.settings.updateWeightsDelay;
+            case 9: modificationDelay = basket.settings.addTokenDelay;
+            case 10: modificationDelay = basket.settings.updateWeightsDelay;
+            case 11: modificationDelay = basket.settings.makeDirectSwapDelay;
+        }
+
+        if(modificationDelay.eq(new BN(0))){
+            let intent = getIntentPda(basket.ownAddress, manager, editType);
+            let basketTokenMint = getBasketTokenMintPda(basket.ownAddress);
+            let metadataAccount = getMetadataAccount(basketTokenMint);
+            ix2 = editBasketIx({
+                keeper: manager,
+                basket: basket.ownAddress,
+                intent,
+                bountyMint: BOUNTY_MINT,
+                manager,
+                editType,
+                metadataAccount
+            });
+        }
+
+        let ixs = [];
+        if(ix2 === null)
+            ixs = [[ix]];
+        else ixs = [[ix, ix2]];
+        const signers = ixs.map(() => []);
+        let vtxs = await prepareV0Transactions({
+            connection: this.sdkParams.connection,
+            payer: manager,
+            priorityFee: this.sdkParams.priorityFee,
+            multipleIxs: ixs,
+            multipleLookupTableAddresses: [],
+            signers,
+            batches: [1],
+        });
+
+        return vtxs;
+    }
+
+    async createEditBasketTx(params: {
+        keeper: PublicKey,
+        basket: PublicKey,
+        manager: PublicKey,
+        editType: TaskType,
+    }): Promise<VersionedTxs> {
+        const {
+            keeper,
+            basket,
+            manager,
+            editType
+        } = params;
+        let intent = getIntentPda(basket, manager, editType);
+        let basketTokenMint = getBasketTokenMintPda(basket);
+        let metadataAccount = getMetadataAccount(basketTokenMint);
+        
+        let ix = editBasketIx({
+            keeper,
+            basket,
+            intent,
+            bountyMint: BOUNTY_MINT,
+            manager,
+            editType,
+            metadataAccount
+        });
+
+        let vtxs = await prepareV0Transactions({
+            connection: this.sdkParams.connection,
+            payer: manager,
+            priorityFee: this.sdkParams.priorityFee,
+            multipleIxs: [[ix]],
+            multipleLookupTableAddresses: [],
+            signers: [[]],
+            batches: [1],
+        });
+
+        return vtxs;
+    }
+
+    async signAndSendVersionedTxs(params: {
+        vtxs: VersionedTxs,
+        wallet: Wallet,
+    }): Promise<TransactionSignature[]> {
+        const { vtxs, wallet } = params;
+        vtxs.versionedTxs = await wallet.signAllTransactions(vtxs.versionedTxs);
+        return await sendV0Transactions(this.sdkParams.connection, vtxs, false);
+    }
+
+}

package/src/instructions/automation/auction.ts

@@ -0,0 +1,55 @@
+import {
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_2022_PROGRAM_ID,
+    TOKEN_PROGRAM_ID
+} from '@solana/spl-token';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { BASKETS_V3_PROGRAM_ID } from '../../constants';
+import { SystemProgram } from '@solana/web3.js';
+import { getAta, getBountyVaultPda, getGlobalConfigPda, getRebalanceIntentPda, getRentPayerPda } from '../pda';
+
+
+const CREATE_AUCTION_DISCRIMINATOR = Buffer.from([50, 37, 7, 103, 80, 100, 162, 13]);
+
+export function createAuctionIx(params: {
+    keeper: PublicKey,
+    basket: PublicKey,
+    bountyMint: PublicKey,
+}): TransactionInstruction {
+    const { keeper, basket, bountyMint } = params;
+    let bountyVault = getBountyVaultPda();
+    
+    let bountyVaultAta = getAta(bountyMint, bountyVault);
+    let rebalanceIntent = getRebalanceIntentPda(basket, basket);
+
+    let rentPayerPda = getRentPayerPda();
+
+    let globalConfig = getGlobalConfigPda();
+
+    let keeperBountyATA = getAta(keeper, bountyMint);
+
+    const data = CREATE_AUCTION_DISCRIMINATOR;
+
+    const keys = [
+      { pubkey: keeper, isWritable: true, isSigner: true },
+      { pubkey: basket, isWritable: true, isSigner: false },
+      { pubkey: rebalanceIntent, isWritable: true, isSigner: false },
+      { pubkey: rentPayerPda, isWritable: true, isSigner: false },
+      { pubkey: globalConfig, isWritable: false, isSigner: false },
+      { pubkey: bountyMint, isWritable: false, isSigner: false },
+      { pubkey: keeperBountyATA, isWritable: true, isSigner: false },
+      { pubkey: bountyVault, isWritable: true, isSigner: false },
+      { pubkey: bountyVaultAta, isWritable: true, isSigner: false },
+      { pubkey: SystemProgram.programId, isWritable: 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: rebalanceIntent, isWritable: true, isSigner: false }
+    ];
+
+  return new TransactionInstruction({
+      keys,
+      programId: BASKETS_V3_PROGRAM_ID,
+      data,
+  });
+}

package/src/instructions/automation/claimBounty.ts

@@ -0,0 +1,69 @@
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { SystemProgram, TransactionInstruction } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
+import { getAta, getBountyVaultPda, getGlobalConfigPda } from "../pda";
+import { BASKETS_V3_PROGRAM_ID } from "../../constants";
+
+
+export const CLAIM_BOUNTY_HANDLER_DISCRIMINATOR = Buffer.from([13, 252, 98, 119, 169, 40, 250, 254]);
+
+export function claimBountyIx(params: {
+    keeper: PublicKey;
+    basket: PublicKey;
+    intent: PublicKey;
+    bountyMint: PublicKey;
+    bountyDepositor: PublicKey;
+    rentPayer: PublicKey;
+    keepers: PublicKey[];
+}): TransactionInstruction {
+    const {
+        keeper,
+        basket,
+        intent,
+        bountyMint,
+        bountyDepositor,
+        rentPayer,
+        keepers
+    } = params;
+
+
+    let bountyVault = getBountyVaultPda();
+
+    let globalConfig = getGlobalConfigPda();
+
+    let keeperBountyAta = getAta(keeper, bountyMint);
+    let basketBountyAta = getAta(basket, bountyMint);
+
+    let bountyVaultAta = getAta(bountyVault, bountyMint);
+    let bountyDepositorAta = getAta(bountyDepositor, bountyMint);
+
+    const data = CLAIM_BOUNTY_HANDLER_DISCRIMINATOR;
+
+    const keys = [
+        { pubkey: keeper, isSigner: true, isWritable: true },
+        { pubkey: basket, isSigner: false, isWritable: true },
+        { pubkey: intent, isSigner: false, isWritable: true },
+        { pubkey: bountyMint, isSigner: false, isWritable: false },
+        { pubkey: keeperBountyAta, isSigner: false, isWritable: true },
+        { pubkey: basketBountyAta, isSigner: false, isWritable: true },
+        { pubkey: bountyVault, isSigner: false, isWritable: true },
+        { pubkey: bountyVaultAta, isSigner: false, isWritable: true },
+        { pubkey: bountyDepositorAta, isSigner: false, isWritable: true },
+        { pubkey: rentPayer, isSigner: false, isWritable: true },
+        { pubkey: globalConfig, isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    ]; 
+
+    keepers.forEach((keeperPubkey) => {
+      keys.push({ pubkey: keeperPubkey, isWritable: true, isSigner: false });
+      const remKeeperATA = getAta(keeperPubkey, bountyMint);
+      keys.push({ pubkey: remKeeperATA, isWritable: true, isSigner: false });
+    });
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}

package/src/instructions/automation/priceUpdate.ts

@@ -0,0 +1,73 @@
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+
+import { BASKETS_V3_PROGRAM_ID, PYTH_SOL_ACCOUNT, PYTH_USDC_ACCOUNT } from '../../constants';
+import { getGlobalConfigPda } from '../pda';
+
+
+const START_PRICE_UPDATES_DISCRIMINATOR = Buffer.from([240, 67, 241, 88, 0, 32, 224, 184]);
+const UPDATE_TOKEN_PRICES_DISCRIMINATOR = Buffer.from([147, 87, 140, 33, 214, 189, 181, 242]);
+
+
+
+export function startPriceUpdatesIx(params: {
+    keeper: PublicKey,
+    basket: PublicKey,
+    rebalanceIntent: PublicKey
+}): TransactionInstruction {
+
+     const keys = [
+        { pubkey: params.keeper, isSigner: true, isWritable: true },
+        { pubkey: params.basket, isSigner: false, isWritable: false },
+        { pubkey: params.rebalanceIntent, isSigner: false, isWritable: true },
+    ];
+
+    const data = START_PRICE_UPDATES_DISCRIMINATOR;
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+};
+
+
+
+export function updateTokenPricesIx(params: {
+    keeper: PublicKey,
+    basket: PublicKey,
+    rebalanceIntent: PublicKey,
+    lookupTable0: PublicKey,
+    lookupTable1: PublicKey,
+    tokenIndices: number[], // length 20
+    additionalOracleAccounts: PublicKey[]
+}): TransactionInstruction {
+
+
+    let globalConfig = getGlobalConfigPda();
+
+    const data = Buffer.concat([
+        Buffer.from(UPDATE_TOKEN_PRICES_DISCRIMINATOR), // 8 bytes
+        Buffer.from(params.tokenIndices)
+    ]);
+
+    const keys = [
+        { pubkey: params.keeper, isSigner: true, isWritable: true },
+        { pubkey: params.basket, isSigner: false, isWritable: true },
+        { pubkey: params.rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: globalConfig, isSigner: false, isWritable: false },
+        { pubkey: PYTH_SOL_ACCOUNT, isSigner: false, isWritable: true },
+        { pubkey: PYTH_USDC_ACCOUNT, isSigner: false, isWritable: true },
+        { pubkey: params.lookupTable0, isSigner: false, isWritable: true },
+        { pubkey: params.lookupTable1, isSigner: false, isWritable: true },
+    ];
+
+    // remaining accounts
+
+    keys.push(...params.additionalOracleAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false })));
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data
+    });
+}

package/src/instructions/automation/rebalanceSwap.ts

@@ -0,0 +1,60 @@
+import { TransactionInstruction } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
+import { getAta, getRebalanceIntentPda } from "../pda";
+import { SYSTEM_PROGRAM_ID } from "@coral-xyz/anchor/dist/cjs/native/system";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { BN } from "@coral-xyz/anchor";
+import { BASKETS_V3_PROGRAM_ID } from "../../constants";
+
+
+
+const REBALANCE_SWAP_DISCRIMINATOR = Buffer.from([101, 122, 61, 201, 21, 165, 177, 213]);
+
+export function rebalanceSwapIx(
+    params: {
+        keeper: PublicKey;
+        basket: PublicKey;
+        mintFrom: PublicKey;
+        mintTo: PublicKey;
+        amount: number;
+        side: number; // 0 or 1 
+}): TransactionInstruction {
+
+    const { keeper, basket, mintFrom, mintTo, amount, side } = params;
+
+    let rebalanceIntent = getRebalanceIntentPda(basket, keeper);
+    let keeperFromATA = getAta(keeper, mintFrom);
+    let keeperToATA = getAta(keeper, mintTo);
+    let basketFromATA = getAta(basket, mintFrom);
+    let basketToATA = getAta(basket, mintTo);
+
+
+    const keys = [
+        { pubkey: params.keeper, isWritable: true, isSigner: true },
+        { pubkey: params.basket, isWritable: true, isSigner: false },
+        { pubkey: rebalanceIntent, isWritable: true, isSigner: false },
+        { pubkey: params.mintFrom, isWritable: false, isSigner: false },
+        { pubkey: params.mintTo, isWritable: false, isSigner: false },
+        { pubkey: keeperFromATA, isWritable: true, isSigner: false },
+        { pubkey: keeperToATA, isWritable: true, isSigner: false },
+        { pubkey: basketFromATA, isWritable: true, isSigner: false },
+        { pubkey: basketToATA, isWritable: true, isSigner: false },
+        { pubkey: SYSTEM_PROGRAM_ID, isWritable: 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 },
+    ];
+
+    const discriminator = REBALANCE_SWAP_DISCRIMINATOR;
+    
+    const amountBuffer = Buffer.from(new BN(amount).toArray("le", 8));
+    const sideBuffer = Buffer.from([side]);
+
+    const data = Buffer.concat([discriminator, amountBuffer, sideBuffer]);
+
+    return new TransactionInstruction({
+        keys,
+        programId: BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}