@streamflow/common 6.5.0 → 7.0.0-alpha.10

package/dist/esm/solana/utils.js

@@ -0,0 +1,416 @@
+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) {
+    const programAccounts = await connection?.getProgramAccounts(programId, {
+        filters: [
+            {
+                memcmp: {
+                    offset,
+                    bytes: wallet.toBase58(),
+                },
+            },
+        ],
+    });
+    return [...programAccounts];
+}
+/**
+ * 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.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 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/{utils.d.ts → esm/utils.d.ts}

@@ -1,18 +1,18 @@
-import BN from "bn.js";
+import BigNumber from "bignumber.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.
+ * 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.
  */
-export declare const getBN: (value: number, decimals: number) => BN;
+export declare const getNumberFromBigNumber: (bigNum: BigNumber, decimals: number) => number;
 /**
- * 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.
+ * 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.
  */
-export declare const getNumberFromBN: (value: BN, decimals: number) => number;
+export declare const getScaledBigNumber: (value: number | string | BigNumber, decimals: number) => BigNumber;
 /**
  * Used to make on chain calls to the contract and wrap raised errors if any
  * @param func function that interacts with the contract

package/dist/esm/utils.js

@@ -0,0 +1,47 @@
+import BigNumber from "bignumber.js";
+import { ContractError } from "./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.
+ */
+export const getNumberFromBigNumber = (bigNum, decimals) => {
+    return bigNum.div(BigNumber(10).pow(decimals)).toNumber();
+};
+/**
+ * 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.
+ */
+export const getScaledBigNumber = (value, decimals) => {
+    return new BigNumber(value).times(new BigNumber(10).pow(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,36 @@
 {
   "name": "@streamflow/common",
-  "version": "6.5.0",
+  "version": "7.0.0-alpha.10",
   "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": "799b73f95e7914ee0462e9cbb9da5e370278bd78",
+  "gitHead": "263638b9fd29395dcb64c33dfc2197df47f526af",
   "devDependencies": {
-    "@streamflow/eslint-config": "6.5.0",
-    "@types/bn.js": "5.1.1",
-    "@types/jest": "29.2.4",
+    "@streamflow/eslint-config": "7.0.0-alpha.10",
     "date-fns": "2.28.0",
-    "jest": "29.3.1",
-    "ts-jest": "29.0.3",
     "typescript": "^4.9.5"
   },
   "dependencies": {
@@ -40,9 +40,9 @@
     "@solana/wallet-adapter-base": "0.9.19",
     "@solana/web3.js": "1.90.2",
     "aptos": "1.21.0",
-    "bn.js": "5.2.1",
+    "bignumber.js": "^9.1.2",
     "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";