@streamflow/common 7.5.3 → 8.0.0-alpha.p287.5172056

package/dist/cjs/solana/rpc/index.d.cts

@@ -0,0 +1,89 @@
+import * as _solana_web3_js from '@solana/web3.js';
+import { PublicKey, Connection } from '@solana/web3.js';
+
+/**
+ * @interface GetPriorityFeeEstimateOptions - The options for the priority fee estimate
+ */
+interface GetPriorityFeeEstimateOptions {
+    /**
+     * The accounts or transaction to get the priority fee estimate for.
+     * `string` is a serialized base64 transaction.
+     * `array` is interpreted as an array of public keys in string format or as PublicKey instances (writable accounts).
+     */
+    accountsOrTx: (string | PublicKey)[] | string;
+    /**
+     * The percentile of the priority fee estimate to return.
+     *
+     * examples: Triton RPC - [0, 10000]
+     * @default 5000
+     */
+    percentile?: number;
+    /**
+     * The safe area increase to apply to the priority fee estimate.
+     * @default 0.05 = 5%
+     */
+    safeAreaIncrease?: number;
+}
+
+/**
+ * @category GetPriorityFeeEstimateOptions
+ * @interface RecentPrioritizationFee
+ * @property result - The result of the recent prioritization fees.
+ * @property result.prioritizationFee - The prioritization fee.
+ * @property result.slot - The slot of the prioritization fee.
+ */
+interface RecentPrioritizationFee {
+    result: Array<{
+        prioritizationFee: number;
+        slot: number;
+    }>;
+}
+/**
+ * Fetch the recent prioritization fees from the RPC [getRecentPrioritizationFees]
+ * @param connection - The connection to the RPC
+ * @param options - The options for the RPC
+ * @returns The priority fee estimate
+ */
+declare const getPriorityFeeEstimate$1: (connection: Connection, options: GetPriorityFeeEstimateOptions) => Promise<{
+    median: number;
+    data: RecentPrioritizationFee;
+}>;
+/**
+ * If an RPC of use supports percentile value, aka {@link https://docs.triton.one/chains/solana/improved-priority-fees-api}
+ * @param connection - The connection to the RPC
+ * @param options - The options for the RPC
+ * @returns The priority fee estimate
+ */
+declare const getRecentPrioritizationFee$1: (connection: Connection, options: Pick<GetPriorityFeeEstimateOptions, "accountsOrTx" | "percentile">) => Promise<RecentPrioritizationFee>;
+
+declare namespace percentile {
+  export { getPriorityFeeEstimate$1 as getPriorityFeeEstimate, getRecentPrioritizationFee$1 as getRecentPrioritizationFee };
+}
+
+/**
+ * Fetch the recent prioritization fees from the RPC [getRecentPrioritizationFees] (https://solana.com/docs/rpc/http/getrecentprioritizationfees)
+ * @deprecated Not recommended for use because it provides a single number per slot to indicate the minimum priority fee amount.
+ * @param connection - The connection to the RPC
+ * @param options - The options for the RPC
+ * @returns The priority fee estimate
+ */
+declare const getPriorityFeeEstimate: (connection: Connection, options: GetPriorityFeeEstimateOptions) => Promise<{
+    median: number;
+    data: _solana_web3_js.RecentPrioritizationFees[];
+}>;
+/**
+ * Fetch the recent prioritization fees from the RPC [getRecentPrioritizationFees] (https://solana.com/docs/rpc/http/getrecentprioritizationfees)
+ * @deprecated Not recommended for use because it provides a single number per slot to indicate the minimum priority fee amount.
+ * @param connection - The connection to the RPC
+ * @param options - The options for the RPC
+ * @returns The priority fee estimate
+ */
+declare const getRecentPrioritizationFee: (connection: Connection, options: Pick<GetPriorityFeeEstimateOptions, "accountsOrTx">) => Promise<_solana_web3_js.RecentPrioritizationFees[]>;
+
+declare const general_getPriorityFeeEstimate: typeof getPriorityFeeEstimate;
+declare const general_getRecentPrioritizationFee: typeof getRecentPrioritizationFee;
+declare namespace general {
+  export { general_getPriorityFeeEstimate as getPriorityFeeEstimate, general_getRecentPrioritizationFee as getRecentPrioritizationFee };
+}
+
+export { type GetPriorityFeeEstimateOptions, general as priorityFeeEstimation, percentile as priorityFeeEstimationPercentile };

package/dist/esm/index.d.ts

@@ -1,3 +1,66 @@
-export * from "./types.js";
-export * from "./lib/assertions.js";
-export * from "./lib/utils.js";
+import { TransactionInstruction } from '@solana/web3.js';
+import BN from 'bn.js';
+
+interface ITransactionResult {
+    ixs: TransactionInstruction[];
+    txId: string;
+}
+declare enum ICluster {
+    Mainnet = "mainnet",
+    Devnet = "devnet",
+    Testnet = "testnet",
+    Local = "local"
+}
+declare enum IChain {
+    Solana = "Solana",
+    Aptos = "Aptos",
+    Ethereum = "Ethereum",
+    BNB = "BNB",
+    Polygon = "Polygon",
+    Sui = "Sui"
+}
+/**
+ * Error wrapper for calls made to the contract on chain
+ */
+declare class ContractError extends Error {
+    contractErrorCode: string | null;
+    description: string | null;
+    /**
+     * 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: Error, code?: string | null, description?: string | null);
+}
+
+declare const invariant: (condition: any, message?: string | (() => string)) => asserts condition;
+
+/**
+ * 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.
+ */
+declare const getBN: (value: number, decimals: number) => BN;
+/**
+ * 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.
+ */
+declare const getNumberFromBN: (value: BN, decimals: number) => number;
+/**
+ * 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}
+ */
+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
+ */
+declare function sleep(ms: number): Promise<void>;
+declare const divCeilN: (n: bigint, d: bigint) => bigint;
+
+export { ContractError, IChain, ICluster, type ITransactionResult, divCeilN, getBN, getNumberFromBN, handleContractError, invariant, sleep };

package/dist/esm/index.js

@@ -1,3 +1,76 @@
-export * from "./types.js";
-export * from "./lib/assertions.js";
-export * from "./lib/utils.js";
+import '@solana/web3.js';
+import BN from 'bn.js';
+
+// types.ts
+var ICluster = /* @__PURE__ */ ((ICluster2) => {
+  ICluster2["Mainnet"] = "mainnet";
+  ICluster2["Devnet"] = "devnet";
+  ICluster2["Testnet"] = "testnet";
+  ICluster2["Local"] = "local";
+  return ICluster2;
+})(ICluster || {});
+var IChain = /* @__PURE__ */ ((IChain2) => {
+  IChain2["Solana"] = "Solana";
+  IChain2["Aptos"] = "Aptos";
+  IChain2["Ethereum"] = "Ethereum";
+  IChain2["BNB"] = "BNB";
+  IChain2["Polygon"] = "Polygon";
+  IChain2["Sui"] = "Sui";
+  return IChain2;
+})(IChain || {});
+var ContractError = 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, { cause: error });
+    this.contractErrorCode = code ?? null;
+    this.description = description ?? null;
+    Object.setPrototypeOf(this, _ContractError.prototype);
+    this.name = "ContractError";
+    this.stack = error.stack;
+  }
+};
+
+// lib/assertions.ts
+var prefix = "Assertion failed";
+var invariant = (condition, message) => {
+  if (condition) {
+    return;
+  }
+  const provided = typeof message === "function" ? message() : message;
+  const value = provided ? `${prefix}: ${provided}` : prefix;
+  throw new Error(value);
+};
+var 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));
+};
+var getNumberFromBN = (value, decimals) => value.gt(new BN(2 ** 53 - 1)) ? value.div(new BN(10 ** decimals)).toNumber() : value.toNumber() / 10 ** decimals;
+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;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var divCeilN = (n, d) => n / d + (n % d ? BigInt(1) : BigInt(0));
+
+export { ContractError, IChain, ICluster, divCeilN, getBN, getNumberFromBN, handleContractError, invariant, sleep };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../types.ts","../../lib/assertions.ts","../../lib/utils.ts"],"names":["ICluster","IChain"],"mappings":"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","file":"index.js","sourcesContent":["import { type TransactionInstruction } from \"@solana/web3.js\";\n\nexport interface ITransactionResult {\n  ixs: TransactionInstruction[];\n  txId: string;\n}\n\n// Utility types\nexport enum ICluster {\n  Mainnet = \"mainnet\",\n  Devnet = \"devnet\",\n  Testnet = \"testnet\",\n  Local = \"local\",\n}\n\nexport enum IChain {\n  Solana = \"Solana\",\n  Aptos = \"Aptos\",\n  Ethereum = \"Ethereum\",\n  BNB = \"BNB\",\n  Polygon = \"Polygon\",\n  Sui = \"Sui\",\n}\n\n/**\n * Error wrapper for calls made to the contract on chain\n */\nexport class ContractError extends Error {\n  public contractErrorCode: string | null;\n\n  public description: string | null;\n\n  /**\n   * Constructs the Error Wrapper\n   * @param error Original error raised probably by the chain SDK\n   * @param code extracted code from the error if managed to parse it\n   */\n  constructor(error: Error, code?: string | null, description?: string | null) {\n    super(error.message, { cause: error }); // Call the base class constructor with the error message\n    this.contractErrorCode = code ?? null;\n    this.description = description ?? null;\n    // Copy properties from the original error\n    Object.setPrototypeOf(this, ContractError.prototype);\n    this.name = \"ContractError\"; // Set the name property\n    this.stack = error.stack;\n  }\n}\n","const prefix = \"Assertion failed\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const invariant: (condition: any, message?: string | (() => string)) => asserts condition = (\n  condition,\n  message,\n) => {\n  if (condition) {\n    return;\n  }\n  const provided: string | undefined = typeof message === \"function\" ? message() : message;\n  const value: string = provided ? `${prefix}: ${provided}` : prefix;\n  throw new Error(value);\n};\n","import BN from \"bn.js\";\n\nimport { ContractError } from \"../types.js\";\n\n/**\n * Used for conversion of token amounts to their Big Number representation.\n * Get Big Number representation in the smallest units from the same value in the highest units.\n * @param {number} value - Number of tokens you want to convert to its BN representation.\n * @param {number} decimals - Number of decimals the token has.\n */\nexport const getBN = (value: number, decimals: number): BN => {\n  const decimalPart = value - Math.trunc(value);\n  const integerPart = new BN(Math.trunc(value));\n\n  const decimalE = new BN(decimalPart * 1e9);\n\n  const sum = integerPart.mul(new BN(1e9)).add(decimalE);\n  const resultE = sum.mul(new BN(10).pow(new BN(decimals)));\n  return resultE.div(new BN(1e9));\n};\n\n/**\n * Used for token amounts conversion from their Big Number representation to number.\n * Get value in the highest units from BN representation of the same value in the smallest units.\n * @param {BN} value - Big Number representation of value in the smallest units.\n * @param {number} decimals - Number of decimals the token has.\n */\nexport const getNumberFromBN = (value: BN, decimals: number): number =>\n  value.gt(new BN(2 ** 53 - 1)) ? value.div(new BN(10 ** decimals)).toNumber() : value.toNumber() / 10 ** decimals;\n\n/**\n * Used to make on chain calls to the contract and wrap raised errors if any\n * @param func function that interacts with the contract\n * @param callback callback that may be used to extract error code\n * @returns {T}\n */\nexport async function handleContractError<T>(\n  func: () => Promise<T>,\n  callback?: (err: Error) => string | null,\n): Promise<T> {\n  try {\n    return await func();\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  } catch (err: any) {\n    if (err instanceof Error) {\n      if (callback) {\n        throw new ContractError(err, callback(err));\n      }\n      throw new ContractError(err);\n    }\n    throw err;\n  }\n}\n\n/**\n * Pause async function execution for given amount of milliseconds\n * @param ms millisecond to sleep for\n */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nexport const divCeilN = (n: bigint, d: bigint): bigint => n / d + (n % d ? BigInt(1) : BigInt(0));\n"]}

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

@@ -1,5 +1,262 @@
-export * from "./account-filters.js";
-export * from "./instructions.js";
-export * from "./public-key.js";
-export * from "./types.js";
-export * from "./utils.js";
+import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment, Keypair, Transaction, VersionedTransaction, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus } from '@solana/web3.js';
+import BN from 'bn.js';
+import PQueue from 'p-queue';
+import { Mint } from '@solana/spl-token';
+import { SignerWalletAdapter } from '@solana/wallet-adapter-base';
+
+declare const getFilters: <T extends Record<string, number | PublicKey>>(criteria: T, byteOffsets: Record<keyof T, number>) => MemcmpFilter[];
+
+declare const prepareWrappedAccount: (connection: Connection, senderAddress: PublicKey, amount: BN) => Promise<TransactionInstruction[]>;
+
+/**
+ * Converts a string or PublicKey to a PublicKey object.
+ * @param address - The input address as a string or PublicKey.
+ * @returns The PublicKey object.
+ */
+declare const pk: (address: string | PublicKey) => PublicKey;
+
+type ComputePriceEstimate = (tx: string | (string | PublicKey)[]) => Promise<number>;
+interface ITransactionSolanaExt {
+    computePrice?: number | ComputePriceEstimate;
+    computeLimit?: number;
+}
+interface IInteractSolanaExt extends ITransactionSolanaExt {
+    invoker: {
+        publicKey: string | PublicKey | null;
+    };
+}
+interface Account {
+    pubkey: PublicKey;
+    account: AccountInfo<Buffer>;
+}
+interface CheckAssociatedTokenAccountsData {
+    sender: PublicKey;
+    recipient: PublicKey;
+    partner: PublicKey;
+    streamflowTreasury: PublicKey;
+    mint: PublicKey;
+}
+interface AtaParams {
+    mint: PublicKey;
+    owner: PublicKey;
+    programId?: PublicKey;
+}
+interface ConfirmationParams {
+    hash: BlockhashWithExpiryBlockHeight;
+    context: Context;
+    commitment?: Commitment;
+}
+interface ThrottleParams {
+    sendRate?: number;
+    sendThrottler?: PQueue;
+    waitBeforeConfirming?: number | undefined;
+}
+interface IProgramAccount<T> {
+    publicKey: PublicKey;
+    account: T;
+}
+declare class TransactionFailedError extends Error {
+    constructor(m: string);
+}
+
+declare const buildSendThrottler: (sendRate: number, sendInterval?: number) => PQueue;
+/**
+ * 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.
+ */
+declare function getProgramAccounts(connection: Connection, wallet: PublicKey, offset: number, programId: PublicKey): Promise<Account[]>;
+/**
+ * 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.
+ */
+declare function isSignerWallet(walletOrKeypair: Keypair | SignerWalletAdapter): walletOrKeypair is SignerWalletAdapter;
+/**
+ * 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.
+ */
+declare function isSignerKeypair(walletOrKeypair: Keypair | SignerWalletAdapter): walletOrKeypair is Keypair;
+/**
+ * Utility function to check whether given transaction is Versioned
+ * @param tx {Transaction | VersionedTransaction} - Transaction to check
+ * @returns {boolean} - Returns true if transaction is Versioned.
+ */
+declare function isTransactionVersioned(tx: Transaction | VersionedTransaction): tx is VersionedTransaction;
+/**
+ * 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
+ */
+declare function prepareTransaction(connection: Connection, ixs: TransactionInstruction[], payer: PublicKey | undefined | null, commitment?: Commitment, partialSigners?: (Keypair | undefined)[]): Promise<{
+    tx: VersionedTransaction;
+    hash: BlockhashWithExpiryBlockHeight;
+    context: Context;
+}>;
+declare function createVersionedTransaction(ixs: TransactionInstruction[], payer: PublicKey | undefined | null, recentBlockhash: BlockhashWithExpiryBlockHeight["blockhash"], partialSigners?: (Keypair | undefined)[]): VersionedTransaction;
+declare function signTransaction<T extends Transaction | VersionedTransaction>(invoker: Keypair | SignerWalletAdapter, tx: T): Promise<T>;
+/**
+ * Signs, sends and confirms Transaction
+ * @param connection - Solana client connection
+ * @param invoker - Keypair used as signer
+ * @param tx - Transaction instance
+ * @param 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
+ */
+declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, throttleParams: ThrottleParams): Promise<string>;
+/**
+ * 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
+ */
+declare function executeTransaction(connection: Connection, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, throttleParams: ThrottleParams): Promise<string>;
+/**
+ * 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
+ */
+declare function executeMultipleTransactions(connection: Connection, txs: (Transaction | VersionedTransaction)[], confirmationParams: ConfirmationParams, { sendRate, sendThrottler, ...throttlingParams }: ThrottleParams): Promise<PromiseSettledResult<string>[]>;
+/**
+ * Sends and confirm transaction in a loop, constantly re-broadcsting the tx until Blockheight expires.
+ * - we add additional 30 bocks to account for validators in an PRC pool divergence
+ * @param connection - Solana client connection
+ * @param tx - Transaction instance
+ * @param 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
+ */
+declare function sendAndConfirmTransaction(connection: Connection, tx: Transaction | VersionedTransaction, { hash, context, commitment }: ConfirmationParams, { sendRate, sendThrottler, waitBeforeConfirming }: ThrottleParams): Promise<string>;
+declare function simulateTransaction(connection: Connection, tx: Transaction | VersionedTransaction): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
+/**
+ * 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
+ */
+declare function confirmAndEnsureTransaction(connection: Connection, signature: string, ignoreError?: boolean): Promise<SignatureStatus | null>;
+/**
+ * Shorthand call signature for getAssociatedTokenAddress, with allowance for address to be offCurve
+ * @param {PublicKey} mint - SPL token Mint address.
+ * @param {PublicKey} owner - Owner of the Associated Token Address
+ * @param {PublicKey} programId - Program ID of the mint
+ * @return {Promise<PublicKey>} - Associated Token Address
+ */
+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 each ATA account: {mint, owner}
+ * @returns Array of boolean where each member corresponds to an owner
+ */
+declare function ataBatchExist(connection: Connection, paramsBatch: AtaParams[]): Promise<boolean[]>;
+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
+ * @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
+ */
+declare function generateCreateAtaBatchTx(connection: Connection, payer: PublicKey, paramsBatch: AtaParams[], commitment?: Commitment): Promise<{
+    tx: VersionedTransaction;
+    hash: BlockhashWithExpiryBlockHeight;
+    context: Context;
+}>;
+/**
+ * Creates ATA for an array of owners
+ * @param connection - Solana client connection
+ * @param invoker - Transaction invoker and payer
+ * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @param commitment - optional commitment that will be used to fetch Blockhash
+ * @param rate - throttle rate for tx sending
+ * @returns Transaction signature
+ */
+declare function createAtaBatch(connection: Connection, invoker: Keypair | SignerWalletAdapter, paramsBatch: AtaParams[], commitment?: Commitment, rate?: number): Promise<string>;
+/**
+ * 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
+ */
+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. If `computePrice` is a function, it will be ignored (the value must be resolved before calling this function).
+ * - sets compute limit if `computeLimit` is provided
+ */
+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
+ */
+declare function getMintAndProgram(connection: Connection, address: PublicKey, commitment?: Commitment): Promise<{
+    mint: Mint;
+    tokenProgramId: PublicKey;
+}>;
+/**
+ * Split fetching of Multiple Accounts Info into batches of 100
+ * as the maximum number of accounts that can be fetched in a single call is 100
+ *
+ * @param connection Connection to use
+ * @param pubKeys Array of public keys to fetch account info for
+ * @param commitment Desired level of commitment for querying the state
+ *
+ * @return Array of AccountInfo objects
+ */
+declare function getMultipleAccountsInfoBatched(connection: Connection, pubKeys: PublicKey[], commitment?: Commitment): Promise<(AccountInfo<Buffer> | null)[]>;
+
+declare function estimateComputeUnitPrice(estimate: ComputePriceEstimate, ixs: Parameters<typeof createVersionedTransaction>[0], payer: Parameters<typeof createVersionedTransaction>[1], recentBlockhash?: Parameters<typeof createVersionedTransaction>[2], partialSigners?: Parameters<typeof createVersionedTransaction>[3]): Promise<number>;
+declare function createAndEstimateTransaction<CreateFn extends (extParams: IInteractSolanaExt) => Promise<TransactionInstruction[]>>(createFn: CreateFn, extParams: IInteractSolanaExt): Promise<Awaited<ReturnType<CreateFn>>>;
+declare function createAndEstimateTransaction<CreateFn extends (extParams: IInteractSolanaExt) => Promise<any>>(createFn: CreateFn, extParams: IInteractSolanaExt, select: (result: Awaited<ReturnType<CreateFn>>) => TransactionInstruction[]): Promise<Awaited<ReturnType<CreateFn>>>;
+
+declare function deserializeRawTransaction(serializedTx: string): {
+    type: string;
+    transaction: Transaction;
+    accounts: PublicKey[];
+    writableAccounts: PublicKey[];
+} | {
+    type: string;
+    transaction: VersionedTransaction;
+    accounts: PublicKey[];
+    writableAccounts: PublicKey[];
+};
+
+export { type Account, type AtaParams, type CheckAssociatedTokenAccountsData, type ComputePriceEstimate, type ConfirmationParams, type IInteractSolanaExt, type IProgramAccount, type ITransactionSolanaExt, type ThrottleParams, TransactionFailedError, ata, ataBatchExist, buildSendThrottler, checkOrCreateAtaBatch, confirmAndEnsureTransaction, createAndEstimateTransaction, createAtaBatch, createVersionedTransaction, deserializeRawTransaction, enrichAtaParams, estimateComputeUnitPrice, executeMultipleTransactions, executeTransaction, generateCreateAtaBatchTx, getFilters, getMintAndProgram, getMultipleAccountsInfoBatched, getProgramAccounts, isSignerKeypair, isSignerWallet, isTransactionVersioned, pk, prepareBaseInstructions, prepareTransaction, prepareWrappedAccount, sendAndConfirmTransaction, signAndExecuteTransaction, signTransaction, simulateTransaction };