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

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,21 @@ export declare class SymmetryCore {
         manager: PublicKey;
         editType: TaskType;
     }): Promise<VersionedTxs>;
+    depositTx(params: {
+        buyer: PublicKey;
+        basket: PublicKey;
+        contributions: {
+            mint: PublicKey;
+            amount: number;
+        }[];
+        rebalanceSlippageBps?: number;
+        executionStartTime?: number;
+    }): Promise<VersionedTxs>;
+    updateTokenPricesTx(params: {
+        keeper: PublicKey;
+        rebalanceIntent: RebalanceIntent;
+        basket: Basket;
+    }): 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,8 @@ 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");
 exports.COMPUTE_UNITS = 1000000;
 exports.PRIORITY_FEE = 100000;
 exports.JUPITER_API_KEY = "https://quote-api.jup.ag/v6/";
@@ -164,6 +167,119 @@ class SymmetryCore {
             return vtxs;
         });
     }
+    depositTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { buyer, basket, contributions, rebalanceSlippageBps, executionStartTime } = params;
+            if (!rebalanceSlippageBps)
+                rebalanceSlippageBps = 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: rebalanceSlippageBps,
+                        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,
+                }),
+            ]);
+            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 batches = [];
+            let batchSize = 5;
+            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([]);
+                batches.push(1);
+            }
+            let vtxs = yield (0, txUtils_1.prepareV0Transactions)({
+                connection: this.sdkParams.connection,
+                payer: keeper,
+                priorityFee: this.sdkParams.priorityFee,
+                multipleIxs: ixs,
+                multipleLookupTableAddresses: multipleLookupTableAddresses,
+                signers: signers,
+                batches: batches,
+            });
+            return vtxs;
+        });
+    }
     signAndSendVersionedTxs(params) {
         return __awaiter(this, void 0, void 0, function* () {
             let { vtxs, wallet } = params;

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

@@ -20,7 +20,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

@@ -98,31 +98,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/layouts/intents/rebalanceIntent.d.ts

@@ -30,9 +30,9 @@ export interface TokenAuction {
 }
 export declare const TokenAuctionLayout: any;
 export interface TaskCompletion {
+    completedBy: PublicKey;
     completedBounty: BN;
     completedTime: BN;
-    completedBy: PublicKey;
 }
 export declare const TaskCompletionLayout: any;
 export interface RebalanceIntent {

package/dist/src/layouts/intents/rebalanceIntent.js

@@ -36,9 +36,9 @@ exports.TokenAuctionLayout = (0, borsh_1.struct)([
 ]);
 ;
 exports.TaskCompletionLayout = (0, borsh_1.struct)([
+    (0, borsh_1.publicKey)('completedBy'),
     (0, borsh_1.u64)('completedBounty'),
     (0, borsh_1.u64)('completedTime'),
-    (0, borsh_1.publicKey)('completedBy'),
 ]);
 ;
 exports.RebalanceIntentLayout = (0, borsh_1.struct)([

package/dist/src/states/oracles/oracle.js

@@ -66,8 +66,6 @@ class PriceAggregator {
                 const lutIdx = oracleData.accountsToLoadLutIndices[j];
                 if (lutId === 0 && lutIdx === 0)
                     continue;
-                console.log(lutId, lutIdx);
-                console.log(lutAccounts[lutId]);
                 let pubkey = lutAccounts[lutId].state.addresses[lutIdx];
                 let account = accountInfoMap.get(pubkey.toBase58());
                 //@ts-ignore
@@ -98,9 +96,10 @@ class PriceAggregator {
         let prices = [];
         for (let i = 0; i < oracleResults.length; i++) {
             const pr = oracleResults[i];
-            prices.push({ price: pr.getMid(), weight: new decimal_js_1.default(agg.oracles[i].oracleSettings.weight) });
-            prices.push({ price: pr.getLow(), weight: new decimal_js_1.default(agg.oracles[i].oracleSettings.weight) });
-            prices.push({ price: pr.getHigh(), weight: new decimal_js_1.default(agg.oracles[i].oracleSettings.weight) });
+            const weight = new decimal_js_1.default(agg.oracles[i].oracleSettings.weight);
+            prices.push({ price: pr.getMid(), weight: weight });
+            prices.push({ price: pr.getLow(), weight: weight });
+            prices.push({ price: pr.getHigh(), weight: weight });
         }
         const medianPrice = weightedPercentile(prices, 50);
         const p25Price = weightedPercentile(prices, 25);

package/dist/test.js

@@ -37,6 +37,54 @@ function testStates() {
         let kp = Array.from(web3_js_1.Keypair.generate().secretKey);
         let wallet = new anchor_1.Wallet(web3_js_1.Keypair.fromSecretKey(new Uint8Array(kp)));
         console.log(wallet.publicKey);
+        // let pubkey = await createAssociatedTokenAccountIdempotent(
+        //     connection,
+        //     wallet.payer,
+        //     WSOL_MINT,
+        //     wallet.publicKey,
+        //     {commitment: "confirmed"},
+        //     TOKEN_PROGRAM_ID,
+        //     ASSOCIATED_TOKEN_PROGRAM_ID,
+        //     true,
+        // );
+        // let xxx = await createWrappedNativeAccount(
+        //     connection,
+        //     wallet.payer,
+        //     wallet.publicKey,
+        //     1100000000,
+        // );
+        // console.log(xxx);
+        // return;
+        // let intentPda = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
+        // let tx = await sdk.depositTx({
+        //     buyer: wallet.publicKey,
+        //     basket: basket.ownAddress,
+        //     contributions: [{mint: USDC_MINT, amount: 10000000}],
+        // });
+        // let resTx = await sdk.signAndSendVersionedTxs({
+        //     vtxs: tx,
+        //     wallet,
+        // });
+        // console.log(resTx);
+        // return;
+        let myIntents = yield sdk.fetchAllRebalanceIntents([
+            { filterType: "owner", filterValue: wallet.publicKey },
+            { filterType: "basket", filterValue: basket.ownAddress }
+        ]);
+        let myIntent = myIntents[0];
+        console.log(myIntent.priceUpdateTasks[0]);
+        console.log(myIntent.priceUpdateTasks[1]);
+        return;
+        let tx = yield sdk.updateTokenPricesTx({
+            keeper: wallet.publicKey,
+            rebalanceIntent: myIntent,
+            basket,
+        });
+        let resTx = yield sdk.signAndSendVersionedTxs({
+            vtxs: tx,
+            wallet,
+        });
+        console.log(resTx);
         return;
         let editWeightsTx = yield sdk.createEditBasketIntentTx({
             manager: wallet.publicKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symmetry-hq/temp-v3-sdk",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Symmetry Baskets V3 SDK",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/src/constants.ts

@@ -15,7 +15,7 @@ export const USDC_MINT = new PublicKey("USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNX
 export const PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT = new PublicKey("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE");
 export const PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT = new PublicKey("Dpw1EAVrSB1ibxiDQyTAW6Zip3J4Btk2x4SgApQCeFbX");
 
-export const BOUNTY_MINT =  new PublicKey("49hY35FvJ8KimFrkGL1X89GSve1C1ZVoLPeQBUHXCouy");
+export const BOUNTY_MINT =  new PublicKey("So11111111111111111111111111111111111111112");
 
 export const INTENT_TASK_DATA_SIZE = 600;
 export const MAX_MANAGERS_PER_BASKET = 10;

package/src/index.ts

@@ -1,24 +1,28 @@
 import { BN } from '@coral-xyz/anchor';
 import { Connection, Keypair, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
 
-import { BOUNTY_MINT } from './constants';
+import { BOUNTY_MINT, PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT } from './constants';
 import {
     createBasketIx, createBasketStateAccountIx, resizeBasketStateIx
 } from './instructions/management/createBasket';
 import { createEditBasketIntentIx, editBasketIx } from './instructions/management/edit';
 import {
     getBasketState, getBasketTokenMintPda, getIntentPda, getLookupTableAccount, getMetadataAccount,
-    getRandomSeed
+    getRandomSeed,
+    getRebalanceIntentPda,
+    getRentPayerPda
 } from './instructions/pda';
 import { Basket } from './layouts/basket';
 import { decimalToFraction, Fraction } from './layouts/fraction';
 import { EditData, HostFees, Intent, MetadataParams, TaskType } from './layouts/intents/intent';
 import { RebalanceIntent } from './layouts/intents/rebalanceIntent';
-import { BasketFilter, fetchBasket, fetchBaskets, loadBasketPrice } from './states/basket';
+import { BasketFilter, fetchBasket, fetchBaskets, getBasketOracleAccountInfos, loadBasketPrice } from './states/basket';
 import { fetchIntents, IntentFilter } from './states/intents/intent';
 import { fetchRebalanceIntents, RebalanceIntentFilter } from './states/intents/rebalanceIntent';
 import { prepareV0Transactions, sendV0Transactions, signedVersionedTxs, VersionedTxs, Wallet } from './txUtils';
 import Decimal from 'decimal.js';
+import { createUserRebalanceIntentIx, depositStateIx, depositTokensIx, lockDepositsIx, resizeRebalanceIntentIx } from './instructions/user/deposit';
+import { updateTokenPricesIx } from './instructions/automation/priceUpdate';
 
 export const COMPUTE_UNITS = 1_000_000;
 export const PRIORITY_FEE = 100_000;
@@ -220,6 +224,128 @@ export class SymmetryCore {
         return vtxs;
     }
 
+    async depositTx(params: {
+        buyer: PublicKey,
+        basket: PublicKey,
+        contributions: {mint: PublicKey, amount: number}[];
+        rebalanceSlippageBps?: number;
+        executionStartTime?: number;
+    }): Promise<VersionedTxs> {
+        let { buyer, basket, contributions, rebalanceSlippageBps, executionStartTime } = params;
+        if (!rebalanceSlippageBps)
+            rebalanceSlippageBps = 100;
+        if (!executionStartTime)
+            executionStartTime = 0;
+        let rebalanceIntent = getRebalanceIntentPda(basket, buyer);
+        let batchIxs = [
+            [
+                createUserRebalanceIntentIx({
+                    user: params.buyer,
+                    basket: params.basket,
+                }),
+                resizeRebalanceIntentIx(rebalanceIntent),
+                depositStateIx({
+                    buyer,
+                    basket,
+                    bountyMint: BOUNTY_MINT,
+                    rebalanceIntentRentPayer: buyer,
+                    rebalanceSlippageBps: rebalanceSlippageBps,
+                    executionStartTime: executionStartTime,
+                }),
+            ]
+        ];
+
+        let depositTokensIxs = depositTokensIx({
+            owner: buyer,
+            basket: basket,
+            contributions: contributions,
+        });
+        depositTokensIxs.forEach((ix) => {
+            batchIxs.push([ix]);
+        });
+
+        batchIxs.push([
+            lockDepositsIx({
+                owner: buyer,
+                basket: basket,
+            }),
+        ]);
+
+        let signers = [];
+        let multipleLookupTableAddresses = [];
+        for (let i = 0; i < batchIxs.length; i++) {
+            signers.push([]);
+            multipleLookupTableAddresses.push([]);
+        }
+        let vtxs = await prepareV0Transactions({
+            connection: this.sdkParams.connection,
+            payer: buyer,
+            priorityFee: this.sdkParams.priorityFee,
+            multipleIxs: batchIxs,
+            multipleLookupTableAddresses: multipleLookupTableAddresses,
+            signers: signers,
+            batches: [1, depositTokensIxs.length, 1],
+        });
+
+        return vtxs;
+    }
+
+    async updateTokenPricesTx(params: {
+        keeper: PublicKey,
+        rebalanceIntent: RebalanceIntent,
+        basket: Basket,
+    }): Promise<VersionedTxs> {
+        let { keeper, rebalanceIntent, basket } = params;
+        let ixs: TransactionInstruction[][] = [];
+        let signers: Keypair[][] = [];
+        let multipleLookupTableAddresses: PublicKey[][] = [];
+        let batches: number[] = [];
+        let batchSize = 5;
+        for (let batchStart = 0; batchStart < basket.numTokens; batchStart += batchSize) {
+            let allKeys: PublicKey[] = [];
+            let tokenIndices: number[] = [];
+            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([
+                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([]);
+            batches.push(1);
+        }
+        let vtxs = await prepareV0Transactions({
+            connection: this.sdkParams.connection,
+            payer: keeper,
+            priorityFee: this.sdkParams.priorityFee,
+            multipleIxs: ixs,
+            multipleLookupTableAddresses: multipleLookupTableAddresses,
+            signers: signers,
+            batches: batches,
+        });
+        return vtxs;
+    }
+
     async signAndSendVersionedTxs(params: {
         vtxs: VersionedTxs,
         wallet: Wallet,

package/src/instructions/user/deposit.ts

@@ -130,48 +130,60 @@ export function depositTokensIx(params: {
     owner: PublicKey;
     basket: PublicKey;
     contributions: {mint: PublicKey, amount: number}[]; // length 10
-}): TransactionInstruction{
+}): 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: SystemProgram.programId, 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 });
-    });
 
+    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 new TransactionInstruction({
-        keys,
-        programId: BASKETS_V3_PROGRAM_ID,
-        data,
-    });
+    return ixs;
 }
 
 
-
 export function lockDepositsIx(params: {
     owner: PublicKey;
     basket: PublicKey;

package/src/layouts/intents/rebalanceIntent.ts

@@ -48,15 +48,15 @@ export const TokenAuctionLayout = struct<TokenAuction>([
 ]);
 
 export interface TaskCompletion {
+    completedBy: PublicKey; //Pubkey
     completedBounty: BN; //u64
     completedTime: BN; //u64
-    completedBy: PublicKey; //Pubkey
 };
 
 export const TaskCompletionLayout = struct<TaskCompletion>([
+    publicKey('completedBy'),
     u64('completedBounty'),
     u64('completedTime'),
-    publicKey('completedBy'),
 ]);
 
 export interface RebalanceIntent {

package/src/states/oracles/oracle.ts

@@ -89,8 +89,6 @@ export class PriceAggregator{
                 const lutId = oracleData.accountsToLoadLutIds[j];
                 const lutIdx = oracleData.accountsToLoadLutIndices[j];
                 if (lutId === 0 && lutIdx === 0) continue;
-                console.log(lutId, lutIdx);
-                console.log(lutAccounts[lutId]);
                 let pubkey = lutAccounts[lutId].state.addresses[lutIdx];
                 let account = accountInfoMap.get(pubkey.toBase58());
                 //@ts-ignore
@@ -127,9 +125,10 @@ export class PriceAggregator{
 
         for (let i = 0; i < oracleResults.length; i++) {
             const pr = oracleResults[i];
-            prices.push({ price: pr.getMid(), weight: new Decimal(agg.oracles[i].oracleSettings.weight) });
-            prices.push({ price: pr.getLow(), weight: new Decimal(agg.oracles[i].oracleSettings.weight) });
-            prices.push({ price: pr.getHigh(), weight: new Decimal(agg.oracles[i].oracleSettings.weight) });
+            const weight = new Decimal(agg.oracles[i].oracleSettings.weight);
+            prices.push({ price: pr.getMid(), weight: weight });
+            prices.push({ price: pr.getLow(), weight: weight });
+            prices.push({ price: pr.getHigh(), weight: weight });
         }
 
         const medianPrice = weightedPercentile(prices, 50);

package/test.ts

@@ -6,6 +6,7 @@ import { decimalToFraction, fractionToDecimal } from "./src/layouts/fraction";
 import { OracleType, Quote, Side } from "./src/layouts/oracle";
 import { PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT, USDC_MINT, WSOL_MINT } from "./src/constants";
 import { TaskType } from "./src/layouts/intents/intent";
+import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
 
 
 let connection = new Connection("https://api.devnet.solana.com");
@@ -27,6 +28,59 @@ async function testStates() {
     let kp = Array.from(Keypair.generate().secretKey);
     let wallet = new Wallet(Keypair.fromSecretKey(new Uint8Array(kp)));
     console.log(wallet.publicKey);
+
+    // let pubkey = await createAssociatedTokenAccountIdempotent(
+    //     connection,
+    //     wallet.payer,
+    //     WSOL_MINT,
+    //     wallet.publicKey,
+    //     {commitment: "confirmed"},
+    //     TOKEN_PROGRAM_ID,
+    //     ASSOCIATED_TOKEN_PROGRAM_ID,
+    //     true,
+    // );
+    // let xxx = await createWrappedNativeAccount(
+    //     connection,
+    //     wallet.payer,
+    //     wallet.publicKey,
+    //     1100000000,
+    // );
+    // console.log(xxx);
+    // return;
+    // let intentPda = getRebalanceIntentPda(basket.ownAddress, wallet.publicKey);
+    
+    // let tx = await sdk.depositTx({
+    //     buyer: wallet.publicKey,
+    //     basket: basket.ownAddress,
+    //     contributions: [{mint: USDC_MINT, amount: 10000000}],
+    // });
+    // let resTx = await sdk.signAndSendVersionedTxs({
+    //     vtxs: tx,
+    //     wallet,
+    // });
+    // console.log(resTx);
+    // return;
+
+
+    let myIntents = await sdk.fetchAllRebalanceIntents([
+        {filterType: "owner", filterValue: wallet.publicKey},
+        {filterType: "basket", filterValue: basket.ownAddress}
+    ]);
+    let myIntent = myIntents[0];
+    console.log(myIntent.priceUpdateTasks[0]);
+    console.log(myIntent.priceUpdateTasks[1]);
+    return;
+
+    let tx = await sdk.updateTokenPricesTx({
+        keeper: wallet.publicKey,
+        rebalanceIntent: myIntent,
+        basket,
+    });
+    let resTx = await sdk.signAndSendVersionedTxs({
+        vtxs: tx,
+        wallet,
+    });
+    console.log(resTx);
     return;
     let editWeightsTx = await sdk.createEditBasketIntentTx({
         manager: wallet.publicKey,