@symmetry-hq/sdk 1.0.14 → 1.0.16

package/dist/index.d.ts

@@ -391,7 +391,7 @@ export declare class SymmetryCore {
         keeper: string;
         intent: string;
         jup_token_ledger_ix?: TransactionInstruction;
-        jup_swap_ix: TransactionInstruction;
+        jup_swap_ix?: TransactionInstruction;
         jup_address_lookup_table_addresses?: PublicKey[];
     }): Promise<TxPayloadBatchSequence>;
     /**

package/dist/index.js

@@ -47,6 +47,8 @@ Object.defineProperty(exports, "isRebalanceRequired", { enumerable: true, get: f
 const pythOracle_1 = require("./states/oracles/pythOracle");
 const withdrawBasketFees_1 = require("./states/withdrawBasketFees");
 const txUtils_1 = require("./txUtils");
+const raydiumClmmOracle_1 = require("./states/oracles/raydiumClmmOracle");
+const raydiumCpmmOracle_1 = require("./states/oracles/raydiumCpmmOracle");
 class SymmetryCore {
     /**
      * Initializes the SymmetryCore SDK.
@@ -747,6 +749,26 @@ class SymmetryCore {
                 }
             }
             let intent = (0, pda_1.getIntentPda)(vault.ownAddress, intentSeedArray, editType);
+            let additionalOracleAccounts = [];
+            if (editType === intent_1.TaskType.AddToken) {
+                let addTokenData = editData;
+                for (let i = 0; i < addTokenData.oracles.length; i++) {
+                    let oracle = addTokenData.oracles[i];
+                    let oracleAccount = new web3_js_1.PublicKey(oracle.account);
+                    if (oracle.oracle_type == "example")
+                        continue;
+                    if (oracle.oracle_type == "pyth")
+                        continue;
+                    if (oracle.oracle_type == "raydium_cpmm") {
+                        let observationKey = raydiumCpmmOracle_1.RaydiumCPMMOracle.deriveObservationKey(oracleAccount, this.sdkParams.network);
+                        additionalOracleAccounts.push(observationKey[0]);
+                    }
+                    if (oracle.oracle_type == "raydium_clmm") {
+                        let observationKey = raydiumClmmOracle_1.RaydiumCLMMOracle.deriveObservationKey(oracleAccount, this.sdkParams.network);
+                        additionalOracleAccounts.push(observationKey[0]);
+                    }
+                }
+            }
             let openVaultIntentIx = (0, edit_1.createEditVaultIntentIx)({
                 manager: manager,
                 vault: vault,
@@ -759,6 +781,7 @@ class SymmetryCore {
                 minBounty: minBounty,
                 maxBounty: maxBounty,
                 tokenProgram: tokenProgram,
+                additionalOracleAccounts: additionalOracleAccounts,
             });
             let txBatchData = { batches: [[{
                             payer: manager,
@@ -768,7 +791,7 @@ class SymmetryCore {
                                 web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
                                 web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
                             ],
-                            lookupTables: [],
+                            lookupTables: [vault.lookupTables.active[0]],
                         }]] };
             // Only execute in the same transaction when there is no delay and no scheduled activation.
             if (modificationDelay.eq(new bn_js_1.default(0)) && activationTimestamp.eq(new bn_js_1.default(0))) {
@@ -781,32 +804,44 @@ class SymmetryCore {
                     keeper: manager,
                     vaultMint: vault.mint,
                 });
-                if (editType == intent_1.TaskType.MakeDirectSwap && params.jup_swap_ix) {
+                if (editType == intent_1.TaskType.MakeDirectSwap) {
+                    let mintIn = new web3_js_1.PublicKey(editData.from_token_mint);
+                    let mintOut = new web3_js_1.PublicKey(editData.to_token_mint);
+                    let mintInInfo = yield this.sdkParams.connection.getAccountInfo(mintIn);
+                    let mintOutInfo = yield this.sdkParams.connection.getAccountInfo(mintOut);
+                    let mintInProgram = mintInInfo.owner;
+                    let mintOutProgram = mintOutInfo.owner;
                     let flashParams = {
                         keeper: manager,
                         vault: vault.ownAddress,
                         rebalanceIntent: undefined,
                         intent: intent,
-                        mintIn: new web3_js_1.PublicKey(editData.from_token_mint),
-                        mintOut: new web3_js_1.PublicKey(editData.to_token_mint),
+                        mintIn: mintIn,
+                        mintOut: mintOut,
                         amountIn: new bn_js_1.default(editData.amount_from),
                         amountOut: new bn_js_1.default(editData.amount_to),
+                        mintInProgram: mintInProgram,
+                        mintOutProgram: mintOutProgram,
                         mode: undefined,
                     };
                     let ixWithdraw = (0, flashSwap_1.flashWithdrawIx)(flashParams);
                     let ixDeposit = (0, flashSwap_1.flashDepositIx)(flashParams);
+                    let managerFromATA = (0, pda_1.getAta)(manager, flashParams.mintIn, mintInProgram);
+                    let managerToATA = (0, pda_1.getAta)(manager, flashParams.mintOut, mintOutProgram);
+                    let ixs = [
+                        (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(manager, managerFromATA, manager, flashParams.mintIn, mintInProgram),
+                        (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(manager, managerToATA, manager, flashParams.mintOut, mintOutProgram),
+                        ixWithdraw,
+                    ];
+                    if (params.jup_swap_ix)
+                        ixs.push(params.jup_swap_ix);
+                    ixs.push(ixDeposit);
+                    ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }));
+                    ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }));
                     txBatchData.batches.push([{
                             payer: manager,
-                            instructions: [
-                                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(manager, (0, pda_1.getAta)(manager, flashParams.mintIn), manager, flashParams.mintIn),
-                                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(manager, (0, pda_1.getAta)(manager, flashParams.mintOut), manager, flashParams.mintOut),
-                                ixWithdraw,
-                                params.jup_swap_ix,
-                                ixDeposit,
-                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
-                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
-                            ],
-                            lookupTables: [],
+                            instructions: ixs, // TODO: use jup lookup tables
+                            lookupTables: [vault.lookupTables.active[0]],
                         }]);
                     txBatchData.batches.push([{
                             payer: manager,
@@ -815,16 +850,30 @@ class SymmetryCore {
                                 web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
                                 web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
                             ],
-                            lookupTables: [],
+                            lookupTables: [vault.lookupTables.active[0]],
                         }]);
                 }
                 else {
-                    txBatchData.batches[0][0].instructions = [
-                        ...wsolIxs,
-                        openVaultIntentIx,
-                        executeVaultIntentIx,
-                        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
-                        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                    txBatchData.batches = [
+                        [{
+                                payer: manager,
+                                instructions: [
+                                    ...wsolIxs,
+                                    openVaultIntentIx,
+                                    web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                                ],
+                                lookupTables: [vault.lookupTables.active[0]],
+                            }],
+                        [{
+                                payer: manager,
+                                instructions: [
+                                    executeVaultIntentIx,
+                                    web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                                ],
+                                lookupTables: [vault.lookupTables.active[0]],
+                            }]
                     ];
                 }
             }
@@ -889,6 +938,12 @@ class SymmetryCore {
             if (!taskData) {
                 throw new Error('Make direct swap intent is missing decoded task data');
             }
+            let mintIn = new web3_js_1.PublicKey(taskData.from_token_mint);
+            let mintOut = new web3_js_1.PublicKey(taskData.to_token_mint);
+            let mintInInfo = yield this.sdkParams.connection.getAccountInfo(mintIn);
+            let mintOutInfo = yield this.sdkParams.connection.getAccountInfo(mintOut);
+            let mintInProgram = mintInInfo.owner;
+            let mintOutProgram = mintOutInfo.owner;
             const flashParams = {
                 keeper,
                 vault: intent.vault,
@@ -899,6 +954,8 @@ class SymmetryCore {
                 amountIn: new bn_js_1.default(taskData.amount_from),
                 amountOut: new bn_js_1.default(taskData.amount_to),
                 mode: undefined,
+                mintInProgram: mintInProgram,
+                mintOutProgram: mintOutProgram,
             };
             const ixWithdraw = (0, flashSwap_1.flashWithdrawIx)(flashParams);
             const ixDeposit = (0, flashSwap_1.flashDepositIx)(flashParams);
@@ -911,14 +968,19 @@ class SymmetryCore {
                 keeper,
                 vaultMint: undefined,
             });
+            let keeperFromATA = (0, pda_1.getAta)(keeper, flashParams.mintIn, mintInProgram);
+            let keeperToATA = (0, pda_1.getAta)(keeper, flashParams.mintOut, mintOutProgram);
             const flashInstructions = [
-                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, flashParams.mintIn), keeper, flashParams.mintIn),
-                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, flashParams.mintOut), keeper, flashParams.mintOut),
+                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, keeperFromATA, keeper, mintIn, mintInProgram),
+                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, keeperToATA, keeper, mintOut, mintOutProgram),
             ];
             if (params.jup_token_ledger_ix) {
                 flashInstructions.push(params.jup_token_ledger_ix);
             }
-            flashInstructions.push(ixWithdraw, params.jup_swap_ix, ixDeposit, web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }), web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }));
+            flashInstructions.push(ixWithdraw);
+            if (params.jup_swap_ix)
+                flashInstructions.push(params.jup_swap_ix);
+            flashInstructions.push(ixDeposit, web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }), web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }));
             const txBatchData = { batches: [
                     [{
                             payer: keeper,
@@ -1071,6 +1133,8 @@ class SymmetryCore {
             //         vault: vault.ownAddress,
             //     })
             // ];
+            let tokenMintInfos = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(this.sdkParams.connection, contributions.map(contribution => contribution.mint));
+            let tokenPrograms = contributions.map(contribution => tokenMintInfos.get(contribution.mint.toBase58()).owner);
             let txBatchData = { batches: [
                     [{
                             payer: buyer,
@@ -1105,7 +1169,11 @@ class SymmetryCore {
                     (0, deposit_1.depositTokensIx)({
                         owner: buyer,
                         vault: vault.ownAddress,
-                        contributions: contributions,
+                        contributions: contributions.map((contribution, index) => ({
+                            mint: contribution.mint,
+                            amount: contribution.amount,
+                            tokenProgram: tokenPrograms[index],
+                        })),
                     }).map(ix => {
                         return {
                             payer: buyer,
@@ -1181,10 +1249,16 @@ class SymmetryCore {
                         lookupTables: [],
                     }]);
             }
+            let tokenMintInfos = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(this.sdkParams.connection, contributions.map(contribution => contribution.mint));
+            let tokenPrograms = contributions.map(contribution => tokenMintInfos.get(contribution.mint.toBase58()).owner);
             txBatchData.batches.push((0, deposit_1.depositTokensIx)({
                 owner: buyer,
                 vault: rebalanceIntentState.vault,
-                contributions: contributions,
+                contributions: contributions.map((contribution, index) => ({
+                    mint: contribution.mint,
+                    amount: contribution.amount,
+                    tokenProgram: tokenPrograms[index],
+                })),
             }).map(ix => ({
                 payer: buyer,
                 instructions: [
@@ -1710,6 +1784,10 @@ class SymmetryCore {
             let amountIn = new bn_js_1.default(params.amount_in);
             let amountOut = new bn_js_1.default(params.amount_out);
             let mode = params.mode ? params.mode : 0;
+            let mintInInfo = yield this.sdkParams.connection.getAccountInfo(mintIn);
+            let mintOutInfo = yield this.sdkParams.connection.getAccountInfo(mintOut);
+            let mintInProgram = mintInInfo.owner;
+            let mintOutProgram = mintOutInfo.owner;
             let flashParams = {
                 keeper: keeper,
                 vault: vault,
@@ -1720,13 +1798,17 @@ class SymmetryCore {
                 amountIn: amountIn,
                 amountOut: amountOut,
                 mode: mode,
+                mintInProgram: mintInProgram,
+                mintOutProgram: mintOutProgram,
             };
             let ixWithdraw = (0, flashSwap_1.flashWithdrawIx)(flashParams);
             let ixDeposit = (0, flashSwap_1.flashDepositIx)(flashParams);
             let ixs = [];
+            let keeperFromATA = (0, pda_1.getAta)(keeper, mintIn, mintInProgram);
+            let keeperToATA = (0, pda_1.getAta)(keeper, mintOut, mintOutProgram);
             ixs = ixs.concat([
-                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, mintIn), keeper, mintIn),
-                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, mintOut), keeper, mintOut),
+                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, keeperFromATA, keeper, mintIn, mintInProgram),
+                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, keeperToATA, keeper, mintOut, mintOutProgram),
             ]);
             if (params.jup_token_ledger_ix) {
                 ixs.push(params.jup_token_ledger_ix);
@@ -1765,7 +1847,7 @@ class SymmetryCore {
             let keeper = new web3_js_1.PublicKey(params.keeper);
             let rebalanceIntent = (yield this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
             let vault = yield this.fetchVault(rebalanceIntent.vault.toBase58());
-            let vaultRebalanceIntent = (0, pda_1.getRebalanceIntentPda)(vault.ownAddress, rebalanceIntent.owner);
+            let vaultRebalanceIntent = (0, pda_1.getRebalanceIntentPda)(vault.ownAddress, vault.ownAddress);
             let ix = (0, deposit_1.mintVaultIx)({
                 keeper: keeper,
                 vault: vault.ownAddress,
@@ -1834,14 +1916,18 @@ class SymmetryCore {
             }
             let batchSize = 7;
             let ixs = [];
+            let tokenMintInfos = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(this.sdkParams.connection, redeemableTokenMints);
+            let allTokenPrograms = redeemableTokenMints.map(mint => tokenMintInfos.get(mint.toBase58()).owner);
             for (let batchStart = 0; batchStart < redeemableTokenMints.length; batchStart += batchSize) {
                 let tokenMints = redeemableTokenMints.slice(batchStart, batchStart + batchSize);
+                let tokenPrograms = allTokenPrograms.slice(batchStart, batchStart + batchSize);
                 if (tokenMints.length > 0) {
                     ixs.push((0, withdraw_1.redeemTokensIx)({
                         keeper: keeper,
                         vault: rebalanceIntent.vault,
                         owner: rebalanceIntent.owner,
                         tokenMints: tokenMints,
+                        tokenPrograms: tokenPrograms,
                     }));
                 }
             }
@@ -2015,13 +2101,15 @@ class SymmetryCore {
             }
             let withdrawFeesIxs = [];
             let claimTokenFeesFromVaultIxs = [];
+            let tokenMintInfos = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(this.sdkParams.connection, vault.composition.map(composition => composition.mint));
+            let tokenPrograms = vault.composition.map(composition => tokenMintInfos.get(composition.mint.toBase58()).owner);
             claimableFeeTypes.forEach((feeType, index) => {
                 withdrawFeesIxs.push((0, claimFees_1.withdrawFeesIx)({
                     claimer,
                     vaultTokenMint: vault.mint,
                     feeType: feeType,
                 }));
-                claimTokenFeesFromVaultIxs.push(...(0, claimFees_1.claimFeeTokensFromVaultIxs)(claimer, vault.ownAddress, (0, pda_1.getWithdrawVaultFeesPda)(vault.ownAddress, feeType), claimer, owners[index], vault.composition.map(composition => composition.mint)));
+                claimTokenFeesFromVaultIxs.push(...(0, claimFees_1.claimFeeTokensFromVaultIxs)(claimer, vault.ownAddress, (0, pda_1.getWithdrawVaultFeesPda)(vault.ownAddress, feeType), claimer, owners[index], vault.composition.map(composition => composition.mint), tokenPrograms));
             });
             let txBatchData = { batches: [
                     withdrawFeesIxs.map(ix => ({
@@ -2066,7 +2154,9 @@ class SymmetryCore {
         return __awaiter(this, void 0, void 0, function* () {
             let claimer = new web3_js_1.PublicKey(params.claimer);
             let withdrawVaultFees = yield this.fetchWithdrawVaultFees(params.withdrawVaultFees);
-            let claimTokenFeesFromVaultIxs = (0, claimFees_1.claimFeeTokensFromVaultIxs)(claimer, withdrawVaultFees.vault, withdrawVaultFees.ownAddress, withdrawVaultFees.rentPayer, withdrawVaultFees.owners, withdrawVaultFees.accumulatedTokens);
+            let tokenMintInfos = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(this.sdkParams.connection, withdrawVaultFees.accumulatedTokens);
+            let tokenPrograms = withdrawVaultFees.accumulatedTokens.map(token => tokenMintInfos.get(token.toBase58()).owner);
+            let claimTokenFeesFromVaultIxs = (0, claimFees_1.claimFeeTokensFromVaultIxs)(claimer, withdrawVaultFees.vault, withdrawVaultFees.ownAddress, withdrawVaultFees.rentPayer, withdrawVaultFees.owners, withdrawVaultFees.accumulatedTokens, tokenPrograms);
             // Create batches: all claim instructions can run in parallel
             let txBatchData = { batches: [
                     claimTokenFeesFromVaultIxs.map(ix => ({

package/dist/instructions/automation/flashSwap.d.ts

@@ -9,6 +9,8 @@ export declare function flashWithdrawIx(params: {
     mintOut: PublicKey;
     amountIn: BN;
     amountOut: BN;
+    mintInProgram: PublicKey;
+    mintOutProgram: PublicKey;
     mode?: number;
 }): TransactionInstruction;
 export declare function flashDepositIx(params: {
@@ -18,4 +20,6 @@ export declare function flashDepositIx(params: {
     intent?: PublicKey;
     mintIn: PublicKey;
     mintOut: PublicKey;
+    mintInProgram: PublicKey;
+    mintOutProgram: PublicKey;
 }): TransactionInstruction;

package/dist/instructions/automation/flashSwap.js

@@ -11,10 +11,10 @@ const FLASH_DEPOSIT_DISCRIMINATOR = Buffer.from([21, 4, 89, 84, 131, 84, 128, 21
 function flashWithdrawIx(params) {
     var _a, _b;
     const { keeper, vault, mintIn, mintOut, amountIn, amountOut, mode } = params;
-    let keeperFromATA = (0, pda_1.getAta)(keeper, mintIn);
-    let keeperToATA = (0, pda_1.getAta)(keeper, mintOut);
-    let vaultInATA = (0, pda_1.getAta)(vault, mintIn);
-    let vaultOutATA = (0, pda_1.getAta)(vault, mintOut);
+    let keeperFromATA = (0, pda_1.getAta)(keeper, mintIn, params.mintInProgram);
+    let keeperToATA = (0, pda_1.getAta)(keeper, mintOut, params.mintOutProgram);
+    let vaultInATA = (0, pda_1.getAta)(vault, mintIn, params.mintInProgram);
+    let vaultOutATA = (0, pda_1.getAta)(vault, mintOut, params.mintOutProgram);
     const keys = [
         { pubkey: params.keeper, isWritable: true, isSigner: true },
         { pubkey: params.vault, isWritable: true, isSigner: false },
@@ -44,10 +44,10 @@ function flashWithdrawIx(params) {
 }
 function flashDepositIx(params) {
     const { keeper, vault, mintIn, mintOut } = params;
-    let keeperFromATA = (0, pda_1.getAta)(keeper, mintIn);
-    let keeperToATA = (0, pda_1.getAta)(keeper, mintOut);
-    let vaultInATA = (0, pda_1.getAta)(vault, mintIn);
-    let vaultOutATA = (0, pda_1.getAta)(vault, mintOut);
+    let keeperFromATA = (0, pda_1.getAta)(keeper, mintIn, params.mintInProgram);
+    let keeperToATA = (0, pda_1.getAta)(keeper, mintOut, params.mintOutProgram);
+    let vaultInATA = (0, pda_1.getAta)(vault, mintIn, params.mintInProgram);
+    let vaultOutATA = (0, pda_1.getAta)(vault, mintOut, params.mintOutProgram);
     const keys = [
         { pubkey: params.keeper, isWritable: true, isSigner: true },
         { pubkey: params.vault, isWritable: true, isSigner: false },

package/dist/instructions/management/claimFees.d.ts

@@ -11,5 +11,6 @@ export declare function claimFeeTokensFromVaultIx(params: {
     rentPayer: PublicKey;
     owners: PublicKey[];
     tokenMints: PublicKey[];
+    tokenPrograms: PublicKey[];
 }): TransactionInstruction;
-export declare function claimFeeTokensFromVaultIxs(signer: PublicKey, vault: PublicKey, withdrawVaultFees: PublicKey, rentPayer: PublicKey, owners: PublicKey[], tokenMints: PublicKey[]): TransactionInstruction[];
+export declare function claimFeeTokensFromVaultIxs(signer: PublicKey, vault: PublicKey, withdrawVaultFees: PublicKey, rentPayer: PublicKey, owners: PublicKey[], tokenMints: PublicKey[], tokenPrograms: PublicKey[]): TransactionInstruction[];

package/dist/instructions/management/claimFees.js

@@ -56,8 +56,8 @@ function claimFeeTokensFromVaultIx(params) {
     // Remaining accounts: for each token: (mint, vaultAta, claimer1Ata, claimer2Ata, ...)
     for (let i = 0; i < tokenMints.length; i++) {
         const mint = tokenMints[i];
-        const vaultAta = (0, pda_1.getAta)(vault, mint);
-        const claimerATAs = owners.map(owner => (0, pda_1.getAta)(owner, mint));
+        const vaultAta = (0, pda_1.getAta)(vault, mint, params.tokenPrograms[i]);
+        const claimerATAs = owners.map(owner => (0, pda_1.getAta)(owner, mint, params.tokenPrograms[i]));
         keys.push({ pubkey: mint, isWritable: false, isSigner: false });
         keys.push({ pubkey: vaultAta, isWritable: true, isSigner: false });
         for (let j = 0; j < numOwners; j++) {
@@ -70,7 +70,7 @@ function claimFeeTokensFromVaultIx(params) {
         data,
     });
 }
-function claimFeeTokensFromVaultIxs(signer, vault, withdrawVaultFees, rentPayer, owners, tokenMints) {
+function claimFeeTokensFromVaultIxs(signer, vault, withdrawVaultFees, rentPayer, owners, tokenMints, tokenPrograms) {
     if (owners.length === 0 || tokenMints.length === 0)
         return [];
     // Account limit: 8 fixed accounts + (owners + 2) * number_of_mints <= 30
@@ -82,6 +82,7 @@ function claimFeeTokensFromVaultIxs(signer, vault, withdrawVaultFees, rentPayer,
     let ixs = [];
     for (let i = 0; i < tokenMints.length; i += maxTokensPerTx) {
         const batchTokenMints = tokenMints.slice(i, i + maxTokensPerTx);
+        const batchTokenPrograms = tokenPrograms.slice(i, i + maxTokensPerTx);
         ixs.push(claimFeeTokensFromVaultIx({
             signer: signer,
             vault: vault,
@@ -89,6 +90,7 @@ function claimFeeTokensFromVaultIxs(signer, vault, withdrawVaultFees, rentPayer,
             rentPayer: rentPayer,
             owners: owners,
             tokenMints: batchTokenMints,
+            tokenPrograms: batchTokenPrograms,
         }));
     }
     return ixs;

package/dist/instructions/management/edit.d.ts

@@ -31,6 +31,7 @@ export declare function createEditVaultIntentIx(params: {
     minBounty: BN;
     maxBounty: BN;
     tokenProgram?: PublicKey;
+    additionalOracleAccounts?: PublicKey[];
 }): TransactionInstruction;
 export declare function executeEditVaultIntentIx(params: {
     keeper: PublicKey;

package/dist/instructions/management/edit.js

@@ -324,6 +324,16 @@ function createEditVaultIntentIx(params) {
                 isWritable: true,
                 isSigner: false
             });
+            additionalAccounts.push({
+                pubkey: constants_1.PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT,
+                isWritable: true,
+                isSigner: false
+            });
+            additionalAccounts.push({
+                pubkey: constants_1.PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT,
+                isWritable: true,
+                isSigner: false
+            });
             for (let i = 0; i < addTokenData.oracles.length; i++) {
                 additionalAccounts.push({
                     pubkey: new web3_js_1.PublicKey(addTokenData.oracles[i].account),
@@ -331,6 +341,13 @@ function createEditVaultIntentIx(params) {
                     isSigner: false
                 });
             }
+            if (params.additionalOracleAccounts)
+                for (let i = 0; i < params.additionalOracleAccounts.length; i++)
+                    additionalAccounts.push({
+                        pubkey: params.additionalOracleAccounts[i],
+                        isWritable: true,
+                        isSigner: false
+                    });
             additionalAccounts.push({
                 pubkey: constants_1.ADDRESS_LOOKUP_TABLE_PROGRAM_ID,
                 isWritable: false,

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

@@ -5,6 +5,7 @@ export declare function depositTokensIx(params: {
     contributions: {
         mint: PublicKey;
         amount: number;
+        tokenProgram: PublicKey;
     }[];
 }): TransactionInstruction[];
 export declare function lockDepositsIx(params: {

package/dist/instructions/user/deposit.js

@@ -39,8 +39,8 @@ function depositTokensIx(params) {
         // remaining accounts
         batch_contributions.forEach((contribution) => {
             let mint = contribution.mint;
-            let ownerAta = (0, pda_1.getAta)(owner, mint);
-            let vaultAta = (0, pda_1.getAta)(vault, mint);
+            let ownerAta = (0, pda_1.getAta)(owner, mint, contribution.tokenProgram);
+            let vaultAta = (0, pda_1.getAta)(vault, mint, contribution.tokenProgram);
             keys.push({ pubkey: mint, isSigner: false, isWritable: false });
             keys.push({ pubkey: ownerAta, isSigner: false, isWritable: true });
             keys.push({ pubkey: vaultAta, isSigner: false, isWritable: true });

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

@@ -5,4 +5,5 @@ export declare function redeemTokensIx(params: {
     vault: PublicKey;
     owner: PublicKey;
     tokenMints: PublicKey[];
+    tokenPrograms: PublicKey[];
 }): TransactionInstruction;

package/dist/instructions/user/withdraw.js

@@ -8,7 +8,7 @@ const web3_js_1 = require("@solana/web3.js");
 const web3_js_2 = require("@solana/web3.js");
 const REDEEM_TOKENS_DISCRIMINATOR = Buffer.from([83, 49, 112, 2, 105, 193, 106, 126]);
 function redeemTokensIx(params) {
-    const { keeper, vault, owner, } = params;
+    const { keeper, vault, owner, tokenMints, tokenPrograms, } = params;
     let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(vault, owner);
     const keys = [
         { pubkey: keeper, isSigner: true, isWritable: true },
@@ -21,10 +21,10 @@ function redeemTokensIx(params) {
         { pubkey: web3_js_2.SystemProgram.programId, isSigner: false, isWritable: false },
     ];
     // remaining accounts
-    params.tokenMints.forEach((mint) => {
+    tokenMints.forEach((mint, index) => {
         keys.push({ pubkey: mint, isWritable: false, isSigner: false });
-        keys.push({ pubkey: (0, pda_1.getAta)(owner, mint), isWritable: true, isSigner: false });
-        keys.push({ pubkey: (0, pda_1.getAta)(vault, mint), isWritable: true, isSigner: false });
+        keys.push({ pubkey: (0, pda_1.getAta)(owner, mint, tokenPrograms[index]), isWritable: true, isSigner: false });
+        keys.push({ pubkey: (0, pda_1.getAta)(vault, mint, tokenPrograms[index]), isWritable: true, isSigner: false });
     });
     const discriminator = REDEEM_TOKENS_DISCRIMINATOR;
     const data = discriminator;

package/dist/src/instructions/pda.js

@@ -19,11 +19,11 @@ exports.getMetadataAccount = getMetadataAccount;
 exports.getLookupTableAccount = getLookupTableAccount;
 exports.getLookupTableInfoAccount = getLookupTableInfoAccount;
 exports.getAta = getAta;
+const crypto_1 = require("crypto");
 const bn_js_1 = __importDefault(require("bn.js"));
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const constants_1 = require("../constants");
-const crypto_1 = require("../runtime/crypto");
 exports.GLOBAL_CONFIG_SEED = Buffer.from("global_config");
 exports.VAULT_FEES_SEED = Buffer.from("basket_fees");
 exports.WITHDRAW_VAULT_FEES_SEED = Buffer.from("withdraw_basket_fees");
@@ -47,7 +47,7 @@ function serializeString(input) {
     return out;
 }
 function getRandomSeed() {
-    return Array.from((0, crypto_1.getSecureRandomBytes)(16));
+    return Array.from((0, crypto_1.randomBytes)(16));
 }
 function getVaultTokenMintPda(vaultId) {
     return web3_js_1.PublicKey.findProgramAddressSync([

package/dist/src/keeperRebalaneHandler.d.ts

@@ -0,0 +1,32 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Wallet } from "./txUtils";
+import { Basket, UIRebalanceIntent } from ".";
+export declare class RebalanceHandler {
+    private params;
+    private intent;
+    private basket;
+    constructor(params: {
+        intent: UIRebalanceIntent;
+        basket: Basket;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    });
+    delay: (ms: number) => Promise<unknown>;
+    refresh(): Promise<void>;
+    static run(params: {
+        intentPubkey: PublicKey;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    }): Promise<void>;
+    private execute;
+}