@symmetry-hq/sdk 1.0.11 → 1.0.13

package/dist/src/index.js

@@ -729,6 +729,12 @@ class SymmetryCore {
                 let maxBountyPerTask = parseInt(maxBounty.toString());
                 bountyWsolAmount = maxBountyPerTask + boundBounty;
             }
+            if (editType === intent_1.TaskType.EditAutomationSettings && editData.enabled == true) {
+                let bountyBalance = parseInt(vault.settings.bountyBalance.toString());
+                let requiredBounty = parseInt(globalConfig.minBountyForVaultAutomation.toString());
+                if (bountyBalance < requiredBounty)
+                    bountyWsolAmount += 2 * requiredBounty - bountyBalance;
+            }
             let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, manager, bountyWsolAmount);
             let intentSeedArray = web3_js_1.Keypair.generate().publicKey.toBytes();
             let tokenProgram = undefined;
@@ -1367,6 +1373,16 @@ class SymmetryCore {
                     maxBountyPerTask = maxBountyAmount;
                 bountyWsolAmount = (0, rebalanceIntent_3.computeRebalanceIntentBountyAmount)(rebalanceIntent_2.RebalanceType.Vault, vault.numTokens, boundBounty, maxBountyPerTask, Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor));
             }
+            let isManager = vault.settings.creator.equals(keeper);
+            for (let i = 0; i < vault.settings.managers.managers.length; i++)
+                if (vault.settings.managers.managers[i].equals(keeper))
+                    isManager = true;
+            if (isManager) {
+                let bountyBalance = parseInt(vault.settings.bountyBalance.toString());
+                let requiredBounty = parseInt(globalConfig.minBountyForVaultAutomation.toString());
+                if (bountyBalance < requiredBounty)
+                    bountyWsolAmount += 2 * requiredBounty - bountyBalance;
+            }
             let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, keeper, bountyWsolAmount);
             const rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(vault.ownAddress, vault.ownAddress);
             let rentPayer = (0, pda_1.getRentPayerPda)();

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

@@ -153,23 +153,33 @@ function formatRebalanceIntent(rebalanceIntent, vault) {
         })),
     };
     if (vault) {
+        const auctionTokenByMint = new Map(auctionData.tokens.map(token => [token.mint, token]));
+        const mintDataTokenByMint = new Map(mintData.tokens.map(token => [token.mint, token]));
         let minRatio = 1;
-        for (let i = 0; i < vault.composition.length; i++) {
-            if (vault.composition[i].amount == 0)
+        for (const vaultToken of vault.composition) {
+            if (vaultToken.amount == 0)
                 continue;
-            let ratio = auctionData.tokens[i].amount / vault.composition[i].amount;
+            const auctionToken = auctionTokenByMint.get(vaultToken.mint);
+            if (!auctionToken)
+                continue;
+            let ratio = auctionToken.amount / vaultToken.amount;
             minRatio = Math.min(minRatio, ratio);
         }
         let mintValue = 0;
         let remainingValue = 0;
         let mintAmount = Math.floor(vault.supply_outstanding * minRatio);
-        for (let i = 0; i < vault.composition.length; i++) {
-            let contributionAmount = Math.floor(vault.composition[i].amount * minRatio);
-            contributionAmount = Math.min(contributionAmount, auctionData.tokens[i].amount);
-            mintData.tokens[i].contribution_amount = contributionAmount;
-            mintData.tokens[i].remaining_amount = auctionData.tokens[i].amount - contributionAmount;
-            mintValue += contributionAmount * auctionData.tokens[i].price;
-            remainingValue += (auctionData.tokens[i].amount - contributionAmount) * auctionData.tokens[i].price;
+        for (const vaultToken of vault.composition) {
+            const mint = vaultToken.mint;
+            const auctionToken = auctionTokenByMint.get(mint);
+            const mintDataToken = mintDataTokenByMint.get(mint);
+            if (!auctionToken || !mintDataToken)
+                continue;
+            let contributionAmount = Math.floor(vaultToken.amount * minRatio);
+            contributionAmount = Math.min(contributionAmount, auctionToken.amount);
+            mintDataToken.contribution_amount = contributionAmount;
+            mintDataToken.remaining_amount = auctionToken.amount - contributionAmount;
+            mintValue += contributionAmount * auctionToken.price;
+            remainingValue += (auctionToken.amount - contributionAmount) * auctionToken.price;
         }
         mintData.mintValue = mintValue;
         mintData.mintAmount = mintAmount;

package/dist/src/states/oracles/oracle.d.ts

@@ -20,5 +20,5 @@ export declare class PriceAggregator {
     minOraclesThresh: number;
     confMultiplier: Fraction;
     constructor(numOracles: number, oracles: OracleData[], minConfBps: number, confThreshBps: number, minOraclesThresh: number, confMultiplier: Fraction);
-    static fetch(oracleAggregator: OracleAggregator, lutAccounts: AddressLookupTableAccount[], accountInfoMap: Map<string, AccountInfo<Buffer> | null>, solPrice: OraclePrice, usdPrice: OraclePrice, pythPriceOverrides?: Map<string, OraclePrice>): OraclePrice;
+    static fetch(oracleAggregator: OracleAggregator, lutAccounts: AddressLookupTableAccount[], accountInfoMap: Map<string, AccountInfo<Buffer> | null>, wsolPrice: OraclePrice, usdcPrice: OraclePrice, pythPriceOverrides?: Map<string, OraclePrice>): OraclePrice;
 }

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

@@ -54,7 +54,7 @@ class PriceAggregator {
         if (!(0 <= this.minOraclesThresh && this.minOraclesThresh <= constants_2.U32_MAX.toNumber()))
             throw new Error(`Minimum number of oracles must be between 0 and ${constants_2.U32_MAX}`);
     }
-    static fetch(oracleAggregator, lutAccounts, accountInfoMap, solPrice, usdPrice, pythPriceOverrides) {
+    static fetch(oracleAggregator, lutAccounts, accountInfoMap, wsolPrice, usdcPrice, pythPriceOverrides) {
         let validated = true;
         const agg = oracleAggregator;
         const oracleResults = [];
@@ -62,15 +62,11 @@ class PriceAggregator {
             const oracleData = agg.oracles[i];
             const settings = oracleData.oracleSettings;
             let loadedAccounts = [];
-            let firstLoadedPubkey;
             for (let j = 0; j < settings.numRequiredAccounts; j++) {
                 const lutId = oracleData.accountsToLoadLutIds[j];
                 const lutIdx = oracleData.accountsToLoadLutIndices[j];
                 const pubkey = lutAccounts[lutId].state.addresses[lutIdx];
                 const account = accountInfoMap.get(pubkey.toBase58());
-                if (!firstLoadedPubkey) {
-                    firstLoadedPubkey = pubkey;
-                }
                 // @ts-ignore
                 loadedAccounts.push(account);
             }
@@ -95,17 +91,16 @@ class PriceAggregator {
             let result = (() => {
                 switch (settings.oracleType) {
                     case oracle_1.OracleType.Pyth:
-                        if (firstLoadedPubkey) {
-                            const override = pythPriceOverrides === null || pythPriceOverrides === void 0 ? void 0 : pythPriceOverrides.get(firstLoadedPubkey.toBase58());
-                            if (override) {
-                                return override;
-                            }
-                        }
-                        return pythOracle_1.PythOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                        const lutId = oracleData.accountsToLoadLutIds[0];
+                        const lutIdx = oracleData.accountsToLoadLutIndices[0];
+                        const pubkey = lutAccounts[lutId].state.addresses[lutIdx];
+                        const override = pythPriceOverrides === null || pythPriceOverrides === void 0 ? void 0 : pythPriceOverrides.get(pubkey.toBase58());
+                        const price = pythOracle_1.PythOracle.fetch(settings, loadedAccounts, wsolPrice, usdcPrice);
+                        return (override ? override : price);
                     case oracle_1.OracleType.RaydiumClmm:
-                        return raydiumClmmOracle_1.RaydiumCLMMOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                        return raydiumClmmOracle_1.RaydiumCLMMOracle.fetch(settings, loadedAccounts, wsolPrice, usdcPrice);
                     case oracle_1.OracleType.RaydiumCpmm:
-                        return raydiumCpmmOracle_1.RaydiumCPMMOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                        return raydiumCpmmOracle_1.RaydiumCPMMOracle.fetch(settings, loadedAccounts, wsolPrice, usdcPrice);
                     default:
                         throw new Error(`Invalid oracle type: ${settings.oracleType}`);
                 }

package/dist/src/states/oracles/pythOracle.d.ts

@@ -14,7 +14,7 @@ export interface HermesPythPriceData {
     emaConf?: string | number;
 }
 export declare function fetchHermesPythPrices(priceFeedIds: string[]): Promise<Map<string, HermesPythPriceData>>;
-export declare function buildPythOraclePriceFromHermesPriceData(oracleParams: OracleSettings, priceData: HermesPythPriceData, solPrice: OraclePrice, usdPrice: OraclePrice): OraclePrice;
+export declare function buildPythOraclePriceFromHermesPriceData(oracleParams: OracleSettings, priceData: HermesPythPriceData, wsolPrice: OraclePrice, usdcPrice: OraclePrice): OraclePrice;
 export type VerificationLevel = {
     kind: 'Partial';
     numSignatures: number;
@@ -38,6 +38,10 @@ export interface InstructionWithSigners {
     signers: Keypair[];
     computeUnits?: number;
 }
+/**
+ * Build closeEncodedVaa instruction
+ */
+export declare function buildCloseEncodedVaaInstruction(writeAuthority: PublicKey, encodedVaa: PublicKey, wormholeProgramId?: PublicKey): TransactionInstruction;
 export interface PythUpdateResult {
     postInstructions: InstructionWithSigners[];
     closeInstructions: InstructionWithSigners[];
@@ -140,5 +144,5 @@ export declare class PythState {
     static decode(buf: Buffer, offset?: number): [PythState, number];
 }
 export declare class PythOracle {
-    static fetch(oracleParams: OracleSettings, accountInfos: AccountInfo<Buffer>[], solPrice?: OraclePrice, usdPrice?: OraclePrice): OraclePrice;
+    static fetch(oracleParams: OracleSettings, accountInfos: AccountInfo<Buffer>[], wsolPrice?: OraclePrice, usdcPrice?: OraclePrice): OraclePrice;
 }

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

@@ -20,6 +20,7 @@ exports.buildFreshVaultPythPriceOverrides = buildFreshVaultPythPriceOverrides;
 exports.getRandomTipAccount = getRandomTipAccount;
 exports.buildJitoTipInstruction = buildJitoTipInstruction;
 exports.getPythPriceFeedAccountAddress = getPythPriceFeedAccountAddress;
+exports.buildCloseEncodedVaaInstruction = buildCloseEncodedVaaInstruction;
 exports.parsePriceFeedMessage = parsePriceFeedMessage;
 exports.parseAccumulatorUpdateData = parseAccumulatorUpdateData;
 exports.getSizeOfTransaction = getSizeOfTransaction;
@@ -72,17 +73,19 @@ function fetchHermesPythPrices(priceFeedIds) {
         return result;
     });
 }
-function buildPythOraclePriceFromHermesPriceData(oracleParams, priceData, solPrice, usdPrice) {
+function buildPythOraclePriceFromHermesPriceData(oracleParams, priceData, wsolPrice, usdcPrice) {
     var _a;
+    let quoteDecimals = (oracleParams.quote == oracle_1.Quote.Usdc) ? constants_1.USDC_DECIMALS : ((oracleParams.quote == oracle_1.Quote.Wsol) ? constants_1.WSOL_DECIMALS : 0);
     let pr = new decimal_js_1.default(priceData.price.toString())
-        .mul(decimal_js_1.default.pow(10, priceData.expo - oracleParams.tokenDecimals));
+        .mul(decimal_js_1.default.pow(10, priceData.expo - oracleParams.tokenDecimals + quoteDecimals));
     let ema = new decimal_js_1.default(((_a = priceData.emaPrice) !== null && _a !== void 0 ? _a : priceData.price).toString())
-        .mul(decimal_js_1.default.pow(10, priceData.expo - oracleParams.tokenDecimals));
+        .mul(decimal_js_1.default.pow(10, priceData.expo - oracleParams.tokenDecimals + quoteDecimals));
     let cf = new decimal_js_1.default(priceData.conf.toString())
-        .mul(decimal_js_1.default.pow(10, priceData.expo - oracleParams.tokenDecimals));
+        .mul(decimal_js_1.default.pow(10, priceData.expo - oracleParams.tokenDecimals + quoteDecimals));
     const lastUpdateTimestamp = priceData.publishTime;
-    let quotePrice = (oracleParams.quote === oracle_1.Quote.Usdc) ? usdPrice :
-        ((oracleParams.quote === oracle_1.Quote.Wsol) ? solPrice : new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0));
+    let quotePrice = (oracleParams.quote === oracle_1.Quote.Usdc) ? usdcPrice :
+        ((oracleParams.quote === oracle_1.Quote.Wsol) ? wsolPrice :
+            new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0));
     pr = pr.mul(quotePrice.price);
     ema = ema.mul(quotePrice.price);
     cf = cf.mul(quotePrice.price);
@@ -711,7 +714,7 @@ class PythState {
 }
 exports.PythState = PythState;
 class PythOracle {
-    static fetch(oracleParams, accountInfos, solPrice, usdPrice) {
+    static fetch(oracleParams, accountInfos, wsolPrice, usdcPrice) {
         //@ts-ignore
         let state = null;
         try {
@@ -729,7 +732,7 @@ class PythOracle {
             publishTime: parseInt(state.priceMessage.publishTime.toString()),
             emaPrice: state.priceMessage.emaPrice.toString(),
             emaConf: state.priceMessage.emaConf.toString(),
-        }, solPrice !== null && solPrice !== void 0 ? solPrice : new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0), usdPrice !== null && usdPrice !== void 0 ? usdPrice : new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0));
+        }, wsolPrice !== null && wsolPrice !== void 0 ? wsolPrice : new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0), usdcPrice !== null && usdcPrice !== void 0 ? usdcPrice : new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0));
     }
 }
 exports.PythOracle = PythOracle;

package/dist/src/states/oracles/raydiumCpmmOracle.d.ts

@@ -115,6 +115,6 @@ export declare class RaydiumCPMMOracle {
      * - SELL: delta_quote_out = netQuote * delta_base / (netBase + delta_base)
      */
     static calculateMaxPriceImpactForMinLiquidity(oracleParams: OracleSettings, netBase: Decimal, netQuote: Decimal, spotPriceUsd: Decimal, quotePrice: OraclePrice): Decimal;
-    static fetch(oracleParams: OracleSettings, accountInfos: AccountInfo<Buffer>[], solPrice: OraclePrice, usdPrice: OraclePrice): OraclePrice;
+    static fetch(oracleParams: OracleSettings, accountInfos: AccountInfo<Buffer>[], wsolPrice: OraclePrice, usdcPrice: OraclePrice): OraclePrice;
 }
 export {};

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

@@ -462,7 +462,7 @@ class RaydiumCPMMOracle {
         const maxImpact = decimal_js_1.default.max(impactBuy, impactSell);
         return maxImpact.mul(new decimal_js_1.default(10000)); // Convert to bps
     }
-    static fetch(oracleParams, accountInfos, solPrice, usdPrice) {
+    static fetch(oracleParams, accountInfos, wsolPrice, usdcPrice) {
         const poolStateInfo = accountInfos[0];
         const vault0Info = accountInfos[1];
         const vault1Info = accountInfos[2];
@@ -473,8 +473,9 @@ class RaydiumCPMMOracle {
         const [decodedObservationState, ____] = ObservationState.decode(observationStateInfo.data, 8);
         const currentTime = new bn_js_1.default(Math.floor(Date.now() / 1000));
         // Determine quote oracle
-        let quotePrice = (oracleParams.quote === oracle_1.Quote.Usdc) ? usdPrice :
-            ((oracleParams.quote === oracle_1.Quote.Wsol) ? solPrice : new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0));
+        let quotePrice = (oracleParams.quote === oracle_1.Quote.Usdc) ? usdcPrice :
+            ((oracleParams.quote === oracle_1.Quote.Wsol) ? wsolPrice :
+                new oracle_2.OraclePrice(new decimal_js_1.default(1), new decimal_js_1.default(0), 0));
         // Get spot price with reserves
         const { netBase, netQuote, spotPrice } = this.getSpotPriceWithReserves(decodedPoolState, decodedVault0State, decodedVault1State, oracleParams.side, quotePrice);
         // Get TWAP prices

package/dist/src/txUtils.d.ts

@@ -56,10 +56,17 @@ export declare function getMultipleAccountsInfoBatched(connection: Connection, p
 export declare function getAddressLookupTableAccounts(connection: Connection, keys: PublicKey[]): Promise<Map<string, AddressLookupTableAccount>>;
 export declare function getMultipleAddressLookupTableAccounts(connection: Connection, batches: PublicKey[][][]): Promise<AddressLookupTableAccount[][][]>;
 export declare function compileVersionedTransaction(blockhash: string, addressLookupTableAccounts: AddressLookupTableAccount[], payerPubkey: PublicKey, ixs: TransactionInstruction[]): VersionedTransaction;
-export declare function sendVersionedTransaction(connection: Connection, tx: VersionedTransaction, blockhash: string, lastValidBlockHeight: number, simulateTransactions: boolean): Promise<TransactionSignature>;
+/**
+ * Send + confirm a batch of versioned transactions with parallel rebroadcasting.
+ * All txs within each batch are sent and confirmed concurrently.
+ * Batches are processed sequentially (batch 1 must all confirm before batch 2 starts).
+ */
+export declare function sendVersionedTxs(connection: Connection, versionedTxs: VersionedTxs, simulateTransactions?: boolean, rebroadcastIntervalMs?: number, confirmTimeoutMs?: number): Promise<TransactionSignature[][]>;
+/**
+ * Sign + send a TxPayloadBatchSequence using fast parallel rebroadcasting.
+ */
+export declare function sendTxPayloadBatchSequence(connection: Connection, txPayloadBatchSequence: TxPayloadBatchSequence, simulateTransactions?: boolean): Promise<TransactionSignature[][]>;
 export declare function prepareVersionedTxs(connection: Connection, txBatchData: TxBatchData): Promise<VersionedTxs>;
-export declare function sendVersionedTxs(connection: Connection, versionedTxs: VersionedTxs, simulateTransactions?: boolean): Promise<TransactionSignature[][]>;
 export declare function signVersionedTxs(wallet: Wallet, versionedTxs: VersionedTxs): Promise<VersionedTxs>;
 export declare function signTxPayloadBatchSequence(wallet: Wallet, txPayloadBatchSequence: TxPayloadBatchSequence): Promise<TxPayloadBatchSequence>;
-export declare function sendTxPayloadBatchSequence(connection: Connection, txPayloadBatchSequence: TxPayloadBatchSequence, simulateTransactions?: boolean): Promise<TransactionSignature[][]>;
 export {};

package/dist/src/txUtils.js

@@ -16,12 +16,11 @@ exports.getMultipleAccountsInfoBatched = getMultipleAccountsInfoBatched;
 exports.getAddressLookupTableAccounts = getAddressLookupTableAccounts;
 exports.getMultipleAddressLookupTableAccounts = getMultipleAddressLookupTableAccounts;
 exports.compileVersionedTransaction = compileVersionedTransaction;
-exports.sendVersionedTransaction = sendVersionedTransaction;
-exports.prepareVersionedTxs = prepareVersionedTxs;
 exports.sendVersionedTxs = sendVersionedTxs;
+exports.sendTxPayloadBatchSequence = sendTxPayloadBatchSequence;
+exports.prepareVersionedTxs = prepareVersionedTxs;
 exports.signVersionedTxs = signVersionedTxs;
 exports.signTxPayloadBatchSequence = signTxPayloadBatchSequence;
-exports.sendTxPayloadBatchSequence = sendTxPayloadBatchSequence;
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const constants_1 = require("./constants");
@@ -165,57 +164,164 @@ function compileVersionedTransaction(blockhash, addressLookupTableAccounts, paye
     }
     return versionedTx;
 }
-function sendVersionedTransaction(connection, tx, blockhash, lastValidBlockHeight, simulateTransactions) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const serializedTx = tx.serialize();
-        let txId;
-        if (simulateTransactions) {
-            txId = yield connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed", maxRetries: 0 }).catch(e => {
-                console.log(e.message);
-                throw new Error("Simulation failed");
-            });
-            for (let i = 0; i < 4; i++) {
-                yield delay(3000).then(() => connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed", maxRetries: 0 }).catch(() => { }));
-            }
-            console.log("Simulation txId:", txId);
-        }
-        else {
-            txId = yield connection.sendRawTransaction(serializedTx, { skipPreflight: true, maxRetries: 0 });
-            for (let i = 0; i < 4; i++) {
-                yield delay(3000).then(() => connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed", maxRetries: 0 }).catch(() => { }));
-            }
-            console.log("Sending tx:", txId);
-        }
-        let confirmation = null;
-        let result = null;
-        connection.confirmTransaction({
-            blockhash,
-            lastValidBlockHeight,
-            signature: txId,
-        }, "confirmed").catch(() => null).then((res) => confirmation = res);
-        let iterations = 10;
-        while (confirmation === null && result === null && iterations > 0) {
-            yield delay(1000);
-            result = yield connection.getTransaction(txId, {
-                commitment: "confirmed",
-                maxSupportedTransactionVersion: 0,
-            }).catch(() => null);
-            if (result && result.meta && ((_a = result.meta) === null || _a === void 0 ? void 0 : _a.err)) {
-                console.log(result.meta.err);
-                throw new Error(txId);
-            }
-            iterations--;
+const REBROADCAST_INTERVAL_MS = 500;
+const TX_CONFIRM_TIMEOUT_MS = 15000;
+// export async function sendVersionedTransaction(
+//     connection: Connection,
+//     tx: VersionedTransaction,
+//     blockhash: string,
+//     lastValidBlockHeight: number,
+//     simulateTransactions: boolean,
+// ): Promise<TransactionSignature> {
+//     const serializedTx = tx.serialize();
+//     let txId: TransactionSignature;
+//     if (simulateTransactions) {
+//         txId = await connection.sendRawTransaction(
+//             serializedTx,
+//             { preflightCommitment: "confirmed", maxRetries: 0 }
+//         ).catch(e => {
+//             console.log(e.message);
+//             throw new Error("Simulation failed");
+//         });
+//         for (let i = 0; i < 4; i++) {
+//             await delay(3000).then(() =>
+//                 connection.sendRawTransaction(
+//                     serializedTx,
+//                     {preflightCommitment: "confirmed", maxRetries: 0}
+//                 ).catch(() => {})
+//             );
+//         }
+//         console.log("Simulation txId:", txId);
+//     } else {
+//         txId = await connection.sendRawTransaction(
+//             serializedTx,
+//             { skipPreflight: true, maxRetries: 0 }
+//         );
+//         for (let i = 0; i < 4; i++) {
+//             await delay(3000).then(() =>
+//                 connection.sendRawTransaction(
+//                     serializedTx,
+//                     {preflightCommitment: "confirmed", maxRetries: 0}
+//                 ).catch(() => {})
+//             );
+//         }
+//         console.log("Sending tx:", txId);
+//     }
+//     let confirmation = null;
+//     let result = null;
+//     connection.confirmTransaction({
+//         blockhash,
+//         lastValidBlockHeight,
+//         signature: txId,
+//     }, "confirmed").catch(() => null).then((res) => confirmation = res);
+//     let iterations = 10;
+//     while (confirmation === null && result === null && iterations > 0) {
+//         await delay(1000);
+//         result = await connection.getTransaction(txId, {
+//             commitment: "confirmed",
+//             maxSupportedTransactionVersion: 0,
+//         }).catch(() => null);
+//         if (result && result.meta && result.meta?.err) {
+//             console.log(result.meta.err);
+//             throw new Error(txId);
+//         }
+//         iterations--;
+//     }
+//     if (result) return txId;
+//     //@ts-ignore
+//     if (!confirmation || confirmation.value.err) {
+//         //@ts-ignore
+//         console.log(confirmation?.value.err);
+//         throw new Error(txId);
+//     }
+//     return txId;
+// }
+/**
+ * Send + confirm a batch of versioned transactions with parallel rebroadcasting.
+ * All txs within each batch are sent and confirmed concurrently.
+ * Batches are processed sequentially (batch 1 must all confirm before batch 2 starts).
+ */
+function sendVersionedTxs(connection_1, versionedTxs_1) {
+    return __awaiter(this, arguments, void 0, function* (connection, versionedTxs, simulateTransactions = false, rebroadcastIntervalMs = REBROADCAST_INTERVAL_MS, confirmTimeoutMs = TX_CONFIRM_TIMEOUT_MS) {
+        const { batches, blockhash, lastValidBlockHeight } = versionedTxs;
+        const batchTxIds = [];
+        for (const batch of batches) {
+            const txIds = yield Promise.all(batch.map((tx) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const serializedTx = tx.serialize();
+                let txId;
+                if (simulateTransactions) {
+                    txId = yield connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed", maxRetries: 0 }).catch(e => {
+                        console.log(e.message);
+                        throw new Error("Simulation failed");
+                    });
+                }
+                else {
+                    txId = yield connection.sendRawTransaction(serializedTx, { skipPreflight: true, maxRetries: 0 });
+                }
+                const rebroadcastInterval = setInterval(() => {
+                    connection.sendRawTransaction(serializedTx, { skipPreflight: true, maxRetries: 0 }).catch(() => { });
+                }, rebroadcastIntervalMs);
+                let timeoutId;
+                try {
+                    const confirmPromise = connection.confirmTransaction({
+                        blockhash,
+                        lastValidBlockHeight,
+                        signature: txId,
+                    }, "confirmed");
+                    const timeoutPromise = new Promise((_, reject) => {
+                        timeoutId = setTimeout(() => reject(new Error("timeout")), confirmTimeoutMs);
+                    });
+                    const confirmation = yield Promise.race([confirmPromise, timeoutPromise]);
+                    if (confirmation.value.err) {
+                        console.log("Tx error:", txId, confirmation.value.err);
+                        return "Error";
+                    }
+                    return txId;
+                }
+                catch (e) {
+                    if ((e === null || e === void 0 ? void 0 : e.message) === "timeout") {
+                        const result = yield connection.getTransaction(txId, {
+                            commitment: "confirmed",
+                            maxSupportedTransactionVersion: 0,
+                        }).catch(() => null);
+                        if (result && !((_a = result.meta) === null || _a === void 0 ? void 0 : _a.err))
+                            return txId;
+                        if ((_b = result === null || result === void 0 ? void 0 : result.meta) === null || _b === void 0 ? void 0 : _b.err)
+                            console.log("Tx error:", txId, result.meta.err);
+                    }
+                    console.log("Error sending tx:", (_c = e === null || e === void 0 ? void 0 : e.message) !== null && _c !== void 0 ? _c : e);
+                    return "Error";
+                }
+                finally {
+                    clearInterval(rebroadcastInterval);
+                    if (timeoutId !== undefined)
+                        clearTimeout(timeoutId);
+                }
+            })));
+            batchTxIds.push(txIds);
         }
-        if (result)
-            return txId;
-        //@ts-ignore
-        if (!confirmation || confirmation.value.err) {
-            //@ts-ignore
-            console.log(confirmation === null || confirmation === void 0 ? void 0 : confirmation.value.err);
-            throw new Error(txId);
+        return batchTxIds;
+    });
+}
+/**
+ * Sign + send a TxPayloadBatchSequence using fast parallel rebroadcasting.
+ */
+function sendTxPayloadBatchSequence(connection_1, txPayloadBatchSequence_1) {
+    return __awaiter(this, arguments, void 0, function* (connection, txPayloadBatchSequence, simulateTransactions = false) {
+        var _a, _b, _c, _d;
+        const txs = [];
+        for (const batch of txPayloadBatchSequence.batches) {
+            const batchTxs = [];
+            for (const tx of batch.transactions)
+                batchTxs.push(web3_js_1.VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
+            txs.push(batchTxs);
         }
-        return txId;
+        return yield sendVersionedTxs(connection, {
+            blockhash: (_b = (_a = txPayloadBatchSequence.batches[0].transactions[0]) === null || _a === void 0 ? void 0 : _a.recent_blockhash) !== null && _b !== void 0 ? _b : "",
+            lastValidBlockHeight: (_d = (_c = txPayloadBatchSequence.batches[0].transactions[0]) === null || _c === void 0 ? void 0 : _c.last_valid_block_height) !== null && _d !== void 0 ? _d : 0,
+            batches: txs,
+        }, simulateTransactions);
     });
 }
 function prepareVersionedTxs(connection, txBatchData) {
@@ -242,17 +348,29 @@ function prepareVersionedTxs(connection, txBatchData) {
         };
     });
 }
-function sendVersionedTxs(connection_1, versionedTxs_1) {
-    return __awaiter(this, arguments, void 0, function* (connection, versionedTxs, simulateTransactions = false) {
-        const { batches, blockhash, lastValidBlockHeight } = versionedTxs;
-        let batchTxIds = [];
-        for (const batch of batches) {
-            let txIds = yield Promise.all(batch.map(tx => sendVersionedTransaction(connection, tx, blockhash, lastValidBlockHeight, simulateTransactions).catch(e => { console.log("Error sending tx:", e.message); return "Error"; })));
-            batchTxIds.push(txIds);
-        }
-        return batchTxIds;
-    });
-}
+// export async function sendVersionedTxs(
+//     connection: Connection,
+//     versionedTxs: VersionedTxs,
+//     simulateTransactions: boolean = false,
+// ): Promise<TransactionSignature[][]> {
+//     const { batches, blockhash, lastValidBlockHeight } = versionedTxs;
+//     let batchTxIds: TransactionSignature[][] = [];
+//     for (const batch of batches) {
+//         let txIds = await Promise.all(
+//             batch.map(tx =>
+//                 sendVersionedTransaction(
+//                     connection,
+//                     tx,
+//                     blockhash,
+//                     lastValidBlockHeight,
+//                     simulateTransactions
+//                 ).catch(e => {console.log("Error sending tx:", e.message); return "Error"})
+//             )
+//         );
+//         batchTxIds.push(txIds);
+//     }
+//     return batchTxIds;
+// }
 function signVersionedTxs(wallet, versionedTxs) {
     return __awaiter(this, void 0, void 0, function* () {
         let txs = [];
@@ -285,20 +403,21 @@ function signTxPayloadBatchSequence(wallet, txPayloadBatchSequence) {
         return txPayloadBatchSequence;
     });
 }
-function sendTxPayloadBatchSequence(connection_1, txPayloadBatchSequence_1) {
-    return __awaiter(this, arguments, void 0, function* (connection, txPayloadBatchSequence, simulateTransactions = false) {
-        var _a, _b, _c, _d;
-        let txs = [];
-        for (const batch of txPayloadBatchSequence.batches) {
-            let batchTxs = [];
-            for (const tx of batch.transactions)
-                batchTxs.push(web3_js_1.VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
-            txs.push(batchTxs);
-        }
-        return yield sendVersionedTxs(connection, {
-            blockhash: (_b = (_a = txPayloadBatchSequence.batches[0].transactions[0]) === null || _a === void 0 ? void 0 : _a.recent_blockhash) !== null && _b !== void 0 ? _b : "",
-            lastValidBlockHeight: (_d = (_c = txPayloadBatchSequence.batches[0].transactions[0]) === null || _c === void 0 ? void 0 : _c.last_valid_block_height) !== null && _d !== void 0 ? _d : 0,
-            batches: txs,
-        }, simulateTransactions);
-    });
-}
+// export async function sendTxPayloadBatchSequence(
+//     connection: Connection,
+//     txPayloadBatchSequence: TxPayloadBatchSequence,
+//     simulateTransactions: boolean = false,
+// ): Promise<TransactionSignature[][]> {
+//     let txs: VersionedTransaction[][] = [];
+//     for (const batch of txPayloadBatchSequence.batches) {
+//         let batchTxs: VersionedTransaction[] = [];
+//         for (const tx of batch.transactions)
+//             batchTxs.push(VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
+//         txs.push(batchTxs);
+//     }
+//     return await sendVersionedTxs(connection, {
+//         blockhash: txPayloadBatchSequence.batches[0].transactions[0]?.recent_blockhash ?? "",
+//         lastValidBlockHeight: txPayloadBatchSequence.batches[0].transactions[0]?.last_valid_block_height ?? 0,
+//         batches: txs,
+//     }, simulateTransactions);
+// }

package/dist/test.js

@@ -72,7 +72,7 @@ function testStates() {
             editGlobalConfig: false, // TESTED
             createVault: false, // TESTED
             editPrivateVaultSettings: false, // NOT TESTED
-            addBounty: true, // TESTED
+            addBounty: false, // TESTED
             editCreator: false, // TESTED
             editManagerSettings: false, // TESTED
             editFeeSettings: false, // TESTED
@@ -521,13 +521,13 @@ function testStates() {
                     symmetryLimitOrderFeeBps: 0,
                     symmetryFeesExtraData: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,],
                     bountyMint: new web3_js_1.PublicKey("So11111111111111111111111111111111111111112"),
-                    minBountyForVaultAutomation: new anchor_1.BN(200 * 50 * 10 ** 3),
-                    bountyBondAmount: new anchor_1.BN(5 * 50 * 10 ** 3),
+                    minBountyForVaultAutomation: new anchor_1.BN(2000 * 5000),
+                    bountyBondAmount: new anchor_1.BN(20 * 5000),
                     bountyPerTask: {
-                        minBounty: new anchor_1.BN(10 * 50 * 10 ** 3),
-                        maxBounty: new anchor_1.BN(20 * 50 * 10 ** 3),
-                        minBountyUntil: new anchor_1.BN(1),
-                        maxBountyAfter: new anchor_1.BN(101),
+                        minBounty: new anchor_1.BN(20 * 5000),
+                        maxBounty: new anchor_1.BN(50 * 5000),
+                        minBountyUntil: new anchor_1.BN(10),
+                        maxBountyAfter: new anchor_1.BN(40),
                     },
                     bountyPerPriceUpdateTaskDivisor: new anchor_1.BN(3),
                     minRemainingValue: { high: new anchor_1.BN(0), low: new anchor_1.BN("1844674407370955161") },

package/package.json

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

package/src/index.ts

@@ -762,6 +762,14 @@ export class SymmetryCore {
             let maxBountyPerTask = parseInt(maxBounty.toString());
             bountyWsolAmount = maxBountyPerTask + boundBounty;
         }
+
+        if (editType === TaskType.EditAutomationSettings && (editData as EditAutomationSettings).enabled == true) {
+            let bountyBalance = parseInt(vault.settings.bountyBalance.toString());
+            let requiredBounty = parseInt(globalConfig.minBountyForVaultAutomation.toString());
+            if (bountyBalance < requiredBounty)
+                bountyWsolAmount += 2 * requiredBounty - bountyBalance;
+        }
+
         let wsolIxs = await wrapWsolIxs(
             this.sdkParams.connection,
             manager,
@@ -1525,7 +1533,19 @@ export class SymmetryCore {
                 Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor),
             );
         }
-        
+
+        let isManager = vault.settings.creator.equals(keeper);
+        for (let i = 0; i < vault.settings.managers.managers.length; i++)
+            if (vault.settings.managers.managers[i].equals(keeper))
+                isManager = true;
+
+        if (isManager) {
+            let bountyBalance = parseInt(vault.settings.bountyBalance.toString());
+            let requiredBounty = parseInt(globalConfig.minBountyForVaultAutomation.toString());
+            if (bountyBalance < requiredBounty)
+                bountyWsolAmount += 2 * requiredBounty - bountyBalance;
+        }
+
         let wsolIxs = await wrapWsolIxs(
             this.sdkParams.connection,
             keeper,

package/src/states/intents/rebalanceIntent.ts

@@ -147,23 +147,33 @@ export function formatRebalanceIntent(rebalanceIntent: RebalanceIntent, vault?:
         })),
     }
     if (vault) {
+        const auctionTokenByMint = new Map(auctionData.tokens.map(token => [token.mint, token]));
+        const mintDataTokenByMint = new Map(mintData.tokens.map(token => [token.mint, token]));
         let minRatio = 1;
-        for (let i = 0; i < vault.composition.length; i++) {
-            if (vault.composition[i].amount == 0)
+        for (const vaultToken of vault.composition) {
+            if (vaultToken.amount == 0)
                 continue;
-            let ratio = auctionData.tokens[i].amount / vault.composition[i].amount;
+            const auctionToken = auctionTokenByMint.get(vaultToken.mint);
+            if (!auctionToken) continue;
+
+            let ratio = auctionToken.amount / vaultToken.amount;
             minRatio = Math.min(minRatio, ratio);
         }
         let mintValue = 0;
         let remainingValue = 0;
         let mintAmount = Math.floor(vault.supply_outstanding * minRatio);
-        for (let i = 0; i < vault.composition.length; i++) {
-            let contributionAmount = Math.floor(vault.composition[i].amount * minRatio);
-            contributionAmount = Math.min(contributionAmount, auctionData.tokens[i].amount);
-            mintData.tokens[i].contribution_amount = contributionAmount;
-            mintData.tokens[i].remaining_amount = auctionData.tokens[i].amount - contributionAmount;
-            mintValue += contributionAmount * auctionData.tokens[i].price;
-            remainingValue += (auctionData.tokens[i].amount - contributionAmount) * auctionData.tokens[i].price;
+        for (const vaultToken of vault.composition) {
+            const mint = vaultToken.mint;
+            const auctionToken = auctionTokenByMint.get(mint);
+            const mintDataToken = mintDataTokenByMint.get(mint);
+            if (!auctionToken || !mintDataToken) continue;
+
+            let contributionAmount = Math.floor(vaultToken.amount * minRatio);
+            contributionAmount = Math.min(contributionAmount, auctionToken.amount);
+            mintDataToken.contribution_amount = contributionAmount;
+            mintDataToken.remaining_amount = auctionToken.amount - contributionAmount;
+            mintValue += contributionAmount * auctionToken.price;
+            remainingValue += (auctionToken.amount - contributionAmount) * auctionToken.price;
         }
         mintData.mintValue = mintValue;
         mintData.mintAmount = mintAmount;

package/src/states/oracles/oracle.ts

@@ -6,7 +6,7 @@ import { AccountInfo, AddressLookupTableAccount, PublicKey } from '@solana/web3.
 import { HUNDRED_PERCENT_BPS } from '../../constants';
 import { Fraction, fractionToDecimal } from '../../layouts/fraction';
 import {
-    MAX_ACCOUNTS_PER_ORACLE, OracleAggregator, OracleData, OracleSettings, OracleType
+    OracleAggregator, OracleData, OracleType,
 } from '../../layouts/oracle';
 import { U32_MAX } from './constants';
 import { PythOracle } from './pythOracle';
@@ -79,8 +79,8 @@ export class PriceAggregator{
         oracleAggregator: OracleAggregator,
         lutAccounts: AddressLookupTableAccount[],
         accountInfoMap: Map<string, AccountInfo<Buffer> | null>,
-        solPrice: OraclePrice,
-        usdPrice: OraclePrice,
+        wsolPrice: OraclePrice,
+        usdcPrice: OraclePrice,
         pythPriceOverrides?: Map<string, OraclePrice>,
     ): OraclePrice {
         let validated: boolean = true;
@@ -93,15 +93,11 @@ export class PriceAggregator{
             const settings = oracleData.oracleSettings;
 
             let loadedAccounts: AccountInfo<Buffer>[] = [];
-            let firstLoadedPubkey: PublicKey | undefined;
             for (let j = 0; j < settings.numRequiredAccounts; j++) {
                 const lutId = oracleData.accountsToLoadLutIds[j];
                 const lutIdx = oracleData.accountsToLoadLutIndices[j];
                 const pubkey = lutAccounts[lutId].state.addresses[lutIdx];
                 const account = accountInfoMap.get(pubkey.toBase58());
-                if (!firstLoadedPubkey) {
-                    firstLoadedPubkey = pubkey;
-                }
                 // @ts-ignore
                 loadedAccounts.push(account);
             }
@@ -127,17 +123,16 @@ export class PriceAggregator{
             let result = (() => {
                 switch (settings.oracleType) {
                     case OracleType.Pyth:
-                        if (firstLoadedPubkey) {
-                            const override = pythPriceOverrides?.get(firstLoadedPubkey.toBase58());
-                            if (override) {
-                                return override;
-                            }
-                        }
-                        return PythOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                        const lutId = oracleData.accountsToLoadLutIds[0];
+                        const lutIdx = oracleData.accountsToLoadLutIndices[0];
+                        const pubkey = lutAccounts[lutId].state.addresses[lutIdx];
+                        const override = pythPriceOverrides?.get(pubkey.toBase58());
+                        const price = PythOracle.fetch(settings, loadedAccounts, wsolPrice, usdcPrice);
+                        return (override ? override : price);
                     case OracleType.RaydiumClmm:
-                        return RaydiumCLMMOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                        return RaydiumCLMMOracle.fetch(settings, loadedAccounts, wsolPrice, usdcPrice);
                     case OracleType.RaydiumCpmm:
-                        return RaydiumCPMMOracle.fetch(settings, loadedAccounts, solPrice, usdPrice);
+                        return RaydiumCPMMOracle.fetch(settings, loadedAccounts, wsolPrice, usdcPrice);
                     default:
                         throw new Error(`Invalid oracle type: ${settings.oracleType}`);
                 }

package/src/states/oracles/pythOracle.ts

@@ -7,7 +7,7 @@ import {
     SystemProgram, Transaction, TransactionInstruction, TransactionMessage, VersionedTransaction
 } from '@solana/web3.js';
 
-import { HUNDRED_PERCENT_BPS, PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT, PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT } from '../../constants';
+import { HUNDRED_PERCENT_BPS, PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT, PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT, USDC_DECIMALS, WSOL_DECIMALS } from '../../constants';
 import { OracleSettings, OracleType, PYTH_USDC_ORACLE_SETTINGS, PYTH_WSOL_ORACLE_SETTINGS, Quote } from '../../layouts/oracle';
 import { TxBatchData, TxData } from '../../txUtils';
 import { HERMES_PUBLIC_ENDPOINT, SOLANA_DEVNET_ENDPOINT } from './constants';
@@ -87,20 +87,25 @@ export async function fetchHermesPythPrices(priceFeedIds: string[]): Promise<Map
 export function buildPythOraclePriceFromHermesPriceData(
     oracleParams: OracleSettings,
     priceData: HermesPythPriceData,
-    solPrice: OraclePrice,
-    usdPrice: OraclePrice,
+    wsolPrice: OraclePrice,
+    usdcPrice: OraclePrice,
 ): OraclePrice {
+    let quoteDecimals =
+        (oracleParams.quote == Quote.Usdc) ? USDC_DECIMALS : (
+        (oracleParams.quote == Quote.Wsol) ? WSOL_DECIMALS : 0);
+
     let pr = new Decimal(priceData.price.toString())
-        .mul(Decimal.pow(10, priceData.expo - oracleParams.tokenDecimals));
+        .mul(Decimal.pow(10, priceData.expo - oracleParams.tokenDecimals + quoteDecimals));
     let ema = new Decimal((priceData.emaPrice ?? priceData.price).toString())
-        .mul(Decimal.pow(10, priceData.expo - oracleParams.tokenDecimals));
+        .mul(Decimal.pow(10, priceData.expo - oracleParams.tokenDecimals + quoteDecimals));
     let cf = new Decimal(priceData.conf.toString())
-        .mul(Decimal.pow(10, priceData.expo - oracleParams.tokenDecimals));
+        .mul(Decimal.pow(10, priceData.expo - oracleParams.tokenDecimals + quoteDecimals));
     const lastUpdateTimestamp = priceData.publishTime;
-    
+
     let quotePrice =
-    (oracleParams.quote === Quote.Usdc) ? usdPrice :
-    ((oracleParams.quote === Quote.Wsol) ? solPrice : new OraclePrice(new Decimal(1), new Decimal(0), 0));
+        (oracleParams.quote === Quote.Usdc) ? usdcPrice :
+        ((oracleParams.quote === Quote.Wsol) ? wsolPrice :
+        new OraclePrice(new Decimal(1), new Decimal(0), 0));
 
     pr = pr.mul(quotePrice.price);
     ema = ema.mul(quotePrice.price);
@@ -490,7 +495,7 @@ function buildVerifyEncodedVaaV1Instruction(
 /**
  * Build closeEncodedVaa instruction
  */
-function buildCloseEncodedVaaInstruction(
+export function buildCloseEncodedVaaInstruction(
     writeAuthority: PublicKey,
     encodedVaa: PublicKey,
     wormholeProgramId: PublicKey = DEFAULT_WORMHOLE_PROGRAM_ID
@@ -976,8 +981,8 @@ export class PythOracle {
     static fetch(
         oracleParams: OracleSettings,
         accountInfos: AccountInfo<Buffer>[],
-        solPrice?: OraclePrice,
-        usdPrice?: OraclePrice,
+        wsolPrice?: OraclePrice,
+        usdcPrice?: OraclePrice,
     ): OraclePrice {
         //@ts-ignore
         let state: PythState = null;
@@ -999,8 +1004,8 @@ export class PythOracle {
                 emaPrice: state.priceMessage.emaPrice.toString(),
                 emaConf: state.priceMessage.emaConf.toString(),
             },
-            solPrice ?? new OraclePrice(new Decimal(1), new Decimal(0), 0),
-            usdPrice ?? new OraclePrice(new Decimal(1), new Decimal(0), 0),
+            wsolPrice ?? new OraclePrice(new Decimal(1), new Decimal(0), 0),
+            usdcPrice ?? new OraclePrice(new Decimal(1), new Decimal(0), 0),
         );
     }
 

package/src/states/oracles/raydiumCpmmOracle.ts

@@ -667,8 +667,8 @@ export class RaydiumCPMMOracle {
     static fetch(
         oracleParams: OracleSettings,
         accountInfos: AccountInfo<Buffer>[],
-        solPrice: OraclePrice,
-        usdPrice: OraclePrice,
+        wsolPrice: OraclePrice,
+        usdcPrice: OraclePrice,
     ): OraclePrice {
         const poolStateInfo = accountInfos[0];
         const vault0Info = accountInfos[1];
@@ -684,8 +684,9 @@ export class RaydiumCPMMOracle {
 
         // Determine quote oracle
         let quotePrice =
-        (oracleParams.quote === Quote.Usdc) ? usdPrice :
-        ((oracleParams.quote === Quote.Wsol) ? solPrice : new OraclePrice(new Decimal(1), new Decimal(0), 0));
+            (oracleParams.quote === Quote.Usdc) ? usdcPrice :
+            ((oracleParams.quote === Quote.Wsol) ? wsolPrice :
+            new OraclePrice(new Decimal(1), new Decimal(0), 0));
 
         // Get spot price with reserves
         const { netBase, netQuote, spotPrice } = this.getSpotPriceWithReserves(

package/src/txUtils.ts

@@ -232,81 +232,190 @@ export function compileVersionedTransaction(
     return versionedTx;
 }
 
-export async function sendVersionedTransaction(
+const REBROADCAST_INTERVAL_MS = 500;
+const TX_CONFIRM_TIMEOUT_MS = 15_000;
+
+// export async function sendVersionedTransaction(
+//     connection: Connection,
+//     tx: VersionedTransaction,
+//     blockhash: string,
+//     lastValidBlockHeight: number,
+//     simulateTransactions: boolean,
+// ): Promise<TransactionSignature> {
+//     const serializedTx = tx.serialize();
+//     let txId: TransactionSignature;
+//     if (simulateTransactions) {
+//         txId = await connection.sendRawTransaction(
+//             serializedTx,
+//             { preflightCommitment: "confirmed", maxRetries: 0 }
+//         ).catch(e => {
+//             console.log(e.message);
+//             throw new Error("Simulation failed");
+//         });
+//         for (let i = 0; i < 4; i++) {
+//             await delay(3000).then(() =>
+//                 connection.sendRawTransaction(
+//                     serializedTx,
+//                     {preflightCommitment: "confirmed", maxRetries: 0}
+//                 ).catch(() => {})
+//             );
+//         }
+//         console.log("Simulation txId:", txId);
+//     } else {
+//         txId = await connection.sendRawTransaction(
+//             serializedTx,
+//             { skipPreflight: true, maxRetries: 0 }
+//         );
+//         for (let i = 0; i < 4; i++) {
+//             await delay(3000).then(() =>
+//                 connection.sendRawTransaction(
+//                     serializedTx,
+//                     {preflightCommitment: "confirmed", maxRetries: 0}
+//                 ).catch(() => {})
+//             );
+//         }
+//         console.log("Sending tx:", txId);
+//     }
+
+//     let confirmation = null;
+//     let result = null;
+
+//     connection.confirmTransaction({
+//         blockhash,
+//         lastValidBlockHeight,
+//         signature: txId,
+//     }, "confirmed").catch(() => null).then((res) => confirmation = res);
+
+//     let iterations = 10;
+//     while (confirmation === null && result === null && iterations > 0) {
+//         await delay(1000);
+//         result = await connection.getTransaction(txId, {
+//             commitment: "confirmed",
+//             maxSupportedTransactionVersion: 0,
+//         }).catch(() => null);
+//         if (result && result.meta && result.meta?.err) {
+//             console.log(result.meta.err);
+//             throw new Error(txId);
+//         }
+//         iterations--;
+//     }
+
+//     if (result) return txId;
+
+//     //@ts-ignore
+//     if (!confirmation || confirmation.value.err) {
+//         //@ts-ignore
+//         console.log(confirmation?.value.err);
+//         throw new Error(txId);
+//     }
+
+//     return txId;
+// }
+
+/**
+ * Send + confirm a batch of versioned transactions with parallel rebroadcasting.
+ * All txs within each batch are sent and confirmed concurrently.
+ * Batches are processed sequentially (batch 1 must all confirm before batch 2 starts).
+ */
+export async function sendVersionedTxs(
     connection: Connection,
-    tx: VersionedTransaction,
-    blockhash: string,
-    lastValidBlockHeight: number,
-    simulateTransactions: boolean,
-): Promise<TransactionSignature> {
-    const serializedTx = tx.serialize();
-    let txId: TransactionSignature;
-    if (simulateTransactions) {
-        txId = await connection.sendRawTransaction(
-            serializedTx,
-            { preflightCommitment: "confirmed", maxRetries: 0 }
-        ).catch(e => {
-            console.log(e.message);
-            throw new Error("Simulation failed");
-        });
-        for (let i = 0; i < 4; i++) {
-            await delay(3000).then(() =>
-                connection.sendRawTransaction(
-                    serializedTx,
-                    {preflightCommitment: "confirmed", maxRetries: 0}
-                ).catch(() => {})
-            );
-        }
-        console.log("Simulation txId:", txId);
-    } else {
-        txId = await connection.sendRawTransaction(
-            serializedTx,
-            { skipPreflight: true, maxRetries: 0 }
-        );
-        for (let i = 0; i < 4; i++) {
-            await delay(3000).then(() =>
-                connection.sendRawTransaction(
-                    serializedTx,
-                    {preflightCommitment: "confirmed", maxRetries: 0}
-                ).catch(() => {})
-            );
-        }
-        console.log("Sending tx:", txId);
-    }
+    versionedTxs: VersionedTxs,
+    simulateTransactions: boolean = false,
+    rebroadcastIntervalMs: number = REBROADCAST_INTERVAL_MS,
+    confirmTimeoutMs: number = TX_CONFIRM_TIMEOUT_MS,
+): Promise<TransactionSignature[][]> {
+    const { batches, blockhash, lastValidBlockHeight } = versionedTxs;
+    const batchTxIds: TransactionSignature[][] = [];
 
-    let confirmation = null;
-    let result = null;
+    for (const batch of batches) {
+        const txIds = await Promise.all(
+            batch.map(async (tx) => {
+                const serializedTx = tx.serialize();
+                let txId: TransactionSignature;
 
-    connection.confirmTransaction({
-        blockhash,
-        lastValidBlockHeight,
-        signature: txId,
-    }, "confirmed").catch(() => null).then((res) => confirmation = res);
-
-    let iterations = 10;
-    while (confirmation === null && result === null && iterations > 0) {
-        await delay(1000);
-        result = await connection.getTransaction(txId, {
-            commitment: "confirmed",
-            maxSupportedTransactionVersion: 0,
-        }).catch(() => null);
-        if (result && result.meta && result.meta?.err) {
-            console.log(result.meta.err);
-            throw new Error(txId);
-        }
-        iterations--;
-    }
+                if (simulateTransactions) {
+                    txId = await connection.sendRawTransaction(
+                        serializedTx,
+                        { preflightCommitment: "confirmed", maxRetries: 0 },
+                    ).catch(e => {
+                        console.log(e.message);
+                        throw new Error("Simulation failed");
+                    });
+                } else {
+                    txId = await connection.sendRawTransaction(
+                        serializedTx,
+                        { skipPreflight: true, maxRetries: 0 },
+                    );
+                }
 
-    if (result) return txId;
+                const rebroadcastInterval = setInterval(() => {
+                    connection.sendRawTransaction(
+                        serializedTx,
+                        { skipPreflight: true, maxRetries: 0 },
+                    ).catch(() => {});
+                }, rebroadcastIntervalMs);
 
-    //@ts-ignore
-    if (!confirmation || confirmation.value.err) {
-        //@ts-ignore
-        console.log(confirmation?.value.err);
-        throw new Error(txId);
+                let timeoutId: ReturnType<typeof setTimeout> | undefined;
+                try {
+                    const confirmPromise = connection.confirmTransaction({
+                        blockhash,
+                        lastValidBlockHeight,
+                        signature: txId,
+                    }, "confirmed");
+
+                    const timeoutPromise = new Promise<never>((_, reject) => {
+                        timeoutId = setTimeout(() => reject(new Error("timeout")), confirmTimeoutMs);
+                    });
+
+                    const confirmation = await Promise.race([confirmPromise, timeoutPromise]);
+
+                    if (confirmation.value.err) {
+                        console.log("Tx error:", txId, confirmation.value.err);
+                        return "Error";
+                    }
+                    return txId;
+                } catch (e: any) {
+                    if (e?.message === "timeout") {
+                        const result = await connection.getTransaction(txId, {
+                            commitment: "confirmed",
+                            maxSupportedTransactionVersion: 0,
+                        }).catch(() => null);
+                        if (result && !result.meta?.err) return txId;
+                        if (result?.meta?.err) console.log("Tx error:", txId, result.meta.err);
+                    }
+                    console.log("Error sending tx:", e?.message ?? e);
+                    return "Error";
+                } finally {
+                    clearInterval(rebroadcastInterval);
+                    if (timeoutId !== undefined) clearTimeout(timeoutId);
+                }
+            }),
+        );
+        batchTxIds.push(txIds);
     }
+    return batchTxIds;
+}
 
-    return txId;
+/**
+ * Sign + send a TxPayloadBatchSequence using fast parallel rebroadcasting.
+ */
+export async function sendTxPayloadBatchSequence(
+    connection: Connection,
+    txPayloadBatchSequence: TxPayloadBatchSequence,
+    simulateTransactions: boolean = false,
+): Promise<TransactionSignature[][]> {
+    const txs: VersionedTransaction[][] = [];
+    for (const batch of txPayloadBatchSequence.batches) {
+        const batchTxs: VersionedTransaction[] = [];
+        for (const tx of batch.transactions)
+            batchTxs.push(VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
+        txs.push(batchTxs);
+    }
+    return await sendVersionedTxs(connection, {
+        blockhash: txPayloadBatchSequence.batches[0].transactions[0]?.recent_blockhash ?? "",
+        lastValidBlockHeight: txPayloadBatchSequence.batches[0].transactions[0]?.last_valid_block_height ?? 0,
+        batches: txs,
+    }, simulateTransactions);
 }
 
 export async function prepareVersionedTxs(
@@ -342,30 +451,30 @@ export async function prepareVersionedTxs(
     };
 }
 
-export async function sendVersionedTxs(
-    connection: Connection,
-    versionedTxs: VersionedTxs,
-    simulateTransactions: boolean = false,
-): Promise<TransactionSignature[][]> {
-    const { batches, blockhash, lastValidBlockHeight } = versionedTxs;
-    let batchTxIds: TransactionSignature[][] = [];
+// export async function sendVersionedTxs(
+//     connection: Connection,
+//     versionedTxs: VersionedTxs,
+//     simulateTransactions: boolean = false,
+// ): Promise<TransactionSignature[][]> {
+//     const { batches, blockhash, lastValidBlockHeight } = versionedTxs;
+//     let batchTxIds: TransactionSignature[][] = [];
 
-    for (const batch of batches) {
-        let txIds = await Promise.all(
-            batch.map(tx =>
-                sendVersionedTransaction(
-                    connection,
-                    tx,
-                    blockhash,
-                    lastValidBlockHeight,
-                    simulateTransactions
-                ).catch(e => {console.log("Error sending tx:", e.message); return "Error"})
-            )
-        );
-        batchTxIds.push(txIds);
-    }
-    return batchTxIds;
-}
+//     for (const batch of batches) {
+//         let txIds = await Promise.all(
+//             batch.map(tx =>
+//                 sendVersionedTransaction(
+//                     connection,
+//                     tx,
+//                     blockhash,
+//                     lastValidBlockHeight,
+//                     simulateTransactions
+//                 ).catch(e => {console.log("Error sending tx:", e.message); return "Error"})
+//             )
+//         );
+//         batchTxIds.push(txIds);
+//     }
+//     return batchTxIds;
+// }
 
 
 export async function signVersionedTxs(
@@ -406,21 +515,21 @@ export async function signTxPayloadBatchSequence(
     return txPayloadBatchSequence;
 }
 
-export async function sendTxPayloadBatchSequence(
-    connection: Connection,
-    txPayloadBatchSequence: TxPayloadBatchSequence,
-    simulateTransactions: boolean = false,
-): Promise<TransactionSignature[][]> {
-    let txs: VersionedTransaction[][] = [];
-    for (const batch of txPayloadBatchSequence.batches) {
-        let batchTxs: VersionedTransaction[] = [];
-        for (const tx of batch.transactions)
-            batchTxs.push(VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
-        txs.push(batchTxs);
-    }
-    return await sendVersionedTxs(connection, {
-        blockhash: txPayloadBatchSequence.batches[0].transactions[0]?.recent_blockhash ?? "",
-        lastValidBlockHeight: txPayloadBatchSequence.batches[0].transactions[0]?.last_valid_block_height ?? 0,
-        batches: txs,
-    }, simulateTransactions);
-}
+// export async function sendTxPayloadBatchSequence(
+//     connection: Connection,
+//     txPayloadBatchSequence: TxPayloadBatchSequence,
+//     simulateTransactions: boolean = false,
+// ): Promise<TransactionSignature[][]> {
+//     let txs: VersionedTransaction[][] = [];
+//     for (const batch of txPayloadBatchSequence.batches) {
+//         let batchTxs: VersionedTransaction[] = [];
+//         for (const tx of batch.transactions)
+//             batchTxs.push(VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
+//         txs.push(batchTxs);
+//     }
+//     return await sendVersionedTxs(connection, {
+//         blockhash: txPayloadBatchSequence.batches[0].transactions[0]?.recent_blockhash ?? "",
+//         lastValidBlockHeight: txPayloadBatchSequence.batches[0].transactions[0]?.last_valid_block_height ?? 0,
+//         batches: txs,
+//     }, simulateTransactions);
+// }

package/test.ts

@@ -1,13 +1,15 @@
-import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { ComputeBudgetProgram, Connection, Keypair, PublicKey } from "@solana/web3.js";
 import { BN, Wallet } from "@coral-xyz/anchor";
 import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
-import { Vault, Intent, RebalanceIntent, SymmetryCore, TaskContext, KeeperMonitor } from "./src";
+import { Vault, Intent, RebalanceIntent, SymmetryCore, TaskContext, KeeperMonitor, isRebalanceRequired } from "./src";
 import { AddOrEditTokenInput, UpdateWeightsInput, MakeDirectSwapInput } from "./src";
 import { EditCreatorSettings, EditManagerSettings, EditFeeSettings, EditScheduleSettings, EditAutomationSettings, EditLpSettings, EditMetadataSettings, EditDepositsSettings, EditForceRebalanceSettings, EditCustomRebalanceSettings, EditAddTokenSettings, EditUpdateWeightsSettings, EditMakeDirectSwapSettings } from "./src";
 import { getRebalanceIntentPda } from "./src/instructions/pda";
-import { PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT } from "./src/constants";
+import { COMPUTE_UNITS, PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT } from "./src/constants";
 import { getJupTokenLedgerAndSwapInstructions } from "./src/jup";
 import { getSwapPairs } from "./src/states/intents/rebalanceIntent";
+import { buildCloseEncodedVaaInstruction } from "./src/states/oracles/pythOracle";
+import { prepareTxPayloadBatchSequence, prepareVersionedTxs, TxBatchData } from "./src/txUtils";
 
 
 let kp = Array.from(Keypair.generate().secretKey);
@@ -73,7 +75,7 @@ async function testStates() {
 
         createVault: false,                // TESTED
         editPrivateVaultSettings: false,   // NOT TESTED
-        addBounty: true,                   // TESTED
+        addBounty: false,                   // TESTED
 
         editCreator: false,                 // TESTED
         editManagerSettings: false,         // TESTED
@@ -565,13 +567,13 @@ async function testStates() {
                 symmetryFeesExtraData: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,],
 
                 bountyMint: new PublicKey("So11111111111111111111111111111111111111112"),
-                minBountyForVaultAutomation: new BN(200 * 50 * 10 ** 3),
-                bountyBondAmount: new BN(5 * 50 * 10 ** 3),
+                minBountyForVaultAutomation: new BN(2000 * 5000),
+                bountyBondAmount: new BN(20 * 5000),
                 bountyPerTask: {
-                    minBounty: new BN(10 * 50 * 10 ** 3),
-                    maxBounty: new BN(20 * 50 * 10 ** 3),
-                    minBountyUntil: new BN(1),
-                    maxBountyAfter: new BN(101),
+                    minBounty: new BN(20 * 5000),
+                    maxBounty: new BN(50 * 5000),
+                    minBountyUntil: new BN(10),
+                    maxBountyAfter: new BN(40),
                 },
                 bountyPerPriceUpdateTaskDivisor: new BN(3),
                 minRemainingValue: {high: new BN(0), low: new BN("1844674407370955161")},