@symmetry-hq/sdk 1.0.11 → 1.0.12

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/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symmetry-hq/sdk",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "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/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

@@ -73,7 +73,7 @@ async function testStates() {
 
         createVault: false,                // TESTED
         editPrivateVaultSettings: false,   // NOT TESTED
-        addBounty: true,                   // TESTED
+        addBounty: false,                   // TESTED
 
         editCreator: false,                 // TESTED
         editManagerSettings: false,         // TESTED