@streamflow/common 8.0.0-alpha.p284.726ba98 → 8.0.0-alpha.p287.84ff30f

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

@@ -0,0 +1,117 @@
+'use strict';
+
+var web3_js = require('@solana/web3.js');
+var buffer = require('buffer');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// solana/rpc/priority-fee-estimate/percentile.ts
+var percentile_exports = {};
+__export(percentile_exports, {
+  getPriorityFeeEstimate: () => getPriorityFeeEstimate,
+  getRecentPrioritizationFee: () => getRecentPrioritizationFee
+});
+function deserializeRawTransaction(serializedTx) {
+  const txBuffer = buffer.Buffer.from(serializedTx, "base64");
+  try {
+    const tx = web3_js.Transaction.from(txBuffer);
+    const message = tx.compileMessage();
+    const accounts = message.accountKeys;
+    const writableAccounts = accounts.filter((_, idx) => message.isAccountWritable(idx));
+    return {
+      type: "legacy",
+      transaction: tx,
+      accounts,
+      writableAccounts
+    };
+  } catch (error) {
+    try {
+      const vtx = web3_js.VersionedTransaction.deserialize(txBuffer);
+      const message = vtx.message;
+      const accounts = "staticAccountKeys" in message ? message.staticAccountKeys : message.accountKeys;
+      const writableAccounts = accounts.filter((_, idx) => message.isAccountWritable(idx));
+      return {
+        type: "versioned",
+        transaction: vtx,
+        accounts,
+        writableAccounts
+      };
+    } catch (vError) {
+      throw new Error("Failed to deserialize transaction: " + (vError instanceof Error ? vError.message : vError), {
+        cause: vError
+      });
+    }
+  }
+}
+
+// solana/rpc/priority-fee-estimate/calc-fee.ts
+var resolveMedian = (values) => {
+  if (values.length < 2) {
+    return 0;
+  }
+  const sortedRates = [...values].sort((a, b) => a - b);
+  const medianIndex = Math.floor(sortedRates.length / 2);
+  const medianArrValue = sortedRates[medianIndex];
+  const medianPrevValue = sortedRates[medianIndex - 1];
+  if (medianPrevValue === void 0 || medianArrValue === void 0) {
+    return 0;
+  }
+  const medianValue = sortedRates.length % 2 === 0 ? (medianPrevValue + medianArrValue) / 2 : medianArrValue;
+  return medianValue;
+};
+
+// solana/rpc/priority-fee-estimate/percentile.ts
+var getPriorityFeeEstimate = async (connection, options) => {
+  const recentPrioritizationFee = await getRecentPrioritizationFee(connection, options);
+  const median = resolveMedian(recentPrioritizationFee.result.map((r) => r.prioritizationFee));
+  return { median: median * (1 + (options.safeAreaIncrease ?? 0.05)), data: recentPrioritizationFee };
+};
+var getRecentPrioritizationFee = async (connection, options) => {
+  const { accountsOrTx, percentile = 5e3 } = options;
+  return connection._rpcRequest(
+    "getRecentPrioritizationFees",
+    buildArgs(accountsOrTx, percentile)
+  );
+};
+var buildArgs = (accountsOrTx, percentile) => {
+  const accountsArray = accountsOrTx instanceof Array ? accountsOrTx.map((a) => a.toString()) : deserializeRawTransaction(accountsOrTx).writableAccounts.map((a) => a.toString());
+  return [
+    accountsArray,
+    {
+      percentile
+    }
+  ];
+};
+
+// solana/rpc/priority-fee-estimate/general.ts
+var general_exports = {};
+__export(general_exports, {
+  getPriorityFeeEstimate: () => getPriorityFeeEstimate2,
+  getRecentPrioritizationFee: () => getRecentPrioritizationFee2
+});
+var pk = (address) => {
+  return typeof address === "string" ? new web3_js.PublicKey(address) : address;
+};
+
+// solana/rpc/priority-fee-estimate/general.ts
+var getPriorityFeeEstimate2 = async (connection, options) => {
+  const recentPrioritizationFee = await getRecentPrioritizationFee2(connection, options);
+  const median = resolveMedian(recentPrioritizationFee.map((r) => r.prioritizationFee));
+  return { median: median * (1 + (options.safeAreaIncrease ?? 0.05)), data: recentPrioritizationFee };
+};
+var getRecentPrioritizationFee2 = async (connection, options) => {
+  return connection.getRecentPrioritizationFees({ lockedWritableAccounts: buildArgs2(options.accountsOrTx)[0] });
+};
+var buildArgs2 = (accountsOrTx) => {
+  const accountsArray = accountsOrTx instanceof Array ? accountsOrTx.map(pk) : deserializeRawTransaction(accountsOrTx).writableAccounts;
+  return [accountsArray];
+};
+
+exports.priorityFeeEstimation = general_exports;
+exports.priorityFeeEstimationPercentile = percentile_exports;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/solana/rpc/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../solana/rpc/priority-fee-estimate/percentile.ts","../../../../solana/deserialize-raw-transaction.ts","../../../../solana/rpc/priority-fee-estimate/calc-fee.ts","../../../../solana/rpc/priority-fee-estimate/general.ts","../../../../solana/public-key.ts"],"names":["Buffer","Transaction","VersionedTransaction","getPriorityFeeEstimate","getRecentPrioritizationFee","PublicKey","buildArgs"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { Connection, PublicKey } from \"@solana/web3.js\";\n\nimport { deserializeRawTransaction } from \"../../deserialize-raw-transaction.js\";\nimport type { GetPriorityFeeEstimateOptions } from \"../../types.js\";\nimport { resolveMedian } from \"./calc-fee.js\";\n\ntype RpcRequest = (methodName: string, args: Array<any> | ReadonlyArray<any>) => Promise<any>;\ninterface RecentPrioritizationFee {\n  result: Array<{ prioritizationFee: number; slot: number }>;\n}\n\nexport const getPriorityFeeEstimate = async (connection: Connection, options: GetPriorityFeeEstimateOptions) => {\n  const recentPrioritizationFee = await getRecentPrioritizationFee(connection, options);\n  const median = resolveMedian(recentPrioritizationFee.result.map((r) => r.prioritizationFee));\n  return { median: median * (1 + (options.safeAreaIncrease ?? 0.05)), data: recentPrioritizationFee };\n};\n\n/**\n * If an RPC of use supports percentile value, aka {@link https://docs.triton.one/chains/solana/improved-priority-fees-api}\n * @param connection - The connection to the RPC\n * @param options - The options for the RPC\n * @returns The priority fee estimate\n */\nexport const getRecentPrioritizationFee = async (\n  connection: Connection,\n  options: Pick<GetPriorityFeeEstimateOptions, \"accountsOrTx\" | \"percentile\">,\n): Promise<RecentPrioritizationFee> => {\n  const { accountsOrTx, percentile = 5000 } = options;\n\n  return (connection as unknown as { _rpcRequest: RpcRequest })._rpcRequest(\n    \"getRecentPrioritizationFees\",\n    buildArgs(accountsOrTx, percentile),\n  ) as Promise<RecentPrioritizationFee>;\n};\n\nconst buildArgs = (accountsOrTx: (string | PublicKey)[] | string, percentile: number) => {\n  const accountsArray =\n    accountsOrTx instanceof Array\n      ? accountsOrTx.map((a) => a.toString())\n      : deserializeRawTransaction(accountsOrTx).writableAccounts.map((a) => a.toString());\n  return [\n    accountsArray,\n    {\n      percentile,\n    },\n  ] as const;\n};\n","import { Transaction, VersionedTransaction, type PublicKey } from \"@solana/web3.js\";\nimport { Buffer } from \"buffer\";\n\ninterface TransactionAccountsProvider {\n  accountKeys: PublicKey[];\n}\n\nexport function deserializeRawTransaction(serializedTx: string) {\n  const txBuffer = Buffer.from(serializedTx, \"base64\");\n  try {\n    const tx = Transaction.from(txBuffer);\n    const message = tx.compileMessage();\n    const accounts = message.accountKeys;\n    const writableAccounts = accounts.filter((_, idx) => message.isAccountWritable(idx));\n    return {\n      type: \"legacy\",\n      transaction: tx,\n      accounts,\n      writableAccounts,\n    };\n  } catch (error) {\n    try {\n      const vtx = VersionedTransaction.deserialize(txBuffer);\n      const message = vtx.message;\n      const accounts =\n        \"staticAccountKeys\" in message\n          ? message.staticAccountKeys\n          : (message as unknown as TransactionAccountsProvider).accountKeys;\n\n      const writableAccounts = accounts.filter((_, idx) => message.isAccountWritable(idx));\n      return {\n        type: \"versioned\",\n        transaction: vtx,\n        accounts,\n        writableAccounts,\n      };\n    } catch (vError) {\n      throw new Error(\"Failed to deserialize transaction: \" + (vError instanceof Error ? vError.message : vError), {\n        cause: vError,\n      });\n    }\n  }\n}\n","export const resolveMedian = (values: number[]) => {\n  if (values.length < 2) {\n    return 0;\n  }\n\n  const sortedRates = [...values].sort((a, b) => a - b);\n  const medianIndex = Math.floor(sortedRates.length / 2);\n  const medianArrValue = sortedRates[medianIndex];\n  const medianPrevValue = sortedRates[medianIndex - 1];\n\n  if (medianPrevValue === undefined || medianArrValue === undefined) {\n    return 0;\n  }\n\n  const medianValue = sortedRates.length % 2 === 0 ? (medianPrevValue + medianArrValue) / 2 : medianArrValue;\n\n  return medianValue;\n};\n","import type { Connection, PublicKey } from \"@solana/web3.js\";\n\nimport { deserializeRawTransaction } from \"../../deserialize-raw-transaction.js\";\nimport { pk } from \"../../public-key.js\";\nimport type { GetPriorityFeeEstimateOptions } from \"../../types.js\";\nimport { resolveMedian } from \"./calc-fee.js\";\n\nexport const getPriorityFeeEstimate = async (connection: Connection, options: GetPriorityFeeEstimateOptions) => {\n  const recentPrioritizationFee = await getRecentPrioritizationFee(connection, options);\n  const median = resolveMedian(recentPrioritizationFee.map((r) => r.prioritizationFee));\n  return { median: median * (1 + (options.safeAreaIncrease ?? 0.05)), data: recentPrioritizationFee };\n};\n\nexport const getRecentPrioritizationFee = async (\n  connection: Connection,\n  options: Pick<GetPriorityFeeEstimateOptions, \"accountsOrTx\">,\n) => {\n  return connection.getRecentPrioritizationFees({ lockedWritableAccounts: buildArgs(options.accountsOrTx)[0] });\n};\n\nconst buildArgs = (accountsOrTx: (string | PublicKey)[] | string) => {\n  const accountsArray =\n    accountsOrTx instanceof Array ? accountsOrTx.map(pk) : deserializeRawTransaction(accountsOrTx).writableAccounts;\n  return [accountsArray] as const;\n};\n","import { PublicKey } from \"@solana/web3.js\";\n\n/**\n * Converts a string or PublicKey to a PublicKey object.\n * @param address - The input address as a string or PublicKey.\n * @returns The PublicKey object.\n */\nexport const pk = (address: string | PublicKey): PublicKey => {\n  return typeof address === \"string\" ? new PublicKey(address) : address;\n};\n"]}

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

@@ -0,0 +1,40 @@
+import * as _solana_web3_js from '@solana/web3.js';
+import { Connection } from '@solana/web3.js';
+import { G as GetPriorityFeeEstimateOptions } from '../../types-DGCX8JLm.cjs';
+import 'p-queue';
+
+interface RecentPrioritizationFee {
+    result: Array<{
+        prioritizationFee: number;
+        slot: number;
+    }>;
+}
+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 };
+}
+
+declare const getPriorityFeeEstimate: (connection: Connection, options: GetPriorityFeeEstimateOptions) => Promise<{
+    median: number;
+    data: _solana_web3_js.RecentPrioritizationFees[];
+}>;
+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 { general as priorityFeeEstimation, percentile as priorityFeeEstimationPercentile };

package/dist/cjs/types-DGCX8JLm.d.cts

@@ -0,0 +1,73 @@
+import { PublicKey, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment } from '@solana/web3.js';
+import PQueue from 'p-queue';
+
+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);
+}
+/**
+ * @interface GetPriorityFeeEstimateOptions - The options for the priority fee estimate
+ * @property accountsOrTx - The accounts or transaction to get the priority fee estimate for.
+ * @property percentile - The percentile of the priority fee estimate to return.
+ * @property safeAreaIncrease - The safe area increase to apply to 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.
+     */
+    accountsOrTx: (string | PublicKey)[] | string;
+    /**
+     * The percentile of the priority fee estimate to return.
+     * [0, 10000] for Triton RPC signature
+     * Default: 5000
+     */
+    percentile?: number;
+    /**
+     * The safe area increase to apply to the priority fee estimate.
+     * Default: 0.05 = 5%
+     */
+    safeAreaIncrease?: number;
+}
+
+export { type Account as A, type ConfirmationParams as C, type GetPriorityFeeEstimateOptions as G, type ITransactionSolanaExt as I, type ThrottleParams as T, type AtaParams as a, type ComputePriceEstimate as b, type IInteractSolanaExt as c, type CheckAssociatedTokenAccountsData as d, type IProgramAccount as e, TransactionFailedError as f };

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

@@ -1,8 +1,10 @@
-import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment, Keypair, Transaction, VersionedTransaction, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus } from '@solana/web3.js';
+import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, Keypair, Transaction, VersionedTransaction, Commitment, BlockhashWithExpiryBlockHeight, Context, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus, AccountInfo } from '@solana/web3.js';
 import BN from 'bn.js';
-import PQueue from 'p-queue';
+import { A as Account, C as ConfirmationParams, T as ThrottleParams, a as AtaParams, I as ITransactionSolanaExt, b as ComputePriceEstimate, c as IInteractSolanaExt } from '../types-DGCX8JLm.js';
+export { d as CheckAssociatedTokenAccountsData, G as GetPriorityFeeEstimateOptions, e as IProgramAccount, f as TransactionFailedError } from '../types-DGCX8JLm.js';
 import { Mint } from '@solana/spl-token';
 import { SignerWalletAdapter } from '@solana/wallet-adapter-base';
+import PQueue from 'p-queue';
 
 declare const getFilters: <T extends Record<string, number | PublicKey>>(criteria: T, byteOffsets: Record<keyof T, number>) => MemcmpFilter[];
 
@@ -15,44 +17,6 @@ declare const prepareWrappedAccount: (connection: Connection, senderAddress: Pub
  */
 declare const pk: (address: string | PublicKey) => PublicKey;
 
-interface ITransactionSolanaExt {
-    computePrice?: number;
-    computeLimit?: number;
-}
-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
@@ -90,11 +54,12 @@ declare function isTransactionVersioned(tx: Transaction | VersionedTransaction):
  * @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<{
+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
@@ -236,4 +201,20 @@ declare function getMintAndProgram(connection: Connection, address: PublicKey, c
  */
 declare function getMultipleAccountsInfoBatched(connection: Connection, pubKeys: PublicKey[], commitment?: Commitment): Promise<(AccountInfo<Buffer> | null)[]>;
 
-export { type Account, type AtaParams, type CheckAssociatedTokenAccountsData, type ConfirmationParams, type IProgramAccount, type ITransactionSolanaExt, type ThrottleParams, TransactionFailedError, ata, ataBatchExist, buildSendThrottler, checkOrCreateAtaBatch, confirmAndEnsureTransaction, createAtaBatch, enrichAtaParams, executeMultipleTransactions, executeTransaction, generateCreateAtaBatchTx, getFilters, getMintAndProgram, getMultipleAccountsInfoBatched, getProgramAccounts, isSignerKeypair, isSignerWallet, isTransactionVersioned, pk, prepareBaseInstructions, prepareTransaction, prepareWrappedAccount, sendAndConfirmTransaction, signAndExecuteTransaction, signTransaction, simulateTransaction };
+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 { Account, AtaParams, ComputePriceEstimate, ConfirmationParams, IInteractSolanaExt, ITransactionSolanaExt, ThrottleParams, 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 };

package/dist/esm/solana/index.js

@@ -1,7 +1,8 @@
 import { getAssociatedTokenAddress, NATIVE_MINT, createAssociatedTokenAccountInstruction, createSyncNativeInstruction, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, unpackMint } from '@solana/spl-token';
-import { SystemProgram, PublicKey, Keypair, TransactionMessage, VersionedTransaction, SendTransactionError, ComputeBudgetProgram } from '@solana/web3.js';
+import { SystemProgram, PublicKey, Keypair, TransactionMessage, VersionedTransaction, SendTransactionError, ComputeBudgetProgram, Transaction } from '@solana/web3.js';
 import bs58 from 'bs58';
 import 'bn.js';
+import { Buffer as Buffer$1 } from 'buffer';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -51,12 +52,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
 var require_eventemitter3 = __commonJS({
   "../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js"(exports, module) {
     var has = Object.prototype.hasOwnProperty;
-    var prefix = "~";
+    var prefix2 = "~";
     function Events() {
     }
     if (Object.create) {
       Events.prototype = /* @__PURE__ */ Object.create(null);
-      if (!new Events().__proto__) prefix = false;
+      if (!new Events().__proto__) prefix2 = false;
     }
     function EE(fn, context, once) {
       this.fn = fn;
@@ -67,7 +68,7 @@ var require_eventemitter3 = __commonJS({
       if (typeof fn !== "function") {
         throw new TypeError("The listener must be a function");
       }
-      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      var listener = new EE(fn, context || emitter, once), evt = prefix2 ? prefix2 + event : event;
       if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
       else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
       else emitter._events[evt] = [emitter._events[evt], listener];
@@ -85,7 +86,7 @@ var require_eventemitter3 = __commonJS({
       var names = [], events, name;
       if (this._eventsCount === 0) return names;
       for (name in events = this._events) {
-        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+        if (has.call(events, name)) names.push(prefix2 ? name.slice(1) : name);
       }
       if (Object.getOwnPropertySymbols) {
         return names.concat(Object.getOwnPropertySymbols(events));
@@ -93,7 +94,7 @@ var require_eventemitter3 = __commonJS({
       return names;
     };
     EventEmitter2.prototype.listeners = function listeners(event) {
-      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      var evt = prefix2 ? prefix2 + event : event, handlers = this._events[evt];
       if (!handlers) return [];
       if (handlers.fn) return [handlers.fn];
       for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
@@ -102,13 +103,13 @@ var require_eventemitter3 = __commonJS({
       return ee;
     };
     EventEmitter2.prototype.listenerCount = function listenerCount(event) {
-      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      var evt = prefix2 ? prefix2 + event : event, listeners = this._events[evt];
       if (!listeners) return 0;
       if (listeners.fn) return 1;
       return listeners.length;
     };
     EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-      var evt = prefix ? prefix + event : event;
+      var evt = prefix2 ? prefix2 + event : event;
       if (!this._events[evt]) return false;
       var listeners = this._events[evt], len = arguments.length, args, i;
       if (listeners.fn) {
@@ -165,7 +166,7 @@ var require_eventemitter3 = __commonJS({
       return addListener(this, event, fn, context, true);
     };
     EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
-      var evt = prefix ? prefix + event : event;
+      var evt = prefix2 ? prefix2 + event : event;
       if (!this._events[evt]) return this;
       if (!fn) {
         clearEvent(this, evt);
@@ -190,7 +191,7 @@ var require_eventemitter3 = __commonJS({
     EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
       var evt;
       if (event) {
-        evt = prefix ? prefix + event : event;
+        evt = prefix2 ? prefix2 + event : event;
         if (this._events[evt]) clearEvent(this, evt);
       } else {
         this._events = new Events();
@@ -200,7 +201,7 @@ var require_eventemitter3 = __commonJS({
     };
     EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
     EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
-    EventEmitter2.prefixed = prefix;
+    EventEmitter2.prefixed = prefix2;
     EventEmitter2.EventEmitter = EventEmitter2;
     if ("undefined" !== typeof module) {
       module.exports = EventEmitter2;
@@ -705,6 +706,17 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// 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);
+};
+
 // solana/utils.ts
 var SIMULATE_TRIES = 3;
 var buildSendThrottler = (sendRate, sendInterval = 1e3) => {
@@ -732,20 +744,30 @@ function isSignerKeypair(walletOrKeypair) {
 function isTransactionVersioned(tx) {
   return "message" in tx;
 }
-async function prepareTransaction(connection, ixs, payer, commitment, ...partialSigners) {
+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);
+  return {
+    tx: createVersionedTransaction(ixs, payer, hash.blockhash, partialSigners),
+    hash,
+    context
+  };
+}
+function createVersionedTransaction(ixs, payer, recentBlockhash, partialSigners) {
+  invariant(payer, "Payer public key is not provided!");
   const messageV0 = new TransactionMessage({
     payerKey: payer,
-    recentBlockhash: hash.blockhash,
+    recentBlockhash,
     instructions: ixs
   }).compileToV0Message();
   const tx = new VersionedTransaction(messageV0);
-  const signers = partialSigners.filter((item) => !!item);
-  tx.sign(signers);
-  return { tx, context, hash };
+  const signers = partialSigners?.filter((item) => !!item) ?? void 0;
+  if (signers) {
+    tx.sign(signers);
+  }
+  return tx;
 }
 async function signTransaction(invoker, tx) {
   let signedTx;
@@ -937,13 +959,7 @@ async function generateCreateAtaBatchTx(connection, payer, paramsBatch, commitme
     })
   );
   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 };
+  return { tx: createVersionedTransaction(ixs, payer, hash.blockhash), hash, context };
 }
 async function createAtaBatch(connection, invoker, paramsBatch, commitment, rate) {
   const { tx, hash, context } = await generateCreateAtaBatchTx(
@@ -973,7 +989,7 @@ async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programI
 }
 function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
   const ixs = [];
-  if (computePrice) {
+  if (computePrice && typeof computePrice === "number") {
     ixs.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: computePrice }));
   }
   if (computeLimit) {
@@ -1003,6 +1019,68 @@ async function getMultipleAccountsInfoBatched(connection, pubKeys, commitment) {
   return results.flat();
 }
 
-export { TransactionFailedError, ata, ataBatchExist, buildSendThrottler, checkOrCreateAtaBatch, confirmAndEnsureTransaction, createAtaBatch, enrichAtaParams, executeMultipleTransactions, executeTransaction, generateCreateAtaBatchTx, getFilters, getMintAndProgram, getMultipleAccountsInfoBatched, getProgramAccounts, isSignerKeypair, isSignerWallet, isTransactionVersioned, pk, prepareBaseInstructions, prepareTransaction, prepareWrappedAccount, sendAndConfirmTransaction, signAndExecuteTransaction, signTransaction, simulateTransaction };
+// solana/lib/estimate.ts
+async function estimateComputeUnitPrice(estimate, ixs, payer, recentBlockhash, partialSigners) {
+  const tx = createVersionedTransaction(
+    ixs,
+    payer,
+    recentBlockhash ?? "11111111111111111111111111111111",
+    partialSigners
+  );
+  return estimate(Buffer.from(tx.serialize()).toString("base64"));
+}
+async function createAndEstimateTransaction(createFn, extParams, select) {
+  select = select ?? ((value) => value);
+  const createResult = await createFn(extParams);
+  const prepareIxs = select(createResult);
+  const priorityFee = extParams.computePrice;
+  if (priorityFee === void 0 || typeof priorityFee === "number") {
+    return createResult;
+  }
+  const invoker = extParams.invoker.publicKey;
+  invariant(invoker, "Invoker's PublicKey is not available, check passed wallet adapter!");
+  const estimatedComputeUnitPrice = typeof priorityFee === "function" ? await estimateComputeUnitPrice(priorityFee, prepareIxs, pk(invoker)) : (
+    // unachievable because we don't execute estimation for constant or undefined priority fee
+    priorityFee
+  );
+  return createFn({
+    ...extParams,
+    computePrice: estimatedComputeUnitPrice
+  });
+}
+function deserializeRawTransaction(serializedTx) {
+  const txBuffer = Buffer$1.from(serializedTx, "base64");
+  try {
+    const tx = Transaction.from(txBuffer);
+    const message = tx.compileMessage();
+    const accounts = message.accountKeys;
+    const writableAccounts = accounts.filter((_, idx) => message.isAccountWritable(idx));
+    return {
+      type: "legacy",
+      transaction: tx,
+      accounts,
+      writableAccounts
+    };
+  } catch (error) {
+    try {
+      const vtx = VersionedTransaction.deserialize(txBuffer);
+      const message = vtx.message;
+      const accounts = "staticAccountKeys" in message ? message.staticAccountKeys : message.accountKeys;
+      const writableAccounts = accounts.filter((_, idx) => message.isAccountWritable(idx));
+      return {
+        type: "versioned",
+        transaction: vtx,
+        accounts,
+        writableAccounts
+      };
+    } catch (vError) {
+      throw new Error("Failed to deserialize transaction: " + (vError instanceof Error ? vError.message : vError), {
+        cause: vError
+      });
+    }
+  }
+}
+
+export { 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map