@streamflow/common 6.3.8 → 7.0.0-alpha.1

package/dist/{index.js → cjs/index.js}

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./utils.js"), exports);

package/dist/{solana → cjs/solana}/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./instructions"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils"), exports);
+__exportStar(require("./instructions.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./utils.js"), exports);

package/dist/{solana → cjs/solana}/utils.js

@@ -55,8 +55,8 @@ var spl_token_1 = require("@solana/spl-token");
 var web3_js_1 = require("@solana/web3.js");
 var bs58_1 = __importDefault(require("bs58"));
 var p_queue_1 = __importDefault(require("p-queue"));
-var types_1 = require("./types");
-var utils_1 = require("../utils");
+var types_js_1 = require("./types.js");
+var utils_js_1 = require("../utils.js");
 var SIMULATE_TRIES = 3;
 var buildSendThrottler = function (sendRate) {
     return new p_queue_1.default({ concurrency: sendRate, intervalCap: 1, interval: 1000 });
@@ -323,12 +323,12 @@ function sendAndConfirmTransaction(connection, tx, _a, _b) {
                     e_1 = _d.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)];
+                    return [4 /*yield*/, (0, utils_js_1.sleep)(500)];
                 case 7:
                     _d.sent();
                     return [3 /*break*/, 2];
                 case 8: throw e_1;
-                case 9: return [4 /*yield*/, (0, utils_1.sleep)(500)];
+                case 9: return [4 /*yield*/, (0, utils_js_1.sleep)(500)];
                 case 10:
                     _d.sent();
                     _d.label = 11;
@@ -343,10 +343,10 @@ function sendAndConfirmTransaction(connection, tx, _a, _b) {
                     return [3 /*break*/, 15];
                 case 13:
                     e_2 = _d.sent();
-                    if (e_2 instanceof types_1.TransactionFailedError) {
+                    if (e_2 instanceof types_js_1.TransactionFailedError) {
                         throw e_2;
                     }
-                    return [4 /*yield*/, (0, utils_1.sleep)(500)];
+                    return [4 /*yield*/, (0, utils_js_1.sleep)(500)];
                 case 14:
                     _d.sent();
                     return [3 /*break*/, 15];
@@ -358,7 +358,7 @@ function sendAndConfirmTransaction(connection, tx, _a, _b) {
                     return [3 /*break*/, 19];
                 case 17:
                     _e_1 = _d.sent();
-                    return [4 /*yield*/, (0, utils_1.sleep)(500)];
+                    return [4 /*yield*/, (0, utils_js_1.sleep)(500)];
                 case 18:
                     _d.sent();
                     return [3 /*break*/, 19];
@@ -430,7 +430,7 @@ function confirmAndEnsureTransaction(connection, signature, ignoreError) {
                     }
                     if (!ignoreError && value.err) {
                         // That's how solana-web3js does it, `err` here is an object that won't really be handled
-                        throw new types_1.TransactionFailedError("Raw transaction ".concat(signature, " failed (").concat(JSON.stringify({ err: value.err }), ")"));
+                        throw new types_js_1.TransactionFailedError("Raw transaction ".concat(signature, " failed (").concat(JSON.stringify({ err: value.err }), ")"));
                     }
                     switch (connection.commitment) {
                         case "confirmed":

package/dist/{utils.js → cjs/utils.js}

@@ -41,7 +41,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sleep = exports.handleContractError = exports.getNumberFromBN = exports.getBN = void 0;
 var bn_js_1 = __importDefault(require("bn.js"));
-var types_1 = require("./types");
+var types_js_1 = require("./types.js");
 /**
  * Used for conversion of token amounts to their Big Number representation.
  * Get Big Number representation in the smallest units from the same value in the highest units.
@@ -86,9 +86,9 @@ function handleContractError(func, callback) {
                     err_1 = _a.sent();
                     if (err_1 instanceof Error) {
                         if (callback) {
-                            throw new types_1.ContractError(err_1, callback(err_1));
+                            throw new types_js_1.ContractError(err_1, callback(err_1));
                         }
-                        throw new types_1.ContractError(err_1);
+                        throw new types_js_1.ContractError(err_1);
                     }
                     throw err_1;
                 case 3: return [2 /*return*/];

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./utils.js";

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./utils.js";

package/dist/esm/solana/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./instructions.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/esm/solana/index.js

@@ -0,0 +1,3 @@
+export * from "./instructions.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/esm/solana/instructions.js

@@ -0,0 +1,18 @@
+import { getAssociatedTokenAddress, NATIVE_MINT, createAssociatedTokenAccountInstruction, createSyncNativeInstruction, } from "@solana/spl-token";
+import { SystemProgram } from "@solana/web3.js";
+export const prepareWrappedAccount = async (connection, senderAddress, amount) => {
+    const tokenAccount = await getAssociatedTokenAddress(NATIVE_MINT, senderAddress, true);
+    const accInfo = await connection.getParsedAccountInfo(tokenAccount);
+    const instructions = (accInfo.value?.lamports ?? 0) > 0
+        ? []
+        : [createAssociatedTokenAccountInstruction(senderAddress, tokenAccount, senderAddress, NATIVE_MINT)];
+    return [
+        ...instructions,
+        SystemProgram.transfer({
+            fromPubkey: senderAddress,
+            toPubkey: tokenAccount,
+            lamports: amount.toNumber(),
+        }),
+        createSyncNativeInstruction(tokenAccount),
+    ];
+};

package/dist/esm/solana/types.js

@@ -0,0 +1,7 @@
+export class TransactionFailedError extends Error {
+    constructor(m) {
+        super(m);
+        Object.setPrototypeOf(this, TransactionFailedError.prototype);
+        this.name = "TransactionFailedError";
+    }
+}

package/dist/{solana → esm/solana}/utils.d.ts

@@ -2,7 +2,7 @@ import { Mint } from "@solana/spl-token";
 import { SignerWalletAdapter } from "@solana/wallet-adapter-base";
 import { BlockhashWithExpiryBlockHeight, Commitment, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, SignatureStatus, VersionedTransaction, Context, RpcResponseAndContext, SimulatedTransactionResponse } from "@solana/web3.js";
 import PQueue from "p-queue";
-import { Account, AtaParams, ConfirmationParams, ITransactionSolanaExt, ThrottleParams } from "./types";
+import { Account, AtaParams, ConfirmationParams, ITransactionSolanaExt, ThrottleParams } from "./types.js";
 export declare const buildSendThrottler: (sendRate: number) => PQueue;
 /**
  * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface

package/dist/esm/solana/utils.js

@@ -0,0 +1,415 @@
+import { createAssociatedTokenAccountInstruction, getAssociatedTokenAddress, unpackMint, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, } from "@solana/spl-token";
+import { ComputeBudgetProgram, Keypair, TransactionMessage, VersionedTransaction, SendTransactionError, } from "@solana/web3.js";
+import bs58 from "bs58";
+import PQueue from "p-queue";
+import { TransactionFailedError, } from "./types.js";
+import { sleep } from "../utils.js";
+const SIMULATE_TRIES = 3;
+export const buildSendThrottler = (sendRate) => {
+    return new PQueue({ concurrency: sendRate, intervalCap: 1, interval: 1000 });
+};
+/**
+ * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
+ * @param {Connection} connection - Solana web3 connection object.
+ * @param {PublicKey} wallet - PublicKey to compare against.
+ * @param {number} offset - Offset of bits of the PublicKey in the account binary.
+ * @param {PublicKey} programId - Solana program ID.
+ * @return {Promise<Account[]>} - Array of resulting accounts.
+ */
+export async function getProgramAccounts(connection, wallet, offset, programId) {
+    return connection?.getProgramAccounts(programId, {
+        filters: [
+            {
+                memcmp: {
+                    offset,
+                    bytes: wallet.toBase58(),
+                },
+            },
+        ],
+    });
+}
+/**
+ * Utility function to check if the transaction initiator is a Wallet object
+ * @param {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
+ * @return {boolean} - Returns true if parameter is a Wallet.
+ */
+export function isSignerWallet(walletOrKeypair) {
+    return walletOrKeypair.signTransaction !== undefined;
+}
+/**
+ * Utility function to check if the transaction initiator a Keypair object, tries to mitigate version mismatch issues
+ * @param walletOrKeypair {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
+ * @returns {boolean} - Returns true if parameter is a Keypair.
+ */
+export function isSignerKeypair(walletOrKeypair) {
+    return (walletOrKeypair instanceof Keypair ||
+        walletOrKeypair.constructor === Keypair ||
+        walletOrKeypair.constructor.name === Keypair.prototype.constructor.name);
+}
+/**
+ * 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 function isTransactionVersioned(tx) {
+    return "message" in tx;
+}
+/**
+ * Creates a Transaction with given instructions and optionally signs it.
+ * @param connection - Solana client connection
+ * @param ixs - Instructions to add to the Transaction
+ * @param payer - PublicKey of payer
+ * @param commitment - optional Commitment that will be used to fetch latest blockhash
+ * @param partialSigners - optional signers that will be used to partially sign a Transaction
+ * @returns Transaction and Blockhash
+ */
+export async function prepareTransaction(connection, ixs, payer, commitment, ...partialSigners) {
+    if (!payer) {
+        throw new Error("Payer public key is not provided!");
+    }
+    const { value: hash, context } = await connection.getLatestBlockhashAndContext(commitment);
+    const messageV0 = new TransactionMessage({
+        payerKey: payer,
+        recentBlockhash: hash.blockhash,
+        instructions: ixs,
+    }).compileToV0Message();
+    const tx = new VersionedTransaction(messageV0);
+    const signers = partialSigners.filter((item) => !!item);
+    tx.sign(signers);
+    return { tx, context, hash };
+}
+export async function signTransaction(invoker, tx) {
+    let signedTx;
+    if (isSignerWallet(invoker)) {
+        signedTx = await invoker.signTransaction(tx);
+    }
+    else {
+        if (isTransactionVersioned(tx)) {
+            tx.sign([invoker]);
+        }
+        else {
+            tx.partialSign(invoker);
+        }
+        signedTx = tx;
+    }
+    return signedTx;
+}
+/**
+ * Signs, sends and confirms Transaction
+ * @param connection - Solana client connection
+ * @param invoker - Keypair used as signer
+ * @param tx - Transaction instance
+ * @param confirmationParams - Confirmation Params that will be used for execution
+ * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
+ * @returns Transaction signature
+ */
+export async function signAndExecuteTransaction(connection, invoker, tx, confirmationParams, throttleParams) {
+    const signedTx = await signTransaction(invoker, tx);
+    return executeTransaction(connection, signedTx, confirmationParams, throttleParams);
+}
+/**
+ * Sends and confirms Transaction
+ * 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 confirmationParams - Confirmation Params that will be used for execution
+ * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
+ * @returns Transaction signature
+ */
+export async function executeTransaction(connection, tx, confirmationParams, throttleParams) {
+    if (tx.signatures.length === 0) {
+        throw Error("Error with transaction parameters.");
+    }
+    await simulateTransaction(connection, tx);
+    return sendAndConfirmTransaction(connection, tx, confirmationParams, throttleParams);
+}
+/**
+ * Launches a PromisePool with all transaction being executed at the same time, allows to throttle all TXs through one Queue
+ * @param connection - Solana client connection
+ * @param txs - Transactions
+ * @param confirmationParams - Confirmation Params that will be used for execution
+ * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
+ * @param throttleParams.sendRate - rate
+ * @param throttleParams.sendThrottler -  throttler instance
+ * @returns Raw Promise Results - should be handled by the consumer and unwrapped accordingly
+ */
+export async function executeMultipleTransactions(connection, txs, confirmationParams, { sendRate = 1, sendThrottler }) {
+    if (!sendThrottler) {
+        sendThrottler = buildSendThrottler(sendRate);
+    }
+    return Promise.allSettled(txs.map((tx) => executeTransaction(connection, tx, confirmationParams, { sendRate: sendRate, sendThrottler: sendThrottler })));
+}
+/**
+ * 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 confirmationParams - Confirmation Params that will be used for execution
+ * @param confirmationParams.hash - blockhash information, the same hash should be used in the Transaction
+ * @param confirmationParams.context - context at which blockhash has been retrieve
+ * @param confirmationParams.commitment - optional commitment that will be used for simulation and confirmation
+ * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
+ * @param throttleParams.sendRate - rate
+ * @param throttleParams.sendThrottler -  throttler instance
+ */
+export async function sendAndConfirmTransaction(connection, tx, { hash, context, commitment }, { sendRate = 1, sendThrottler }) {
+    const isVersioned = isTransactionVersioned(tx);
+    let signature;
+    if (isVersioned) {
+        signature = bs58.encode(tx.signatures[0]);
+    }
+    else {
+        signature = bs58.encode(tx.signature);
+    }
+    if (!sendThrottler) {
+        sendThrottler = buildSendThrottler(sendRate);
+    }
+    let blockheight = await connection.getBlockHeight(commitment);
+    let transactionSent = false;
+    const rawTransaction = tx.serialize();
+    while (blockheight < hash.lastValidBlockHeight + 15) {
+        try {
+            if (blockheight < hash.lastValidBlockHeight || !transactionSent) {
+                await sendThrottler.add(async () => connection.sendRawTransaction(rawTransaction, {
+                    maxRetries: 0,
+                    minContextSlot: context.slot,
+                    preflightCommitment: commitment,
+                    skipPreflight: true,
+                }));
+                transactionSent = true;
+            }
+        }
+        catch (e) {
+            if (transactionSent ||
+                (e instanceof SendTransactionError && e.message.includes("Minimum context slot has not been reached"))) {
+                await sleep(500);
+                continue;
+            }
+            throw e;
+        }
+        await sleep(500);
+        try {
+            const value = await confirmAndEnsureTransaction(connection, signature);
+            if (value) {
+                return signature;
+            }
+        }
+        catch (e) {
+            if (e instanceof TransactionFailedError) {
+                throw e;
+            }
+            await sleep(500);
+        }
+        try {
+            blockheight = await connection.getBlockHeight(commitment);
+        }
+        catch (_e) {
+            await sleep(500);
+        }
+    }
+    throw new Error(`Transaction ${signature} expired.`);
+}
+export async function simulateTransaction(connection, tx) {
+    let res;
+    for (let i = 0; i < SIMULATE_TRIES; i++) {
+        if (isTransactionVersioned(tx)) {
+            res = await connection.simulateTransaction(tx);
+        }
+        else {
+            res = await connection.simulateTransaction(tx);
+        }
+        if (res.value.err) {
+            const errMessage = JSON.stringify(res.value.err);
+            if (!errMessage.includes("BlockhashNotFound") || i === SIMULATE_TRIES - 1) {
+                throw new SendTransactionError("failed to simulate transaction: " + errMessage, res.value.logs || undefined);
+            }
+            continue;
+        }
+        return res;
+    }
+    throw new SendTransactionError("failed to simulate transaction");
+}
+/**
+ * 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 async function confirmAndEnsureTransaction(connection, signature, ignoreError) {
+    const response = await connection.getSignatureStatus(signature);
+    if (!response) {
+        return null;
+    }
+    const { value } = response;
+    if (!value) {
+        return null;
+    }
+    if (!ignoreError && value.err) {
+        // That's how solana-web3js does it, `err` here is an object that won't really be handled
+        throw new TransactionFailedError(`Raw transaction ${signature} failed (${JSON.stringify({ err: value.err })})`);
+    }
+    switch (connection.commitment) {
+        case "confirmed":
+        case "single":
+        case "singleGossip": {
+            if (value.confirmationStatus === "processed") {
+                return null;
+            }
+            break;
+        }
+        case "finalized":
+        case "max":
+        case "root": {
+            if (value.confirmationStatus === "processed" || value.confirmationStatus === "confirmed") {
+                return null;
+            }
+            break;
+        }
+        // exhaust enums to ensure full coverage
+        case "processed":
+        case "recent":
+    }
+    return value;
+}
+/**
+ * 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 function ata(mint, owner, programId) {
+    return getAssociatedTokenAddress(mint, owner, true, programId);
+}
+/**
+ * Function that checks whether ATA exists for each provided owner
+ * @param connection - Solana client connection
+ * @param paramsBatch - Array of Params for each ATA account: {mint, owner}
+ * @returns Array of boolean where each member corresponds to an owner
+ */
+export async function ataBatchExist(connection, paramsBatch) {
+    const tokenAccounts = await Promise.all(paramsBatch.map(async ({ mint, owner, programId }) => {
+        return ata(mint, owner, programId);
+    }));
+    const response = await connection.getMultipleAccountsInfo(tokenAccounts);
+    return response.map((accInfo) => !!accInfo);
+}
+export async function enrichAtaParams(connection, paramsBatch) {
+    const programIdByMint = {};
+    return Promise.all(paramsBatch.map(async (params) => {
+        if (params.programId) {
+            return params;
+        }
+        const mintStr = params.mint.toString();
+        if (!(mintStr in programIdByMint)) {
+            const { tokenProgramId } = await getMintAndProgram(connection, params.mint);
+            programIdByMint[mintStr] = tokenProgramId;
+        }
+        params.programId = programIdByMint[mintStr];
+        return params;
+    }));
+}
+/**
+ * Generates a Transaction to create ATA for an array of owners
+ * @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 async function generateCreateAtaBatchTx(connection, payer, paramsBatch, commitment) {
+    paramsBatch = await enrichAtaParams(connection, paramsBatch);
+    const ixs = await Promise.all(paramsBatch.map(async ({ mint, owner, programId }) => {
+        return createAssociatedTokenAccountInstruction(payer, await ata(mint, owner), owner, mint, programId);
+    }));
+    const { value: hash, context } = await connection.getLatestBlockhashAndContext({ commitment });
+    const messageV0 = new TransactionMessage({
+        payerKey: payer,
+        recentBlockhash: hash.blockhash,
+        instructions: ixs,
+    }).compileToV0Message();
+    const tx = new VersionedTransaction(messageV0);
+    return { tx, hash, 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
+ * @param rate - throttle rate for tx sending
+ * @returns Transaction signature
+ */
+export async function createAtaBatch(connection, invoker, paramsBatch, commitment, rate) {
+    const { tx, hash, context } = await generateCreateAtaBatchTx(connection, invoker.publicKey, await enrichAtaParams(connection, paramsBatch), commitment);
+    return signAndExecuteTransaction(connection, invoker, tx, { hash, context, commitment }, { sendRate: rate });
+}
+/**
+ * Utility function that checks whether associated token accounts exist and return instructions to populate them if not
+ * @param connection - Solana client connection
+ * @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 async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programId) {
+    const ixs = [];
+    if (!programId) {
+        programId = (await getMintAndProgram(connection, mint)).tokenProgramId;
+    }
+    // TODO: optimize fetching and maps/arrays
+    const atas = [];
+    for (const owner of owners) {
+        atas.push(await ata(mint, owner, programId));
+    }
+    const response = await connection.getMultipleAccountsInfo(atas);
+    for (let i = 0; i < response.length; i++) {
+        if (!response[i]) {
+            ixs.push(createAssociatedTokenAccountInstruction(invoker.publicKey, atas[i], owners[i], mint, programId));
+        }
+    }
+    return ixs;
+}
+/**
+ * Create Base instructions for Solana
+ * - sets compute price if `computePrice` is provided
+ * - sets compute limit if `computeLimit` is provided
+ */
+export function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
+    const ixs = [];
+    if (computePrice) {
+        ixs.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: computePrice }));
+    }
+    if (computeLimit) {
+        ixs.push(ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }));
+    }
+    return ixs;
+}
+/**
+ * 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 async function getMintAndProgram(connection, address, commitment) {
+    const accountInfo = await connection.getAccountInfo(address, commitment);
+    let programId = accountInfo?.owner;
+    if (!programId?.equals(TOKEN_PROGRAM_ID) && !programId?.equals(TOKEN_2022_PROGRAM_ID)) {
+        programId = TOKEN_PROGRAM_ID;
+    }
+    return {
+        mint: unpackMint(address, accountInfo, programId),
+        tokenProgramId: programId,
+    };
+}

package/dist/{types.d.ts → esm/types.d.ts}

@@ -1,7 +1,6 @@
 import { TransactionInstruction } from "@solana/web3.js";
-import { Types } from "aptos";
 export interface ITransactionResult {
-    ixs: (TransactionInstruction | Types.TransactionPayload)[];
+    ixs: TransactionInstruction[];
     txId: string;
 }
 export declare enum ICluster {

package/dist/esm/types.js

@@ -0,0 +1,38 @@
+// Utility types
+export var ICluster;
+(function (ICluster) {
+    ICluster["Mainnet"] = "mainnet";
+    ICluster["Devnet"] = "devnet";
+    ICluster["Testnet"] = "testnet";
+    ICluster["Local"] = "local";
+})(ICluster || (ICluster = {}));
+export var IChain;
+(function (IChain) {
+    IChain["Solana"] = "Solana";
+    IChain["Aptos"] = "Aptos";
+    IChain["Ethereum"] = "Ethereum";
+    IChain["BNB"] = "BNB";
+    IChain["Polygon"] = "Polygon";
+    IChain["Sui"] = "Sui";
+})(IChain || (IChain = {}));
+/**
+ * Error wrapper for calls made to the contract on chain
+ */
+export class ContractError extends Error {
+    contractErrorCode;
+    description;
+    /**
+     * Constructs the Error Wrapper
+     * @param error Original error raised probably by the chain SDK
+     * @param code extracted code from the error if managed to parse it
+     */
+    constructor(error, code, description) {
+        super(error.message); // Call the base class constructor with the error message
+        this.contractErrorCode = code ?? null;
+        this.description = description ?? null;
+        // Copy properties from the original error
+        Object.setPrototypeOf(this, ContractError.prototype);
+        this.name = "ContractError"; // Set the name property
+        this.stack = error.stack;
+    }
+}

package/dist/esm/utils.js

@@ -0,0 +1,50 @@
+import BN from "bn.js";
+import { ContractError } from "./types.js";
+/**
+ * Used for conversion of token amounts to their Big Number representation.
+ * Get Big Number representation in the smallest units from the same value in the highest units.
+ * @param {number} value - Number of tokens you want to convert to its BN representation.
+ * @param {number} decimals - Number of decimals the token has.
+ */
+export const getBN = (value, decimals) => {
+    const decimalPart = value - Math.trunc(value);
+    const integerPart = new BN(Math.trunc(value));
+    const decimalE = new BN(decimalPart * 1e9);
+    const sum = integerPart.mul(new BN(1e9)).add(decimalE);
+    const resultE = sum.mul(new BN(10).pow(new BN(decimals)));
+    return resultE.div(new BN(1e9));
+};
+/**
+ * Used for token amounts conversion from their Big Number representation to number.
+ * Get value in the highest units from BN representation of the same value in the smallest units.
+ * @param {BN} value - Big Number representation of value in the smallest units.
+ * @param {number} decimals - Number of decimals the token has.
+ */
+export const getNumberFromBN = (value, decimals) => value.gt(new BN(2 ** 53 - 1)) ? value.div(new BN(10 ** decimals)).toNumber() : value.toNumber() / 10 ** decimals;
+/**
+ * Used to make on chain calls to the contract and wrap raised errors if any
+ * @param func function that interacts with the contract
+ * @param callback callback that may be used to extract error code
+ * @returns {T}
+ */
+export async function handleContractError(func, callback) {
+    try {
+        return await func();
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            if (callback) {
+                throw new ContractError(err, callback(err));
+            }
+            throw new ContractError(err);
+        }
+        throw err;
+    }
+}
+/**
+ * Pause async function execution for given amount of milliseconds
+ * @param ms millisecond to sleep for
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -1,36 +1,37 @@
 {
   "name": "@streamflow/common",
-  "version": "6.3.8",
+  "version": "7.0.0-alpha.1",
   "description": "Common utilities and types used by streamflow packages.",
   "homepage": "https://github.com/streamflow-finance/js-sdk/",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "type": "module",
   "exports": {
-    ".": "./dist/index.js",
-    "./solana": "./dist/solana/index.js"
-  },
-  "typesVersions": {
-    "*": {
-      "solana": [
-        "dist/solana/index.d.ts"
-      ]
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/esm/index.d.ts"
+    },
+    "./solana": {
+      "import": "./dist/esm/solana/index.js",
+      "require": "./dist/cjs/solana/index.js",
+      "types": "./dist/esm/solana/index.d.ts"
     }
   },
   "scripts": {
-    "build": "rm -rf dist; tsc -p tsconfig.json",
+    "build:cjs": "rm -rf dist/cjs; tsc -p tsconfig.cjs.json",
+    "build:esm": "rm -rf dist/esm; tsc -p tsconfig.esm.json",
+    "build": "rm -rf dist; pnpm run build:cjs && pnpm run build:esm",
     "pack": "pnpm build && pnpm pack",
     "lint": "eslint --fix .",
     "lint-config": "eslint --print-config",
     "prepublishOnly": "npm run lint && npm run build"
   },
-  "gitHead": "9e892b3ff8a7eda63e3d3b91412c1ae5d3864c8e",
+  "gitHead": "8b2be143ac1bfeaca3bcecc11eb5fa1e81f2ffb7",
   "devDependencies": {
-    "@streamflow/eslint-config": "6.3.8",
+    "@streamflow/eslint-config": "7.0.0-alpha.1",
     "@types/bn.js": "5.1.1",
-    "@types/jest": "29.2.4",
     "date-fns": "2.28.0",
-    "jest": "29.3.1",
-    "ts-jest": "29.0.3",
     "typescript": "^4.9.5"
   },
   "dependencies": {
@@ -43,6 +44,6 @@
     "bn.js": "5.2.1",
     "borsh": "^2.0.0",
     "bs58": "5.0.0",
-    "p-queue": "^6.6.2"
+    "p-queue": "^8.0.1"
   }
 }

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./types";
-export * from "./utils";

package/dist/solana/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./instructions";
-export * from "./types";
-export * from "./utils";