@streamflow/common 6.5.0 → 7.0.0-alpha.10

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/cjs/solana/instructions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareWrappedAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const prepareWrappedAccount = async (connection, senderAddress, amount) => {
+    const tokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(spl_token_1.NATIVE_MINT, senderAddress, true);
+    const accInfo = await connection.getParsedAccountInfo(tokenAccount);
+    const instructions = (accInfo.value?.lamports ?? 0) > 0
+        ? []
+        : [(0, spl_token_1.createAssociatedTokenAccountInstruction)(senderAddress, tokenAccount, senderAddress, spl_token_1.NATIVE_MINT)];
+    return [
+        ...instructions,
+        web3_js_1.SystemProgram.transfer({
+            fromPubkey: senderAddress,
+            toPubkey: tokenAccount,
+            lamports: amount.toNumber(),
+        }),
+        (0, spl_token_1.createSyncNativeInstruction)(tokenAccount),
+    ];
+};
+exports.prepareWrappedAccount = prepareWrappedAccount;

package/dist/cjs/solana/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionFailedError = void 0;
+class TransactionFailedError extends Error {
+    constructor(m) {
+        super(m);
+        Object.setPrototypeOf(this, TransactionFailedError.prototype);
+        this.name = "TransactionFailedError";
+    }
+}
+exports.TransactionFailedError = TransactionFailedError;

package/dist/cjs/solana/utils.js

@@ -0,0 +1,443 @@
+"use strict";
+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.simulateTransaction = exports.sendAndConfirmTransaction = exports.executeMultipleTransactions = exports.executeTransaction = exports.signAndExecuteTransaction = exports.signTransaction = exports.prepareTransaction = exports.isTransactionVersioned = exports.isSignerKeypair = exports.isSignerWallet = exports.getProgramAccounts = exports.buildSendThrottler = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const types_js_1 = require("./types.js");
+const utils_js_1 = require("../utils.js");
+const SIMULATE_TRIES = 3;
+const buildSendThrottler = (sendRate) => {
+    return new p_queue_1.default({ concurrency: sendRate, intervalCap: 1, interval: 1000 });
+};
+exports.buildSendThrottler = buildSendThrottler;
+/**
+ * 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.
+ */
+async function getProgramAccounts(connection, wallet, offset, programId) {
+    const programAccounts = await connection?.getProgramAccounts(programId, {
+        filters: [
+            {
+                memcmp: {
+                    offset,
+                    bytes: wallet.toBase58(),
+                },
+            },
+        ],
+    });
+    return [...programAccounts];
+}
+exports.getProgramAccounts = getProgramAccounts;
+/**
+ * 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.
+ */
+function isSignerWallet(walletOrKeypair) {
+    return walletOrKeypair.signTransaction !== undefined;
+}
+exports.isSignerWallet = isSignerWallet;
+/**
+ * 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.
+ */
+function isSignerKeypair(walletOrKeypair) {
+    return (walletOrKeypair instanceof web3_js_1.Keypair ||
+        walletOrKeypair.constructor === web3_js_1.Keypair ||
+        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
+ * @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
+ */
+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 web3_js_1.TransactionMessage({
+        payerKey: payer,
+        recentBlockhash: hash.blockhash,
+        instructions: ixs,
+    }).compileToV0Message();
+    const tx = new web3_js_1.VersionedTransaction(messageV0);
+    const signers = partialSigners.filter((item) => !!item);
+    tx.sign(signers);
+    return { tx, context, hash };
+}
+exports.prepareTransaction = prepareTransaction;
+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;
+}
+exports.signTransaction = signTransaction;
+/**
+ * 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
+ */
+async function signAndExecuteTransaction(connection, invoker, tx, confirmationParams, throttleParams) {
+    const signedTx = await signTransaction(invoker, tx);
+    return executeTransaction(connection, signedTx, confirmationParams, throttleParams);
+}
+exports.signAndExecuteTransaction = signAndExecuteTransaction;
+/**
+ * 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
+ */
+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);
+}
+exports.executeTransaction = executeTransaction;
+/**
+ * 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
+ */
+async function executeMultipleTransactions(connection, txs, confirmationParams, { sendRate = 1, sendThrottler }) {
+    if (!sendThrottler) {
+        sendThrottler = (0, exports.buildSendThrottler)(sendRate);
+    }
+    return Promise.allSettled(txs.map((tx) => executeTransaction(connection, tx, confirmationParams, { sendRate: sendRate, sendThrottler: sendThrottler })));
+}
+exports.executeMultipleTransactions = executeMultipleTransactions;
+/**
+ * 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
+ */
+async function sendAndConfirmTransaction(connection, tx, { hash, context, commitment }, { sendRate = 1, sendThrottler }) {
+    const isVersioned = isTransactionVersioned(tx);
+    let signature;
+    if (isVersioned) {
+        signature = bs58_1.default.encode(tx.signatures[0]);
+    }
+    else {
+        signature = bs58_1.default.encode(tx.signature);
+    }
+    if (!sendThrottler) {
+        sendThrottler = (0, exports.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 web3_js_1.SendTransactionError && e.message.includes("Minimum context slot has not been reached"))) {
+                await (0, utils_js_1.sleep)(500);
+                continue;
+            }
+            throw e;
+        }
+        await (0, utils_js_1.sleep)(500);
+        try {
+            const value = await confirmAndEnsureTransaction(connection, signature);
+            if (value) {
+                return signature;
+            }
+        }
+        catch (e) {
+            if (e instanceof types_js_1.TransactionFailedError) {
+                throw e;
+            }
+            await (0, utils_js_1.sleep)(500);
+        }
+        try {
+            blockheight = await connection.getBlockHeight(commitment);
+        }
+        catch (_e) {
+            await (0, utils_js_1.sleep)(500);
+        }
+    }
+    throw new Error(`Transaction ${signature} expired.`);
+}
+exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
+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 web3_js_1.SendTransactionError("failed to simulate transaction: " + errMessage, res.value.logs || undefined);
+            }
+            continue;
+        }
+        return res;
+    }
+    throw new web3_js_1.SendTransactionError("failed to simulate transaction");
+}
+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
+ */
+async function confirmAndEnsureTransaction(connection, signature, ignoreError) {
+    const response = await connection.getSignatureStatuses([signature]);
+    if (!response || response.value.length === 0 || response.value[0] === null) {
+        return null;
+    }
+    const value = response.value[0];
+    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 types_js_1.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;
+}
+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, 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 each ATA account: {mint, owner}
+ * @returns Array of boolean where each member corresponds to an owner
+ */
+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);
+}
+exports.ataBatchExist = ataBatchExist;
+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;
+    }));
+}
+exports.enrichAtaParams = enrichAtaParams;
+/**
+ * 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
+ */
+async function generateCreateAtaBatchTx(connection, payer, paramsBatch, commitment) {
+    paramsBatch = await enrichAtaParams(connection, paramsBatch);
+    const ixs = await Promise.all(paramsBatch.map(async ({ mint, owner, programId }) => {
+        return (0, spl_token_1.createAssociatedTokenAccountInstruction)(payer, await ata(mint, owner), owner, mint, programId);
+    }));
+    const { value: hash, context } = await connection.getLatestBlockhashAndContext({ commitment });
+    const messageV0 = new web3_js_1.TransactionMessage({
+        payerKey: payer,
+        recentBlockhash: hash.blockhash,
+        instructions: ixs,
+    }).compileToV0Message();
+    const tx = new web3_js_1.VersionedTransaction(messageV0);
+    return { tx, hash, context };
+}
+exports.generateCreateAtaBatchTx = generateCreateAtaBatchTx;
+/**
+ * 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
+ */
+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 });
+}
+exports.createAtaBatch = createAtaBatch;
+/**
+ * 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
+ */
+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((0, spl_token_1.createAssociatedTokenAccountInstruction)(invoker.publicKey, atas[i], owners[i], mint, programId));
+        }
+    }
+    return ixs;
+}
+exports.checkOrCreateAtaBatch = checkOrCreateAtaBatch;
+/**
+ * Create Base instructions for Solana
+ * - sets compute price if `computePrice` is provided
+ * - sets compute limit if `computeLimit` is provided
+ */
+function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
+    const ixs = [];
+    if (computePrice) {
+        ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: computePrice }));
+    }
+    if (computeLimit) {
+        ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }));
+    }
+    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
+ */
+async function getMintAndProgram(connection, address, commitment) {
+    const accountInfo = await connection.getAccountInfo(address, commitment);
+    let programId = accountInfo?.owner;
+    if (!programId?.equals(spl_token_1.TOKEN_PROGRAM_ID) && !programId?.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+        programId = spl_token_1.TOKEN_PROGRAM_ID;
+    }
+    return {
+        mint: (0, spl_token_1.unpackMint)(address, accountInfo, programId),
+        tokenProgramId: programId,
+    };
+}
+exports.getMintAndProgram = getMintAndProgram;

package/dist/cjs/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractError = exports.IChain = exports.ICluster = void 0;
+// Utility types
+var ICluster;
+(function (ICluster) {
+    ICluster["Mainnet"] = "mainnet";
+    ICluster["Devnet"] = "devnet";
+    ICluster["Testnet"] = "testnet";
+    ICluster["Local"] = "local";
+})(ICluster = exports.ICluster || (exports.ICluster = {}));
+var IChain;
+(function (IChain) {
+    IChain["Solana"] = "Solana";
+    IChain["Aptos"] = "Aptos";
+    IChain["Ethereum"] = "Ethereum";
+    IChain["BNB"] = "BNB";
+    IChain["Polygon"] = "Polygon";
+    IChain["Sui"] = "Sui";
+})(IChain = exports.IChain || (exports.IChain = {}));
+/**
+ * Error wrapper for calls made to the contract on chain
+ */
+class ContractError extends Error {
+    /**
+     * 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;
+    }
+}
+exports.ContractError = ContractError;

package/dist/cjs/utils.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.handleContractError = exports.getScaledBigNumber = exports.getNumberFromBigNumber = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const types_js_1 = require("./types.js");
+/**
+ * Used for token amounts conversion from their Big Number representation to number.
+ * Get value in the highest units from BigNumber representation of the same value in the smallest units.
+ * @param {BigNumber} value - Big Number representation of value in the smallest units.
+ * @param {number} decimals - Number of decimals the token has.
+ */
+const getNumberFromBigNumber = (bigNum, decimals) => {
+    return bigNum.div((0, bignumber_js_1.default)(10).pow(decimals)).toNumber();
+};
+exports.getNumberFromBigNumber = getNumberFromBigNumber;
+/**
+ * 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 BigNumber representation.
+ * @param {number} decimals - Number of decimals the token has.
+ */
+const getScaledBigNumber = (value, decimals) => {
+    return new bignumber_js_1.default(value).times(new bignumber_js_1.default(10).pow(decimals));
+};
+exports.getScaledBigNumber = getScaledBigNumber;
+/**
+ * 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}
+ */
+async function handleContractError(func, callback) {
+    try {
+        return await func();
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            if (callback) {
+                throw new types_js_1.ContractError(err, callback(err));
+            }
+            throw new types_js_1.ContractError(err);
+        }
+        throw err;
+    }
+}
+exports.handleContractError = handleContractError;
+/**
+ * Pause async function execution for given amount of milliseconds
+ * @param ms millisecond to sleep for
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;

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/{solana → esm/solana}/instructions.d.ts

@@ -1,3 +1,3 @@
 import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import BN from "bn.js";
-export declare const prepareWrappedAccount: (connection: Connection, senderAddress: PublicKey, amount: BN) => Promise<TransactionInstruction[]>;
+import BigNumber from "bignumber.js";
+export declare const prepareWrappedAccount: (connection: Connection, senderAddress: PublicKey, amount: BigNumber) => Promise<TransactionInstruction[]>;

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