@symmetry-hq/temp-v3-sdk 0.0.5 → 0.0.7

package/dist/src/constants.js

@@ -15,7 +15,7 @@ exports.WSOL_MINT = new web3_js_1.PublicKey("So111111111111111111111111111111111
 exports.USDC_MINT = new web3_js_1.PublicKey("USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNXemT");
 exports.PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT = new web3_js_1.PublicKey("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE");
 exports.PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT = new web3_js_1.PublicKey("Dpw1EAVrSB1ibxiDQyTAW6Zip3J4Btk2x4SgApQCeFbX");
-exports.BOUNTY_MINT = new web3_js_1.PublicKey("49hY35FvJ8KimFrkGL1X89GSve1C1ZVoLPeQBUHXCouy");
+exports.BOUNTY_MINT = new web3_js_1.PublicKey("So11111111111111111111111111111111111111112");
 exports.INTENT_TASK_DATA_SIZE = 600;
 exports.MAX_MANAGERS_PER_BASKET = 10;
 exports.X64 = new decimal_js_1.default(2).pow(new decimal_js_1.default(64));

package/dist/src/index.d.ts

@@ -48,6 +48,43 @@ export declare class SymmetryCore {
         manager: PublicKey;
         editType: TaskType;
     }): Promise<VersionedTxs>;
+    depositTx(params: {
+        buyer: PublicKey;
+        basket: PublicKey;
+        contributions: {
+            mint: PublicKey;
+            amount: number;
+        }[];
+        rebalanceSlippageBps?: number;
+        perTradeRebalanceSlippageBps?: number;
+        executionStartTime?: number;
+    }): Promise<VersionedTxs>;
+    updateTokenPricesTx(params: {
+        keeper: PublicKey;
+        rebalanceIntent: RebalanceIntent;
+        basket: Basket;
+    }): Promise<VersionedTxs>;
+    executeSwap(params: {
+        keeper: PublicKey;
+        rebalanceIntent: RebalanceIntent;
+        mintFrom: PublicKey;
+        mintTo: PublicKey;
+        amount: number;
+        side: number;
+    }): Promise<VersionedTxs>;
+    mintTx(params: {
+        keeper: PublicKey;
+        buyer: PublicKey;
+        basket: PublicKey;
+    }): Promise<VersionedTxs>;
+    redeemTokensTx(params: {
+        keeper: PublicKey;
+        rebalanceIntent: RebalanceIntent;
+    }): Promise<VersionedTxs>;
+    claimBountyTx(params: {
+        keeper: PublicKey;
+        rebalanceIntent: RebalanceIntent;
+    }): Promise<VersionedTxs>;
     signAndSendVersionedTxs(params: {
         vtxs: VersionedTxs;
         wallet: Wallet;

package/dist/src/index.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SymmetryCore = exports.MAX_JUPITER_ACCOUNTS = exports.JUPITER_API_KEY = exports.PRIORITY_FEE = exports.COMPUTE_UNITS = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
 const createBasket_1 = require("./instructions/management/createBasket");
 const edit_1 = require("./instructions/management/edit");
 const pda_1 = require("./instructions/pda");
@@ -25,6 +26,11 @@ const intent_2 = require("./states/intents/intent");
 const rebalanceIntent_1 = require("./states/intents/rebalanceIntent");
 const txUtils_1 = require("./txUtils");
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const deposit_1 = require("./instructions/user/deposit");
+const priceUpdate_1 = require("./instructions/automation/priceUpdate");
+const rebalanceSwap_1 = require("./instructions/automation/rebalanceSwap");
+const withdraw_1 = require("./instructions/user/withdraw");
+const claimBounty_1 = require("./instructions/automation/claimBounty");
 exports.COMPUTE_UNITS = 1000000;
 exports.PRIORITY_FEE = 100000;
 exports.JUPITER_API_KEY = "https://quote-api.jup.ag/v6/";
@@ -164,6 +170,260 @@ class SymmetryCore {
             return vtxs;
         });
     }
+    depositTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { buyer, basket, contributions, rebalanceSlippageBps, perTradeRebalanceSlippageBps, executionStartTime } = params;
+            if (!rebalanceSlippageBps)
+                rebalanceSlippageBps = 100;
+            if (!perTradeRebalanceSlippageBps)
+                perTradeRebalanceSlippageBps = 100;
+            if (!executionStartTime)
+                executionStartTime = 0;
+            let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, buyer);
+            let batchIxs = [
+                [
+                    (0, deposit_1.createUserRebalanceIntentIx)({
+                        user: params.buyer,
+                        basket: params.basket,
+                    }),
+                    (0, deposit_1.resizeRebalanceIntentIx)(rebalanceIntent),
+                    (0, deposit_1.depositStateIx)({
+                        buyer,
+                        basket,
+                        bountyMint: constants_1.BOUNTY_MINT,
+                        rebalanceIntentRentPayer: buyer,
+                        rebalanceSlippageBps,
+                        perTradeRebalanceSlippageBps,
+                        executionStartTime: executionStartTime,
+                    }),
+                ]
+            ];
+            let depositTokensIxs = (0, deposit_1.depositTokensIx)({
+                owner: buyer,
+                basket: basket,
+                contributions: contributions,
+            });
+            depositTokensIxs.forEach((ix) => {
+                batchIxs.push([ix]);
+            });
+            batchIxs.push([
+                (0, deposit_1.lockDepositsIx)({
+                    owner: buyer,
+                    basket: basket,
+                }),
+                (0, priceUpdate_1.startPriceUpdatesIx)({
+                    keeper: buyer,
+                    basket: basket,
+                    rebalanceIntent: rebalanceIntent,
+                }),
+            ]);
+            // batchIxs = [batchIxs[batchIxs.length - 1]];
+            let signers = [];
+            let multipleLookupTableAddresses = [];
+            for (let i = 0; i < batchIxs.length; i++) {
+                signers.push([]);
+                multipleLookupTableAddresses.push([]);
+            }
+            let vtxs = yield (0, txUtils_1.prepareV0Transactions)({
+                connection: this.sdkParams.connection,
+                payer: buyer,
+                priorityFee: this.sdkParams.priorityFee,
+                multipleIxs: batchIxs,
+                multipleLookupTableAddresses: multipleLookupTableAddresses,
+                signers: signers,
+                batches: [1, depositTokensIxs.length, 1],
+            });
+            return vtxs;
+        });
+    }
+    updateTokenPricesTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { keeper, rebalanceIntent, basket } = params;
+            let ixs = [];
+            let signers = [];
+            let multipleLookupTableAddresses = [];
+            let batchSize = 7;
+            for (let batchStart = 0; batchStart < basket.numTokens; batchStart += batchSize) {
+                let allKeys = [];
+                let tokenIndices = [];
+                for (let i = batchStart; i < basket.numTokens && i < batchStart + batchSize; i++) {
+                    tokenIndices.push(i);
+                    let agg = basket.composition[i].oracleAggregator;
+                    for (let i = 0; i < agg.numOracles; i++) {
+                        const oracleData = agg.oracles[i];
+                        for (let j = 0; j < oracleData.oracleSettings.numRequiredAccounts; j++) {
+                            const lutId = oracleData.accountsToLoadLutIds[j];
+                            const lutIdx = oracleData.accountsToLoadLutIndices[j];
+                            if (lutId === 0 && lutIdx === 0)
+                                continue;
+                            if (!basket.lutPubkeys)
+                                continue;
+                            allKeys.push(basket.lutPubkeys[lutId].state.addresses[lutIdx]);
+                        }
+                    }
+                }
+                while (tokenIndices.length < 20)
+                    tokenIndices.push(0);
+                ixs.push([
+                    (0, priceUpdate_1.updateTokenPricesIx)({
+                        keeper: keeper,
+                        basket: rebalanceIntent.basket, //@ts-ignore
+                        rebalanceIntent: rebalanceIntent.ownAddress,
+                        lookupTable0: basket.lookupTables.active[0],
+                        lookupTable1: basket.lookupTables.active[1],
+                        tokenIndices: tokenIndices,
+                        additionalOracleAccounts: allKeys,
+                    }),
+                ]);
+                signers.push([]);
+                multipleLookupTableAddresses.push([basket.lookupTables.active[0], basket.lookupTables.active[1]]);
+                break;
+            }
+            let vtxs = yield (0, txUtils_1.prepareV0Transactions)({
+                connection: this.sdkParams.connection,
+                payer: keeper,
+                priorityFee: this.sdkParams.priorityFee,
+                multipleIxs: ixs,
+                multipleLookupTableAddresses: multipleLookupTableAddresses,
+                signers: signers,
+                batches: [ixs.length],
+            });
+            return vtxs;
+        });
+    }
+    executeSwap(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { keeper, rebalanceIntent, mintFrom, mintTo, amount, side } = params;
+            let ix = (0, rebalanceSwap_1.rebalanceSwapIx)({
+                keeper: keeper,
+                basket: rebalanceIntent.basket,
+                mintFrom: mintFrom,
+                mintTo: mintTo,
+                amount: amount,
+                side: side,
+            });
+            let vtxs = yield (0, txUtils_1.prepareV0Transactions)({
+                connection: this.sdkParams.connection,
+                payer: keeper,
+                priorityFee: this.sdkParams.priorityFee,
+                multipleIxs: [[ix]],
+                multipleLookupTableAddresses: [],
+                signers: [[]],
+                batches: [1],
+            });
+            return vtxs;
+        });
+    }
+    mintTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { keeper, buyer, basket } = params;
+            let ix = (0, deposit_1.mintBasketIx)({
+                keeper: keeper,
+                basket: basket,
+                buyer: buyer,
+            });
+            let vtxs = yield (0, txUtils_1.prepareV0Transactions)({
+                connection: this.sdkParams.connection,
+                payer: keeper,
+                priorityFee: this.sdkParams.priorityFee,
+                multipleIxs: [[ix]],
+                multipleLookupTableAddresses: [],
+                signers: [[]],
+                batches: [1],
+            });
+            return vtxs;
+        });
+    }
+    redeemTokensTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { keeper, rebalanceIntent } = params;
+            let batchSize = 7;
+            let ixs = [];
+            let signers = [];
+            let multipleLookupTableAddresses = [];
+            for (let batchStart = 0; batchStart < rebalanceIntent.tokens.length; batchStart += batchSize) {
+                let tokenMints = [];
+                for (let i = batchStart; i < rebalanceIntent.tokens.length && i < batchStart + batchSize; i++)
+                    if (rebalanceIntent.tokens[i].amount.gt(new anchor_1.BN(0)))
+                        tokenMints.push(rebalanceIntent.tokens[i].mint);
+                if (tokenMints.length > 0) {
+                    ixs.push([
+                        (0, withdraw_1.redeemTokensIx)({
+                            keeper: keeper,
+                            basket: rebalanceIntent.basket,
+                            owner: rebalanceIntent.owner,
+                            tokenMints: tokenMints,
+                        })
+                    ]);
+                    signers.push([]);
+                    multipleLookupTableAddresses.push([]);
+                }
+            }
+            let vtxs = yield (0, txUtils_1.prepareV0Transactions)({
+                connection: this.sdkParams.connection,
+                payer: keeper,
+                priorityFee: this.sdkParams.priorityFee,
+                multipleIxs: ixs,
+                multipleLookupTableAddresses: multipleLookupTableAddresses,
+                signers: signers,
+                batches: [ixs.length],
+            });
+            return vtxs;
+        });
+    }
+    claimBountyTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { keeper, rebalanceIntent } = params;
+            let keepersArray = [];
+            if (!rebalanceIntent.startPriceUpdateTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.startPriceUpdateTask.completedBy);
+            if (!rebalanceIntent.finishPriceUpdateTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.finishPriceUpdateTask.completedBy);
+            if (!rebalanceIntent.mintBasketTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.mintBasketTask.completedBy);
+            for (let i = 0; i < rebalanceIntent.priceUpdateTasks.length; i++)
+                if (!rebalanceIntent.priceUpdateTasks[i].completedBy.equals(web3_js_1.PublicKey.default))
+                    keepersArray.push(rebalanceIntent.priceUpdateTasks[i].completedBy);
+            for (let i = 0; i < rebalanceIntent.tokenSettlementTasks.length; i++)
+                if (!rebalanceIntent.tokenSettlementTasks[i].completedBy.equals(web3_js_1.PublicKey.default))
+                    keepersArray.push(rebalanceIntent.tokenSettlementTasks[i].completedBy);
+            keepersArray = Array.from(new Set(keepersArray));
+            let batchSize = 10;
+            let ixs = [];
+            let signers = [];
+            let multipleLookupTableAddresses = [];
+            for (let batchStart = 0; batchStart < keepersArray.length; batchStart += batchSize) {
+                let keepers = [];
+                for (let i = batchStart; i < keepersArray.length && i < batchStart + batchSize; i++)
+                    keepers.push(keepersArray[i]);
+                if (keepers.length > 0) {
+                    ixs.push([
+                        (0, claimBounty_1.claimBountyIx)({
+                            keeper: keeper,
+                            basket: rebalanceIntent.basket, //@ts-ignore
+                            intent: rebalanceIntent.ownAddress,
+                            bountyMint: rebalanceIntent.bounty.bountyMint,
+                            bountyDepositor: rebalanceIntent.bounty.bountyDepositor,
+                            rentPayer: rebalanceIntent.rentPayer,
+                            keepers: keepers,
+                        })
+                    ]);
+                    signers.push([]);
+                    multipleLookupTableAddresses.push([]);
+                }
+            }
+            let vtxs = yield (0, txUtils_1.prepareV0Transactions)({
+                connection: this.sdkParams.connection,
+                payer: keeper,
+                priorityFee: this.sdkParams.priorityFee,
+                multipleIxs: ixs,
+                multipleLookupTableAddresses: multipleLookupTableAddresses,
+                signers: signers,
+                batches: [ixs.length],
+            });
+            return vtxs;
+        });
+    }
     signAndSendVersionedTxs(params) {
         return __awaiter(this, void 0, void 0, function* () {
             let { vtxs, wallet } = params;

package/dist/src/instructions/management/edit.js

@@ -3,14 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.editPrivateBasketSettingsIx = editPrivateBasketSettingsIx;
 exports.createEditBasketIntentIx = createEditBasketIntentIx;
 exports.editBasketIx = editBasketIx;
-const intent_1 = require("../../layouts/intents/intent");
 const web3_js_1 = require("@solana/web3.js");
+const intent_1 = require("../../layouts/intents/intent");
+const web3_js_2 = require("@solana/web3.js");
 const constants_1 = require("../../constants");
 const pda_1 = require("../pda");
 const spl_token_1 = require("@solana/spl-token");
 const config_1 = require("../../layouts/config");
 const anchor_1 = require("@coral-xyz/anchor");
-const web3_js_2 = require("@solana/web3.js");
+const web3_js_3 = require("@solana/web3.js");
 const oracle_1 = require("../../layouts/oracle");
 const EDIT_PRIVATE_BASKET_SETTINGS_DISCRIMINATOR = Buffer.from([202, 54, 138, 17, 3, 104, 128, 229]);
 const CREATE_EDIT_BASKET_INTENT_DISCRIMINATOR = Buffer.from([82, 150, 58, 227, 153, 129, 20, 30]);
@@ -53,7 +54,7 @@ function editPrivateBasketSettingsIx(params) {
         { pubkey: globalConfig, isSigner: false, isWritable: false },
         { pubkey: constants_1.METADATA_PROGRAM_ID, isSigner: false, isWritable: false }
     ];
-    return new web3_js_1.TransactionInstruction({
+    return new web3_js_2.TransactionInstruction({
         keys,
         programId: constants_1.BASKETS_V3_PROGRAM_ID,
         data
@@ -79,6 +80,10 @@ function createEditBasketIntentIx(params) {
             break;
         case intent_1.TaskType.EditManagerSettings: // 3
             let startIndex = 0;
+            while (editData.managerSettings.managersWeightBps.length < config_1.MAX_MANAGERS_PER_BASKET) {
+                editData.managerSettings.managersWeightBps.push(0);
+                editData.managerSettings.managers.push(web3_js_1.PublicKey.default);
+            }
             for (let i = 0; i < config_1.MAX_MANAGERS_PER_BASKET; i++) {
                 let managerWeight = editData.managerSettings.managersWeightBps[i];
                 editDataBuf.writeUInt16LE(managerWeight, startIndex);
@@ -93,7 +98,9 @@ function createEditBasketIntentIx(params) {
             intent_1.AuthorityBitmasksLayout.encode(editData.authorityBitmasks, authorityBitmasksBuffer);
             editDataBuf.set(authorityBitmasksBuffer, startIndex);
             startIndex += intent_1.AuthorityBitmasksLayout.span;
-            editDataBuf.writeBigUint64LE(editData.managerSettings.modificationDelay, startIndex);
+            let modificationDelayBN = editData.managerSettings.modificationDelay;
+            editDataBuf.writeBigUint64LE(BigInt(modificationDelayBN.toString()), startIndex);
+            startIndex += 8;
             break;
         case intent_1.TaskType.EditAutomationSettings: // 4
             config_1.AutomationSettingsLayout.encode(editData, editDataBuf);
@@ -111,7 +118,21 @@ function createEditBasketIntentIx(params) {
             intent_1.UpdateWeightsDelayLayout.encode(editData, editDataBuf);
             break;
         case intent_1.TaskType.AddToken: // 9
-            oracle_1.OracleAggregatorLayout.encode(editData.oracleAggregator, editDataBuf);
+            let data = editData.oracleAggregator;
+            while (data.oracles.length < constants_1.MAX_ORACLES_PER_TOKEN) {
+                data.oracles.push({
+                    oracleSettings: oracle_1.DEFAULT_ORACLE_SETTINGS,
+                    accountsToLoadLutIds: [],
+                    accountsToLoadLutIndices: [],
+                });
+            }
+            for (let i = 0; i < data.oracles.length; i++) {
+                while (data.oracles[i].accountsToLoadLutIds.length < oracle_1.MAX_ACCOUNTS_PER_ORACLE) {
+                    data.oracles[i].accountsToLoadLutIds.push(0);
+                    data.oracles[i].accountsToLoadLutIndices.push(0);
+                }
+            }
+            oracle_1.OracleAggregatorLayout.encode(data, editDataBuf);
             additionalAccounts.push({
                 pubkey: editData.tokenMint,
                 isWritable: false,
@@ -132,11 +153,13 @@ function createEditBasketIntentIx(params) {
                 isWritable: true,
                 isSigner: false
             });
-            additionalAccounts.push({
-                pubkey: editData.oracleAccount,
-                isWritable: false,
-                isSigner: false
-            });
+            for (let i = 0; i < editData.oracleAccounts.length; i++) {
+                additionalAccounts.push({
+                    pubkey: editData.oracleAccounts[i],
+                    isWritable: false,
+                    isSigner: false
+                });
+            }
             break;
         case intent_1.TaskType.UpdateWeights: // 10
             intent_1.UpdateWeightsLayout.encode(editData, editDataBuf);
@@ -162,13 +185,13 @@ function createEditBasketIntentIx(params) {
         { pubkey: managerBountyATA, isSigner: false, isWritable: true },
         { pubkey: bountyVault, isSigner: false, isWritable: true },
         { pubkey: bountyVaultATA, isSigner: false, isWritable: true },
-        { pubkey: web3_js_2.SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: web3_js_3.SystemProgram.programId, isSigner: false, isWritable: false },
         { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
         { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
         { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
     ];
     keys.push(...additionalAccounts);
-    return new web3_js_1.TransactionInstruction({
+    return new web3_js_2.TransactionInstruction({
         keys,
         programId: constants_1.BASKETS_V3_PROGRAM_ID,
         data,
@@ -198,7 +221,7 @@ function editBasketIx(params) {
         { pubkey: managerBountyATA, isSigner: false, isWritable: true },
         { pubkey: bountyVault, isSigner: false, isWritable: true },
         { pubkey: bountyVaultATA, isSigner: false, isWritable: true },
-        { pubkey: web3_js_2.SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: web3_js_3.SystemProgram.programId, isSigner: false, isWritable: false },
         { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
         { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
         { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
@@ -210,7 +233,7 @@ function editBasketIx(params) {
         keys.push({ pubkey: constants_1.METADATA_PROGRAM_ID, isSigner: false, isWritable: false });
     }
     ;
-    return new web3_js_1.TransactionInstruction({
+    return new web3_js_2.TransactionInstruction({
         keys,
         programId: constants_1.BASKETS_V3_PROGRAM_ID,
         data,

package/dist/src/instructions/user/deposit.d.ts

@@ -11,6 +11,7 @@ export declare function depositStateIx(params: {
     bountyMint: PublicKey;
     rebalanceIntentRentPayer: PublicKey;
     rebalanceSlippageBps: number;
+    perTradeRebalanceSlippageBps: number;
     executionStartTime: number;
 }): TransactionInstruction;
 export declare function depositTokensIx(params: {
@@ -20,7 +21,7 @@ export declare function depositTokensIx(params: {
         mint: PublicKey;
         amount: number;
     }[];
-}): TransactionInstruction;
+}): TransactionInstruction[];
 export declare function lockDepositsIx(params: {
     owner: PublicKey;
     basket: PublicKey;

package/dist/src/instructions/user/deposit.js

@@ -53,7 +53,7 @@ function resizeRebalanceIntentIx(rebalanceIntent) {
     });
 }
 function depositStateIx(params) {
-    const { buyer, basket, bountyMint, rebalanceIntentRentPayer, rebalanceSlippageBps, executionStartTime, } = params;
+    const { buyer, basket, bountyMint, rebalanceIntentRentPayer, rebalanceSlippageBps, perTradeRebalanceSlippageBps, executionStartTime, } = params;
     let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, buyer);
     let basketTokenMint = (0, pda_1.getBasketTokenMintPda)(basket);
     let globalConfig = (0, pda_1.getGlobalConfigPda)();
@@ -64,11 +64,13 @@ function depositStateIx(params) {
     let buyerBasketAta = (0, pda_1.getAta)(buyer, basketTokenMint);
     const rebalanceIntentRentPayerBuf = rebalanceIntentRentPayer.toBuffer();
     const rebalanceSlippageBuf = Buffer.from(new anchor_1.BN(rebalanceSlippageBps).toArray("le", 2));
+    const perTradeRebalanceSlippageBuf = Buffer.from(new anchor_1.BN(perTradeRebalanceSlippageBps).toArray("le", 2));
     const executionStartBuf = Buffer.from(new anchor_1.BN(executionStartTime).toArray("le", 8));
     const data = Buffer.concat([
         CREATE_DEPOSIT_STATE_DISCRIMINATOR,
         rebalanceIntentRentPayerBuf,
         rebalanceSlippageBuf,
+        perTradeRebalanceSlippageBuf,
         executionStartBuf
     ]);
     const keys = [
@@ -98,31 +100,40 @@ function depositTokensIx(params) {
     const { owner, basket, contributions } = params;
     let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, owner);
     const discriminator = DEPOSIT_TOKENS_DISCRIMINATOR;
-    const amountsBuffer = Buffer.concat(contributions.map((contribution) => Buffer.from(new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-        { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
-        { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-        { pubkey: web3_js_3.SystemProgram.programId, isSigner: false, isWritable: false },
-    ];
-    // remaining accounts
-    contributions.forEach((contribution) => {
-        let mint = contribution.mint;
-        let ownerAta = (0, pda_1.getAta)(owner, mint);
-        let basketAta = (0, pda_1.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 web3_js_2.TransactionInstruction({
-        keys,
-        programId: constants_1.BASKETS_V3_PROGRAM_ID,
-        data,
-    });
+    let ixs = [];
+    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 anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: web3_js_3.SystemProgram.programId, isSigner: false, isWritable: false },
+        ];
+        // remaining accounts
+        batch_contributions.forEach((contribution) => {
+            let mint = contribution.mint;
+            let ownerAta = (0, pda_1.getAta)(owner, mint);
+            let basketAta = (0, pda_1.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 web3_js_2.TransactionInstruction({
+            keys,
+            programId: constants_1.BASKETS_V3_PROGRAM_ID,
+            data,
+        }));
+    }
+    return ixs;
 }
 function lockDepositsIx(params) {
     const { owner, basket } = params;

package/dist/src/instructions/user/withdraw.d.ts

@@ -5,6 +5,7 @@ export declare function createWithdrawStateIx(params: {
     basket: PublicKey;
     withdrawAmount: number;
     rebalanceSlippageBps: number;
+    perTradeRebalanceSlippageBps: number;
     executionStartTime: number;
     bountyMint: PublicKey;
 }): TransactionInstruction;

package/dist/src/instructions/user/withdraw.js

@@ -11,7 +11,7 @@ const web3_js_2 = require("@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]);
 function createWithdrawStateIx(params) {
-    const { seller, basket, withdrawAmount, rebalanceSlippageBps, executionStartTime, bountyMint, } = params;
+    const { seller, basket, withdrawAmount, rebalanceSlippageBps, perTradeRebalanceSlippageBps, executionStartTime, bountyMint, } = params;
     let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, seller);
     let rentPayerPda = (0, pda_1.getRentPayerPda)();
     let basketTokenMint = (0, pda_1.getBasketTokenMintPda)(basket);
@@ -25,6 +25,7 @@ function createWithdrawStateIx(params) {
         CREATE_WITHDRAW_STATE_DISCRIMINATOR,
         Buffer.from(new anchor_1.BN(withdrawAmount).toArray("le", 8)),
         Buffer.from(new anchor_1.BN(rebalanceSlippageBps).toArray("le", 2)),
+        Buffer.from(new anchor_1.BN(perTradeRebalanceSlippageBps).toArray("le", 2)),
         Buffer.from(new anchor_1.BN(executionStartTime).toArray("le", 8)),
     ]);
     const keys = [
@@ -67,10 +68,8 @@ function redeemTokensIx(params) {
     // remaining accounts
     params.tokenMints.forEach((mint) => {
         keys.push({ pubkey: mint, isWritable: false, isSigner: false });
-        const ownerAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, owner);
-        keys.push({ pubkey: ownerAta, isWritable: true, isSigner: false });
-        const basketAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, basket);
-        keys.push({ pubkey: basketAta, isWritable: true, isSigner: false });
+        keys.push({ pubkey: (0, pda_1.getAta)(owner, mint), isWritable: true, isSigner: false });
+        keys.push({ pubkey: (0, pda_1.getAta)(basket, mint), isWritable: true, isSigner: false });
     });
     const discriminator = REDEEM_TOKENS_DISCRIMINATOR;
     const data = discriminator;