@streamflow/common 6.0.3 → 6.1.1

package/dist/solana/types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { AccountInfo, PublicKey } from "@solana/web3.js";
+import { AccountInfo, BlockhashWithExpiryBlockHeight, Commitment, Context, PublicKey } from "@solana/web3.js";
 export interface ITransactionSolanaExt {
     computePrice?: number;
     computeLimit?: number;
@@ -20,3 +20,10 @@ export interface AtaParams {
     owner: PublicKey;
     programId?: PublicKey;
 }
+export interface ConfirmationParams {
+    hash: BlockhashWithExpiryBlockHeight;
+    context: Context;
+    commitment?: Commitment;
+}
+export declare class TransactionFailedError extends Error {
+}

package/dist/solana/types.js

@@ -1,2 +1,26 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionFailedError = void 0;
+var TransactionFailedError = /** @class */ (function (_super) {
+    __extends(TransactionFailedError, _super);
+    function TransactionFailedError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return TransactionFailedError;
+}(Error));
+exports.TransactionFailedError = TransactionFailedError;

package/dist/solana/utils.d.ts

@@ -1,7 +1,7 @@
 import { Mint } from "@solana/spl-token";
 import { SignerWalletAdapter } from "@solana/wallet-adapter-base";
-import { BlockhashWithExpiryBlockHeight, Commitment, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, SignatureStatus } from "@solana/web3.js";
-import { Account, AtaParams, ITransactionSolanaExt } from "./types";
+import { BlockhashWithExpiryBlockHeight, Commitment, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, SignatureStatus, VersionedTransaction, Context } from "@solana/web3.js";
+import { Account, AtaParams, ConfirmationParams, ITransactionSolanaExt } from "./types";
 /**
  * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
  * @param {Connection} connection - Solana web3 connection object.
@@ -23,6 +23,12 @@ export declare function isSignerWallet(walletOrKeypair: Keypair | SignerWalletAd
  * @returns {boolean} - Returns true if parameter is a Keypair.
  */
 export declare function isSignerKeypair(walletOrKeypair: Keypair | SignerWalletAdapter): walletOrKeypair is Keypair;
+/**
+ * Utility function to check whether given transaction is Versioned
+ * @param tx {Transaction | VersionedTransaction} - Transaction to check
+ * @returns {boolean} - Returns true if transaction is Versioned.
+ */
+export declare function isTransactionVersioned(tx: Transaction | VersionedTransaction): tx is VersionedTransaction;
 /**
  * Creates a Transaction with given instructions and optionally signs it.
  * @param connection - Solana client connection
@@ -33,39 +39,54 @@ export declare function isSignerKeypair(walletOrKeypair: Keypair | SignerWalletA
  * @returns Transaction and Blockhash
  */
 export declare function prepareTransaction(connection: Connection, ixs: TransactionInstruction[], payer: PublicKey | undefined | null, commitment?: Commitment, ...partialSigners: (Keypair | undefined)[]): Promise<{
-    tx: Transaction;
+    tx: VersionedTransaction;
     hash: BlockhashWithExpiryBlockHeight;
+    context: Context;
 }>;
-export declare function signTransaction(invoker: Keypair | SignerWalletAdapter, tx: Transaction): Promise<Transaction>;
+export declare function signTransaction<T extends Transaction | VersionedTransaction>(invoker: Keypair | SignerWalletAdapter, tx: T): Promise<T>;
 /**
  * Signs, sends and confirms Transaction
  * @param connection - Solana client connection
  * @param invoker - Keypair used as signer
  * @param tx - Transaction instance
- * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @param {ConfirmationParams} confirmationParams - Confirmation Params that will be used for execution
  * @returns Transaction signature
  */
-export declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction, hash: BlockhashWithExpiryBlockHeight): Promise<string>;
+export declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams): Promise<string>;
 /**
  * Sends and confirms Transaction
- * Confirmation strategy is not 100% reliable here as in times of congestion there can be a case that tx is executed,
- * but is not in `commitment` state and so it's not considered executed by the `sendAndConfirmRawTransaction` method,
- * and it raises an expiry error even though transaction may be executed soon.
- * - so we add additional 50 blocks for checks to account for such issues;
- * - also, we check for SignatureStatus one last time as it could be that websocket was slow to respond.
+ * Uses custom confirmation logic that:
+ * - simulates tx before sending separately
+ * - sends transaction without preFlight checks but with some valuable flags https://twitter.com/jordaaash/status/1774892862049800524?s=46&t=bhZ10V0r7IX5Lk5kKzxfGw
+ * - rebroadcasts a tx every 500 ms
+ * - after broadcasting check whether tx has executed once
+ * - catch errors for every actionable item, throw only the ones that signal that tx has failed
+ * - otherwise there is a chance of marking a landed tx as failed if it was broadcasted at least once
  * @param connection - Solana client connection
  * @param tx - Transaction instance
- * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @param {ConfirmationParams} confirmationParams - Confirmation Params that will be used for execution
  * @returns Transaction signature
  */
-export declare function executeTransaction(connection: Connection, tx: Transaction, hash: BlockhashWithExpiryBlockHeight): Promise<string>;
+export declare function executeTransaction(connection: Connection, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams): Promise<string>;
+/**
+ * Sends and confirm transaction in a loop, constantly re-broadcsting the tx until Blockheight expires.
+ * - we add additional 30 bocks to account for validators in an PRC pool divergence
+ * @param connection - Solana client connection
+ * @param tx - Transaction instance
+ * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @param context - context at which blockhash has been retrieve
+ * @param commitment - optional commitment that will be used for simulation and confirmation
+ */
+export declare function sendAndConfirmTransaction(connection: Connection, tx: Transaction | VersionedTransaction, { hash, context, commitment }: ConfirmationParams): Promise<string>;
+export declare function simulateTransaction(connection: Connection, tx: Transaction | VersionedTransaction): Promise<void>;
 /**
  * Confirms and validates transaction success once
  * @param connection - Solana client connection
  * @param signature - Transaction signature
+ * @param ignoreError - return status even if tx failed
  * @returns Transaction Status
  */
-export declare function confirmAndEnsureTransaction(connection: Connection, signature: string): Promise<SignatureStatus | null>;
+export declare function confirmAndEnsureTransaction(connection: Connection, signature: string, ignoreError?: boolean): Promise<SignatureStatus | null>;
 /**
  * Shorthand call signature for getAssociatedTokenAddress, with allowance for address to be offCurve
  * @param {PublicKey} mint - SPL token Mint address.
@@ -87,20 +108,23 @@ export declare function enrichAtaParams(connection: Connection, paramsBatch: Ata
  * @param connection - Solana client connection
  * @param payer - Transaction invoker, should be a signer
  * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @param commitment - optional commitment that will be used to fetch Blockhash
  * @returns Unsigned Transaction with create ATA instructions
  */
-export declare function generateCreateAtaBatchTx(connection: Connection, payer: PublicKey, paramsBatch: AtaParams[]): Promise<{
-    tx: Transaction;
+export declare function generateCreateAtaBatchTx(connection: Connection, payer: PublicKey, paramsBatch: AtaParams[], commitment?: Commitment): Promise<{
+    tx: VersionedTransaction;
     hash: BlockhashWithExpiryBlockHeight;
+    context: Context;
 }>;
 /**
  * Creates ATA for an array of owners
  * @param connection - Solana client connection
  * @param invoker - Transaction invoker and payer
  * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @param commitment - optional commitment that will be used to fetch Blockhash
  * @returns Transaction signature
  */
-export declare function createAtaBatch(connection: Connection, invoker: Keypair | SignerWalletAdapter, paramsBatch: AtaParams[]): Promise<string>;
+export declare function createAtaBatch(connection: Connection, invoker: Keypair | SignerWalletAdapter, paramsBatch: AtaParams[], commitment?: Commitment): Promise<string>;
 /**
  * Utility function that checks whether associated token accounts exist and return instructions to populate them if not
  * @param connection - Solana client connection

package/dist/solana/utils.js

@@ -35,31 +35,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -75,11 +50,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMintAndProgram = exports.prepareBaseInstructions = exports.checkOrCreateAtaBatch = exports.createAtaBatch = exports.generateCreateAtaBatchTx = exports.enrichAtaParams = exports.ataBatchExist = exports.ata = exports.confirmAndEnsureTransaction = exports.executeTransaction = exports.signAndExecuteTransaction = exports.signTransaction = exports.prepareTransaction = exports.isSignerKeypair = exports.isSignerWallet = exports.getProgramAccounts = void 0;
+exports.getMintAndProgram = exports.prepareBaseInstructions = exports.checkOrCreateAtaBatch = exports.createAtaBatch = exports.generateCreateAtaBatchTx = exports.enrichAtaParams = exports.ataBatchExist = exports.ata = exports.confirmAndEnsureTransaction = exports.simulateTransaction = exports.sendAndConfirmTransaction = exports.executeTransaction = exports.signAndExecuteTransaction = exports.signTransaction = exports.prepareTransaction = exports.isTransactionVersioned = exports.isSignerKeypair = exports.isSignerWallet = exports.getProgramAccounts = void 0;
 var spl_token_1 = require("@solana/spl-token");
 var web3_js_1 = require("@solana/web3.js");
 var bs58_1 = __importDefault(require("bs58"));
+var types_1 = require("./types");
 var utils_1 = require("../utils");
+var SIMULATE_TRIES = 3;
 /**
  * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
  * @param {Connection} connection - Solana web3 connection object.
@@ -125,6 +102,15 @@ function isSignerKeypair(walletOrKeypair) {
         walletOrKeypair.constructor.name === web3_js_1.Keypair.prototype.constructor.name);
 }
 exports.isSignerKeypair = isSignerKeypair;
+/**
+ * Utility function to check whether given transaction is Versioned
+ * @param tx {Transaction | VersionedTransaction} - Transaction to check
+ * @returns {boolean} - Returns true if transaction is Versioned.
+ */
+function isTransactionVersioned(tx) {
+    return "message" in tx;
+}
+exports.isTransactionVersioned = isTransactionVersioned;
 /**
  * Creates a Transaction with given instructions and optionally signs it.
  * @param connection - Solana client connection
@@ -140,34 +126,25 @@ function prepareTransaction(connection, ixs, payer, commitment) {
         partialSigners[_i - 4] = arguments[_i];
     }
     return __awaiter(this, void 0, void 0, function () {
-        var hash, tx, partialSigners_1, partialSigners_1_1, signer;
-        var _a, e_1, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, connection.getLatestBlockhash(commitment)];
-                case 1:
-                    hash = _c.sent();
-                    tx = (_a = new web3_js_1.Transaction({
-                        feePayer: payer,
-                        blockhash: hash.blockhash,
-                        lastValidBlockHeight: hash.lastValidBlockHeight,
-                    })).add.apply(_a, __spreadArray([], __read(ixs), false));
-                    try {
-                        for (partialSigners_1 = __values(partialSigners), partialSigners_1_1 = partialSigners_1.next(); !partialSigners_1_1.done; partialSigners_1_1 = partialSigners_1.next()) {
-                            signer = partialSigners_1_1.value;
-                            if (signer) {
-                                tx.partialSign(signer);
-                            }
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (partialSigners_1_1 && !partialSigners_1_1.done && (_b = partialSigners_1.return)) _b.call(partialSigners_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
+        var _a, hash, context, messageV0, tx, signers;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!payer) {
+                        throw new Error("Payer public key is not provided!");
                     }
-                    return [2 /*return*/, { tx: tx, hash: hash }];
+                    return [4 /*yield*/, connection.getLatestBlockhashAndContext(commitment)];
+                case 1:
+                    _a = _b.sent(), hash = _a.value, context = _a.context;
+                    messageV0 = new web3_js_1.TransactionMessage({
+                        payerKey: payer,
+                        recentBlockhash: hash.blockhash,
+                        instructions: ixs,
+                    }).compileToV0Message();
+                    tx = new web3_js_1.VersionedTransaction(messageV0);
+                    signers = partialSigners.filter(function (item) { return !!item; });
+                    tx.sign(signers);
+                    return [2 /*return*/, { tx: tx, context: context, hash: hash }];
             }
         });
     });
@@ -185,7 +162,12 @@ function signTransaction(invoker, tx) {
                     signedTx = _a.sent();
                     return [3 /*break*/, 3];
                 case 2:
-                    tx.partialSign(invoker);
+                    if (isTransactionVersioned(tx)) {
+                        tx.sign([invoker]);
+                    }
+                    else {
+                        tx.partialSign(invoker);
+                    }
                     signedTx = tx;
                     _a.label = 3;
                 case 3: return [2 /*return*/, signedTx];
@@ -199,10 +181,10 @@ exports.signTransaction = signTransaction;
  * @param connection - Solana client connection
  * @param invoker - Keypair used as signer
  * @param tx - Transaction instance
- * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @param {ConfirmationParams} confirmationParams - Confirmation Params that will be used for execution
  * @returns Transaction signature
  */
-function signAndExecuteTransaction(connection, invoker, tx, hash) {
+function signAndExecuteTransaction(connection, invoker, tx, confirmationParams) {
     return __awaiter(this, void 0, void 0, function () {
         var signedTx;
         return __generator(this, function (_a) {
@@ -210,7 +192,7 @@ function signAndExecuteTransaction(connection, invoker, tx, hash) {
                 case 0: return [4 /*yield*/, signTransaction(invoker, tx)];
                 case 1:
                     signedTx = _a.sent();
-                    return [2 /*return*/, executeTransaction(connection, signedTx, hash)];
+                    return [2 /*return*/, executeTransaction(connection, signedTx, confirmationParams)];
             }
         });
     });
@@ -218,63 +200,176 @@ function signAndExecuteTransaction(connection, invoker, tx, hash) {
 exports.signAndExecuteTransaction = signAndExecuteTransaction;
 /**
  * Sends and confirms Transaction
- * Confirmation strategy is not 100% reliable here as in times of congestion there can be a case that tx is executed,
- * but is not in `commitment` state and so it's not considered executed by the `sendAndConfirmRawTransaction` method,
- * and it raises an expiry error even though transaction may be executed soon.
- * - so we add additional 50 blocks for checks to account for such issues;
- * - also, we check for SignatureStatus one last time as it could be that websocket was slow to respond.
+ * Uses custom confirmation logic that:
+ * - simulates tx before sending separately
+ * - sends transaction without preFlight checks but with some valuable flags https://twitter.com/jordaaash/status/1774892862049800524?s=46&t=bhZ10V0r7IX5Lk5kKzxfGw
+ * - rebroadcasts a tx every 500 ms
+ * - after broadcasting check whether tx has executed once
+ * - catch errors for every actionable item, throw only the ones that signal that tx has failed
+ * - otherwise there is a chance of marking a landed tx as failed if it was broadcasted at least once
  * @param connection - Solana client connection
  * @param tx - Transaction instance
- * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @param {ConfirmationParams} confirmationParams - Confirmation Params that will be used for execution
  * @returns Transaction signature
  */
-function executeTransaction(connection, tx, hash) {
+function executeTransaction(connection, tx, confirmationParams) {
     return __awaiter(this, void 0, void 0, function () {
-        var rawTx, signature, confirmationStrategy, e_2, value;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    rawTx = tx.serialize();
-                    if (!hash.lastValidBlockHeight || !tx.signature || !hash.blockhash)
+                    if (tx.signatures.length === 0) {
                         throw Error("Error with transaction parameters.");
-                    signature = bs58_1.default.encode(tx.signature);
-                    confirmationStrategy = {
-                        lastValidBlockHeight: hash.lastValidBlockHeight + 50,
-                        signature: signature,
-                        blockhash: hash.blockhash,
-                    };
-                    _a.label = 1;
+                    }
+                    return [4 /*yield*/, simulateTransaction(connection, tx)];
                 case 1:
-                    _a.trys.push([1, 3, , 7]);
-                    return [4 /*yield*/, (0, web3_js_1.sendAndConfirmRawTransaction)(connection, rawTx, confirmationStrategy)];
-                case 2: return [2 /*return*/, _a.sent()];
+                    _a.sent();
+                    return [2 /*return*/, sendAndConfirmTransaction(connection, tx, confirmationParams)];
+            }
+        });
+    });
+}
+exports.executeTransaction = executeTransaction;
+/**
+ * Sends and confirm transaction in a loop, constantly re-broadcsting the tx until Blockheight expires.
+ * - we add additional 30 bocks to account for validators in an PRC pool divergence
+ * @param connection - Solana client connection
+ * @param tx - Transaction instance
+ * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @param context - context at which blockhash has been retrieve
+ * @param commitment - optional commitment that will be used for simulation and confirmation
+ */
+function sendAndConfirmTransaction(connection, tx, _a) {
+    var hash = _a.hash, context = _a.context, commitment = _a.commitment;
+    return __awaiter(this, void 0, void 0, function () {
+        var isVersioned, signature, blockheight, transactionSent, rawTransaction, e_1, value, e_2, _e_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    isVersioned = isTransactionVersioned(tx);
+                    if (isVersioned) {
+                        signature = bs58_1.default.encode(tx.signatures[0]);
+                    }
+                    else {
+                        signature = bs58_1.default.encode(tx.signature);
+                    }
+                    return [4 /*yield*/, connection.getBlockHeight(commitment)];
+                case 1:
+                    blockheight = _b.sent();
+                    transactionSent = false;
+                    rawTransaction = tx.serialize();
+                    _b.label = 2;
+                case 2:
+                    if (!(blockheight < hash.lastValidBlockHeight + 15)) return [3 /*break*/, 20];
+                    _b.label = 3;
                 case 3:
-                    e_2 = _a.sent();
-                    if (!(e_2 instanceof web3_js_1.TransactionExpiredBlockheightExceededError)) return [3 /*break*/, 6];
-                    return [4 /*yield*/, (0, utils_1.sleep)(1000)];
+                    _b.trys.push([3, 6, , 9]);
+                    if (!(blockheight < hash.lastValidBlockHeight || !transactionSent)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, connection.sendRawTransaction(rawTransaction, {
+                            maxRetries: 0,
+                            minContextSlot: context.slot,
+                            preflightCommitment: commitment,
+                            skipPreflight: true,
+                        })];
                 case 4:
-                    _a.sent();
+                    _b.sent();
+                    transactionSent = true;
+                    _b.label = 5;
+                case 5: return [3 /*break*/, 9];
+                case 6:
+                    e_1 = _b.sent();
+                    if (!(transactionSent ||
+                        (e_1 instanceof web3_js_1.SendTransactionError && e_1.message.includes("Minimum context slot has not been reached")))) return [3 /*break*/, 8];
+                    return [4 /*yield*/, (0, utils_1.sleep)(500)];
+                case 7:
+                    _b.sent();
+                    return [3 /*break*/, 2];
+                case 8: throw e_1;
+                case 9: return [4 /*yield*/, (0, utils_1.sleep)(500)];
+                case 10:
+                    _b.sent();
+                    _b.label = 11;
+                case 11:
+                    _b.trys.push([11, 13, , 15]);
                     return [4 /*yield*/, confirmAndEnsureTransaction(connection, signature)];
-                case 5:
-                    value = _a.sent();
-                    if (!value) {
+                case 12:
+                    value = _b.sent();
+                    if (value) {
+                        return [2 /*return*/, signature];
+                    }
+                    return [3 /*break*/, 15];
+                case 13:
+                    e_2 = _b.sent();
+                    if (e_2 instanceof types_1.TransactionFailedError) {
                         throw e_2;
                     }
-                    return [2 /*return*/, signature];
-                case 6: throw e_2;
+                    return [4 /*yield*/, (0, utils_1.sleep)(500)];
+                case 14:
+                    _b.sent();
+                    return [3 /*break*/, 15];
+                case 15:
+                    _b.trys.push([15, 17, , 19]);
+                    return [4 /*yield*/, connection.getBlockHeight(commitment)];
+                case 16:
+                    blockheight = _b.sent();
+                    return [3 /*break*/, 19];
+                case 17:
+                    _e_1 = _b.sent();
+                    return [4 /*yield*/, (0, utils_1.sleep)(500)];
+                case 18:
+                    _b.sent();
+                    return [3 /*break*/, 19];
+                case 19: return [3 /*break*/, 2];
+                case 20: throw new Error("Transaction ".concat(signature, " expired."));
+            }
+        });
+    });
+}
+exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
+function simulateTransaction(connection, tx) {
+    return __awaiter(this, void 0, void 0, function () {
+        var i, res, errMessage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < SIMULATE_TRIES)) return [3 /*break*/, 7];
+                    res = void 0;
+                    if (!isTransactionVersioned(tx)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, connection.simulateTransaction(tx)];
+                case 2:
+                    res = _a.sent();
+                    return [3 /*break*/, 5];
+                case 3: return [4 /*yield*/, connection.simulateTransaction(tx)];
+                case 4:
+                    res = _a.sent();
+                    _a.label = 5;
+                case 5:
+                    if (res.value.err) {
+                        errMessage = JSON.stringify(res.value.err);
+                        if (!errMessage.includes("BlockhashNotFound") || i === SIMULATE_TRIES - 1) {
+                            throw new web3_js_1.SendTransactionError("failed to simulate transaction: " + errMessage, res.value.logs || undefined);
+                        }
+                    }
+                    return [3 /*break*/, 7];
+                case 6:
+                    i++;
+                    return [3 /*break*/, 1];
                 case 7: return [2 /*return*/];
             }
         });
     });
 }
-exports.executeTransaction = executeTransaction;
+exports.simulateTransaction = simulateTransaction;
 /**
  * Confirms and validates transaction success once
  * @param connection - Solana client connection
  * @param signature - Transaction signature
+ * @param ignoreError - return status even if tx failed
  * @returns Transaction Status
  */
-function confirmAndEnsureTransaction(connection, signature) {
+function confirmAndEnsureTransaction(connection, signature, ignoreError) {
     return __awaiter(this, void 0, void 0, function () {
         var response, value;
         return __generator(this, function (_a) {
@@ -289,9 +384,9 @@ function confirmAndEnsureTransaction(connection, signature) {
                     if (!value) {
                         return [2 /*return*/, null];
                     }
-                    if (value.err) {
+                    if (!ignoreError && value.err) {
                         // That's how solana-web3js does it, `err` here is an object that won't really be handled
-                        throw new Error("Raw transaction ".concat(signature, " failed (").concat(JSON.stringify({ err: value.err }), ")"));
+                        throw new types_1.TransactionFailedError("Raw transaction ".concat(signature, " failed (").concat(JSON.stringify({ err: value.err }), ")"));
                     }
                     switch (connection.commitment) {
                         case "confirmed":
@@ -398,12 +493,12 @@ exports.enrichAtaParams = enrichAtaParams;
  * @param connection - Solana client connection
  * @param payer - Transaction invoker, should be a signer
  * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @param commitment - optional commitment that will be used to fetch Blockhash
  * @returns Unsigned Transaction with create ATA instructions
  */
-function generateCreateAtaBatchTx(connection, payer, paramsBatch) {
+function generateCreateAtaBatchTx(connection, payer, paramsBatch, commitment) {
     return __awaiter(this, void 0, void 0, function () {
-        var ixs, hash, tx;
-        var _a;
+        var ixs, _a, hash, context, messageV0, tx;
         var _this = this;
         return __generator(this, function (_b) {
             switch (_b.label) {
@@ -427,15 +522,16 @@ function generateCreateAtaBatchTx(connection, payer, paramsBatch) {
                         }))];
                 case 2:
                     ixs = _b.sent();
-                    return [4 /*yield*/, connection.getLatestBlockhash()];
+                    return [4 /*yield*/, connection.getLatestBlockhashAndContext({ commitment: commitment })];
                 case 3:
-                    hash = _b.sent();
-                    tx = (_a = new web3_js_1.Transaction({
-                        feePayer: payer,
-                        blockhash: hash.blockhash,
-                        lastValidBlockHeight: hash.lastValidBlockHeight,
-                    })).add.apply(_a, __spreadArray([], __read(ixs), false));
-                    return [2 /*return*/, { tx: tx, hash: hash }];
+                    _a = _b.sent(), hash = _a.value, context = _a.context;
+                    messageV0 = new web3_js_1.TransactionMessage({
+                        payerKey: payer,
+                        recentBlockhash: hash.blockhash,
+                        instructions: ixs,
+                    }).compileToV0Message();
+                    tx = new web3_js_1.VersionedTransaction(messageV0);
+                    return [2 /*return*/, { tx: tx, hash: hash, context: context }];
             }
         });
     });
@@ -446,11 +542,12 @@ exports.generateCreateAtaBatchTx = generateCreateAtaBatchTx;
  * @param connection - Solana client connection
  * @param invoker - Transaction invoker and payer
  * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @param commitment - optional commitment that will be used to fetch Blockhash
  * @returns Transaction signature
  */
-function createAtaBatch(connection, invoker, paramsBatch) {
+function createAtaBatch(connection, invoker, paramsBatch, commitment) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, tx, hash, _b, _c;
+        var _a, tx, hash, context, _b, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -458,10 +555,10 @@ function createAtaBatch(connection, invoker, paramsBatch) {
                     _c = [connection,
                         invoker.publicKey];
                     return [4 /*yield*/, enrichAtaParams(connection, paramsBatch)];
-                case 1: return [4 /*yield*/, _b.apply(void 0, _c.concat([_d.sent()]))];
+                case 1: return [4 /*yield*/, _b.apply(void 0, _c.concat([_d.sent(), commitment]))];
                 case 2:
-                    _a = _d.sent(), tx = _a.tx, hash = _a.hash;
-                    return [2 /*return*/, signAndExecuteTransaction(connection, invoker, tx, hash)];
+                    _a = _d.sent(), tx = _a.tx, hash = _a.hash, context = _a.context;
+                    return [2 /*return*/, signAndExecuteTransaction(connection, invoker, tx, { hash: hash, context: context, commitment: commitment })];
             }
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamflow/common",
-  "version": "6.0.3",
+  "version": "6.1.1",
   "description": "Common utilities and types used by streamflow packages.",
   "homepage": "https://github.com/streamflow-finance/js-sdk/",
   "main": "dist/index.js",
@@ -23,7 +23,7 @@
     "lint-config": "eslint --print-config",
     "prepublishOnly": "npm run lint && npm run build"
   },
-  "gitHead": "d8f882dcb32394efb4ca997fff05e8c30128f14f",
+  "gitHead": "a05d8010b3000b00038ca16a4d5b915436319bdc",
   "devDependencies": {
     "@streamflow/eslint-config": "6.0.0",
     "@types/bn.js": "5.1.1",