@streamflow/common 6.0.1 → 6.0.3

package/dist/solana/types.d.ts

@@ -18,4 +18,5 @@ export interface CheckAssociatedTokenAccountsData {
 export interface AtaParams {
     mint: PublicKey;
     owner: PublicKey;
+    programId?: PublicKey;
 }

package/dist/solana/utils.d.ts

@@ -1,5 +1,6 @@
+import { Mint } from "@solana/spl-token";
 import { SignerWalletAdapter } from "@solana/wallet-adapter-base";
-import { BlockhashWithExpiryBlockHeight, Commitment, Connection, Keypair, PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
+import { BlockhashWithExpiryBlockHeight, Commitment, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, SignatureStatus } from "@solana/web3.js";
 import { Account, AtaParams, ITransactionSolanaExt } from "./types";
 /**
  * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
@@ -38,31 +39,49 @@ export declare function prepareTransaction(connection: Connection, ixs: Transact
 export declare function signTransaction(invoker: Keypair | SignerWalletAdapter, tx: Transaction): Promise<Transaction>;
 /**
  * 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
+ * @returns Transaction signature
+ */
+export declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction, hash: BlockhashWithExpiryBlockHeight): 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.
+ * - 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.
  * @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
  * @returns Transaction signature
  */
-export declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction, hash: BlockhashWithExpiryBlockHeight): Promise<string>;
+export declare function executeTransaction(connection: Connection, tx: Transaction, hash: BlockhashWithExpiryBlockHeight): Promise<string>;
+/**
+ * Confirms and validates transaction success once
+ * @param connection - Solana client connection
+ * @param signature - Transaction signature
+ * @returns Transaction Status
+ */
+export declare function confirmAndEnsureTransaction(connection: Connection, signature: string): Promise<SignatureStatus | null>;
 /**
  * Shorthand call signature for getAssociatedTokenAddress, with allowance for address to be offCurve
  * @param {PublicKey} mint - SPL token Mint address.
  * @param {PublicKey} owner - Owner of the Associated Token Address
+ * @param {PublicKey} programId - Program ID of the mint
  * @return {Promise<PublicKey>} - Associated Token Address
  */
-export declare function ata(mint: PublicKey, owner: PublicKey): Promise<PublicKey>;
+export declare function ata(mint: PublicKey, owner: PublicKey, programId?: PublicKey): Promise<PublicKey>;
 /**
  * Function that checks whether ATA exists for each provided owner
  * @param connection - Solana client connection
- * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
- * @returns Array of boolean where each members corresponds to owners member
+ * @param paramsBatch - Array of Params for each ATA account: {mint, owner}
+ * @returns Array of boolean where each member corresponds to an owner
  */
 export declare function ataBatchExist(connection: Connection, paramsBatch: AtaParams[]): Promise<boolean[]>;
+export declare function enrichAtaParams(connection: Connection, paramsBatch: AtaParams[]): Promise<AtaParams[]>;
 /**
  * Generates a Transaction to create ATA for an array of owners
  * @param connection - Solana client connection
@@ -88,12 +107,26 @@ export declare function createAtaBatch(connection: Connection, invoker: Keypair
  * @param owners - Array of ATA owners
  * @param mint - Mint for which ATA will be checked
  * @param invoker - Transaction invoker and payer
+ * @param programId - Program ID of the Mint
  * @returns Array of Transaction Instructions that should be added to a transaction
  */
-export declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair): Promise<TransactionInstruction[]>;
+export declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair, programId?: PublicKey): Promise<TransactionInstruction[]>;
 /**
  * Create Base instructions for Solana
  * - sets compute price if `computePrice` is provided
  * - sets compute limit if `computeLimit` is provided
  */
 export declare function prepareBaseInstructions(connection: Connection, { computePrice, computeLimit }: ITransactionSolanaExt): TransactionInstruction[];
+/**
+ * Retrieve information about a mint and its program ID, support all Token Programs.
+ *
+ * @param connection Connection to use
+ * @param address    Mint account
+ * @param commitment Desired level of commitment for querying the state
+ *
+ * @return Mint information
+ */
+export declare function getMintAndProgram(connection: Connection, address: PublicKey, commitment?: Commitment): Promise<{
+    mint: Mint;
+    programId: PublicKey;
+}>;

package/dist/solana/utils.js

@@ -75,10 +75,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareBaseInstructions = exports.checkOrCreateAtaBatch = exports.createAtaBatch = exports.generateCreateAtaBatchTx = exports.ataBatchExist = exports.ata = 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.executeTransaction = exports.signAndExecuteTransaction = exports.signTransaction = exports.prepareTransaction = 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 utils_1 = require("../utils");
 /**
  * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
  * @param {Connection} connection - Solana web3 connection object.
@@ -195,10 +196,6 @@ function signTransaction(invoker, tx) {
 exports.signTransaction = signTransaction;
 /**
  * Signs, 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.
  * @param connection - Solana client connection
  * @param invoker - Keypair used as signer
  * @param tx - Transaction instance
@@ -207,41 +204,138 @@ exports.signTransaction = signTransaction;
  */
 function signAndExecuteTransaction(connection, invoker, tx, hash) {
     return __awaiter(this, void 0, void 0, function () {
-        var signedTx, rawTx, confirmationStrategy;
+        var signedTx;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, signTransaction(invoker, tx)];
                 case 1:
                     signedTx = _a.sent();
-                    rawTx = signedTx.serialize();
-                    if (!hash.lastValidBlockHeight || !signedTx.signature || !hash.blockhash)
+                    return [2 /*return*/, executeTransaction(connection, signedTx, 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.
+ * @param connection - Solana client connection
+ * @param tx - Transaction instance
+ * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @returns Transaction signature
+ */
+function executeTransaction(connection, tx, hash) {
+    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)
                         throw Error("Error with transaction parameters.");
+                    signature = bs58_1.default.encode(tx.signature);
                     confirmationStrategy = {
                         lastValidBlockHeight: hash.lastValidBlockHeight + 50,
-                        signature: bs58_1.default.encode(signedTx.signature),
+                        signature: signature,
                         blockhash: hash.blockhash,
                     };
-                    return [2 /*return*/, (0, web3_js_1.sendAndConfirmRawTransaction)(connection, rawTx, confirmationStrategy)];
+                    _a.label = 1;
+                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()];
+                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)];
+                case 4:
+                    _a.sent();
+                    return [4 /*yield*/, confirmAndEnsureTransaction(connection, signature)];
+                case 5:
+                    value = _a.sent();
+                    if (!value) {
+                        throw e_2;
+                    }
+                    return [2 /*return*/, signature];
+                case 6: throw e_2;
+                case 7: return [2 /*return*/];
             }
         });
     });
 }
-exports.signAndExecuteTransaction = signAndExecuteTransaction;
+exports.executeTransaction = executeTransaction;
+/**
+ * Confirms and validates transaction success once
+ * @param connection - Solana client connection
+ * @param signature - Transaction signature
+ * @returns Transaction Status
+ */
+function confirmAndEnsureTransaction(connection, signature) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, value;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, connection.getSignatureStatus(signature)];
+                case 1:
+                    response = _a.sent();
+                    if (!response) {
+                        return [2 /*return*/, null];
+                    }
+                    value = response.value;
+                    if (!value) {
+                        return [2 /*return*/, null];
+                    }
+                    if (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 }), ")"));
+                    }
+                    switch (connection.commitment) {
+                        case "confirmed":
+                        case "single":
+                        case "singleGossip": {
+                            if (value.confirmationStatus === "processed") {
+                                return [2 /*return*/, null];
+                            }
+                            break;
+                        }
+                        case "finalized":
+                        case "max":
+                        case "root": {
+                            if (value.confirmationStatus === "processed" || value.confirmationStatus === "confirmed") {
+                                return [2 /*return*/, null];
+                            }
+                            break;
+                        }
+                        // exhaust enums to ensure full coverage
+                        case "processed":
+                        case "recent":
+                    }
+                    return [2 /*return*/, value];
+            }
+        });
+    });
+}
+exports.confirmAndEnsureTransaction = confirmAndEnsureTransaction;
 /**
  * Shorthand call signature for getAssociatedTokenAddress, with allowance for address to be offCurve
  * @param {PublicKey} mint - SPL token Mint address.
  * @param {PublicKey} owner - Owner of the Associated Token Address
+ * @param {PublicKey} programId - Program ID of the mint
  * @return {Promise<PublicKey>} - Associated Token Address
  */
-function ata(mint, owner) {
-    return (0, spl_token_1.getAssociatedTokenAddress)(mint, owner, true);
+function ata(mint, owner, programId) {
+    return (0, spl_token_1.getAssociatedTokenAddress)(mint, owner, true, programId);
 }
 exports.ata = ata;
 /**
  * Function that checks whether ATA exists for each provided owner
  * @param connection - Solana client connection
- * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
- * @returns Array of boolean where each members corresponds to owners member
+ * @param paramsBatch - Array of Params for each ATA account: {mint, owner}
+ * @returns Array of boolean where each member corresponds to an owner
  */
 function ataBatchExist(connection, paramsBatch) {
     return __awaiter(this, void 0, void 0, function () {
@@ -250,16 +344,10 @@ function ataBatchExist(connection, paramsBatch) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, Promise.all(paramsBatch.map(function (_a) {
-                        var mint = _a.mint, owner = _a.owner;
+                        var mint = _a.mint, owner = _a.owner, programId = _a.programId;
                         return __awaiter(_this, void 0, void 0, function () {
-                            var pubkey;
                             return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0: return [4 /*yield*/, ata(mint, owner)];
-                                    case 1:
-                                        pubkey = _b.sent();
-                                        return [2 /*return*/, pubkey];
-                                }
+                                return [2 /*return*/, ata(mint, owner, programId)];
                             });
                         });
                     }))];
@@ -274,6 +362,37 @@ function ataBatchExist(connection, paramsBatch) {
     });
 }
 exports.ataBatchExist = ataBatchExist;
+function enrichAtaParams(connection, paramsBatch) {
+    return __awaiter(this, void 0, void 0, function () {
+        var programIdByMint;
+        var _this = this;
+        return __generator(this, function (_a) {
+            programIdByMint = {};
+            return [2 /*return*/, Promise.all(paramsBatch.map(function (params) { return __awaiter(_this, void 0, void 0, function () {
+                    var mintStr, programId;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (params.programId) {
+                                    return [2 /*return*/, params];
+                                }
+                                mintStr = params.mint.toString();
+                                if (!!(mintStr in programIdByMint)) return [3 /*break*/, 2];
+                                return [4 /*yield*/, getMintAndProgram(connection, params.mint)];
+                            case 1:
+                                programId = (_a.sent()).programId;
+                                programIdByMint[mintStr] = programId;
+                                _a.label = 2;
+                            case 2:
+                                params.programId = programIdByMint[mintStr];
+                                return [2 /*return*/, params];
+                        }
+                    });
+                }); }))];
+        });
+    });
+}
+exports.enrichAtaParams = enrichAtaParams;
 /**
  * Generates a Transaction to create ATA for an array of owners
  * @param connection - Solana client connection
@@ -288,25 +407,28 @@ function generateCreateAtaBatchTx(connection, payer, paramsBatch) {
         var _this = this;
         return __generator(this, function (_b) {
             switch (_b.label) {
-                case 0: return [4 /*yield*/, Promise.all(paramsBatch.map(function (_a) {
-                        var mint = _a.mint, owner = _a.owner;
-                        return __awaiter(_this, void 0, void 0, function () {
-                            var _b, _c;
-                            return __generator(this, function (_d) {
-                                switch (_d.label) {
-                                    case 0:
-                                        _b = spl_token_1.createAssociatedTokenAccountInstruction;
-                                        _c = [payer];
-                                        return [4 /*yield*/, ata(mint, owner)];
-                                    case 1: return [2 /*return*/, _b.apply(void 0, _c.concat([_d.sent(), owner, mint]))];
-                                }
-                            });
-                        });
-                    }))];
+                case 0: return [4 /*yield*/, enrichAtaParams(connection, paramsBatch)];
                 case 1:
+                    paramsBatch = _b.sent();
+                    return [4 /*yield*/, Promise.all(paramsBatch.map(function (_a) {
+                            var mint = _a.mint, owner = _a.owner, programId = _a.programId;
+                            return __awaiter(_this, void 0, void 0, function () {
+                                var _b, _c;
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            _b = spl_token_1.createAssociatedTokenAccountInstruction;
+                                            _c = [payer];
+                                            return [4 /*yield*/, ata(mint, owner)];
+                                        case 1: return [2 /*return*/, _b.apply(void 0, _c.concat([_d.sent(), owner, mint, programId]))];
+                                    }
+                                });
+                            });
+                        }))];
+                case 2:
                     ixs = _b.sent();
                     return [4 /*yield*/, connection.getLatestBlockhash()];
-                case 2:
+                case 3:
                     hash = _b.sent();
                     tx = (_a = new web3_js_1.Transaction({
                         feePayer: payer,
@@ -328,12 +450,17 @@ exports.generateCreateAtaBatchTx = generateCreateAtaBatchTx;
  */
 function createAtaBatch(connection, invoker, paramsBatch) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, tx, hash;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, generateCreateAtaBatchTx(connection, invoker.publicKey, paramsBatch)];
-                case 1:
-                    _a = _b.sent(), tx = _a.tx, hash = _a.hash;
+        var _a, tx, hash, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _b = generateCreateAtaBatchTx;
+                    _c = [connection,
+                        invoker.publicKey];
+                    return [4 /*yield*/, enrichAtaParams(connection, paramsBatch)];
+                case 1: return [4 /*yield*/, _b.apply(void 0, _c.concat([_d.sent()]))];
+                case 2:
+                    _a = _d.sent(), tx = _a.tx, hash = _a.hash;
                     return [2 /*return*/, signAndExecuteTransaction(connection, invoker, tx, hash)];
             }
         });
@@ -346,12 +473,13 @@ exports.createAtaBatch = createAtaBatch;
  * @param owners - Array of ATA owners
  * @param mint - Mint for which ATA will be checked
  * @param invoker - Transaction invoker and payer
+ * @param programId - Program ID of the Mint
  * @returns Array of Transaction Instructions that should be added to a transaction
  */
-function checkOrCreateAtaBatch(connection, owners, mint, invoker) {
+function checkOrCreateAtaBatch(connection, owners, mint, invoker, programId) {
     return __awaiter(this, void 0, void 0, function () {
-        var ixs, atas, owners_1, owners_1_1, owner, _a, _b, e_2_1, response, i;
-        var e_2, _c;
+        var ixs, atas, owners_1, owners_1_1, owner, _a, _b, e_3_1, response, i;
+        var e_3, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -366,7 +494,7 @@ function checkOrCreateAtaBatch(connection, owners, mint, invoker) {
                     if (!!owners_1_1.done) return [3 /*break*/, 5];
                     owner = owners_1_1.value;
                     _b = (_a = atas).push;
-                    return [4 /*yield*/, ata(mint, owner)];
+                    return [4 /*yield*/, ata(mint, owner, programId)];
                 case 3:
                     _b.apply(_a, [_d.sent()]);
                     _d.label = 4;
@@ -375,21 +503,21 @@ function checkOrCreateAtaBatch(connection, owners, mint, invoker) {
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_2_1 = _d.sent();
-                    e_2 = { error: e_2_1 };
+                    e_3_1 = _d.sent();
+                    e_3 = { error: e_3_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
                         if (owners_1_1 && !owners_1_1.done && (_c = owners_1.return)) _c.call(owners_1);
                     }
-                    finally { if (e_2) throw e_2.error; }
+                    finally { if (e_3) throw e_3.error; }
                     return [7 /*endfinally*/];
                 case 8: return [4 /*yield*/, connection.getMultipleAccountsInfo(atas)];
                 case 9:
                     response = _d.sent();
                     for (i = 0; i < response.length; i++) {
                         if (!response[i]) {
-                            ixs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(invoker.publicKey, atas[i], owners[i], mint));
+                            ixs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(invoker.publicKey, atas[i], owners[i], mint, programId));
                         }
                     }
                     return [2 /*return*/, ixs];
@@ -415,3 +543,33 @@ function prepareBaseInstructions(connection, _a) {
     return ixs;
 }
 exports.prepareBaseInstructions = prepareBaseInstructions;
+/**
+ * Retrieve information about a mint and its program ID, support all Token Programs.
+ *
+ * @param connection Connection to use
+ * @param address    Mint account
+ * @param commitment Desired level of commitment for querying the state
+ *
+ * @return Mint information
+ */
+function getMintAndProgram(connection, address, commitment) {
+    return __awaiter(this, void 0, void 0, function () {
+        var accountInfo, programId;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, connection.getAccountInfo(address, commitment)];
+                case 1:
+                    accountInfo = _a.sent();
+                    programId = accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.owner;
+                    if (!(programId === null || programId === void 0 ? void 0 : programId.equals(spl_token_1.TOKEN_PROGRAM_ID)) && !(programId === null || programId === void 0 ? void 0 : programId.equals(spl_token_1.TOKEN_2022_PROGRAM_ID))) {
+                        programId = spl_token_1.TOKEN_PROGRAM_ID;
+                    }
+                    return [2 /*return*/, {
+                            mint: (0, spl_token_1.unpackMint)(address, accountInfo, programId),
+                            programId: programId,
+                        }];
+            }
+        });
+    });
+}
+exports.getMintAndProgram = getMintAndProgram;

package/dist/utils.d.ts

@@ -20,3 +20,8 @@ export declare const getNumberFromBN: (value: BN, decimals: number) => number;
  * @returns {T}
  */
 export declare function handleContractError<T>(func: () => Promise<T>, callback?: (err: Error) => string | null): Promise<T>;
+/**
+ * Pause async function execution for given amount of milliseconds
+ * @param ms millisecond to sleep for
+ */
+export declare function sleep(ms: number): Promise<void>;

package/dist/utils.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleContractError = exports.getNumberFromBN = exports.getBN = void 0;
+exports.sleep = exports.handleContractError = exports.getNumberFromBN = exports.getBN = void 0;
 var bn_js_1 = __importDefault(require("bn.js"));
 var types_1 = require("./types");
 /**
@@ -97,3 +97,11 @@ function handleContractError(func, callback) {
     });
 }
 exports.handleContractError = handleContractError;
+/**
+ * Pause async function execution for given amount of milliseconds
+ * @param ms millisecond to sleep for
+ */
+function sleep(ms) {
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+}
+exports.sleep = sleep;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamflow/common",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "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": "07782122a48131b4589edd9c536bb7f29dcbe0c9",
+  "gitHead": "d8f882dcb32394efb4ca997fff05e8c30128f14f",
   "devDependencies": {
     "@streamflow/eslint-config": "6.0.0",
     "@types/bn.js": "5.1.1",