@streamflow/common 8.0.0-alpha.p287.84ff30f → 8.0.1-alpha.p287.54fe41f

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

@@ -1,21 +1,73 @@
-import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, Keypair, Transaction, VersionedTransaction, Commitment, BlockhashWithExpiryBlockHeight, Context, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus, AccountInfo } from '@solana/web3.js';
+import * as _solana_web3_js from '@solana/web3.js';
+import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, VersionedTransaction, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment, Keypair, Transaction, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus } from '@solana/web3.js';
 import BN from 'bn.js';
-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 PQueue from 'p-queue';
 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[];
 
 declare const prepareWrappedAccount: (connection: Connection, senderAddress: PublicKey, amount: BN) => Promise<TransactionInstruction[]>;
 
+type ComputePriceEstimate = (tx: string | (string | PublicKey)[]) => Promise<number>;
+type ComputeLimitEstimate = (tx: VersionedTransaction) => Promise<number>;
+interface ITransactionSolanaExt {
+    computePrice?: number | ComputePriceEstimate;
+    computeLimit?: number | ComputeLimitEstimate | "autoSimulate";
+}
 /**
- * Converts a string or PublicKey to a PublicKey object.
- * @param address - The input address as a string or PublicKey.
- * @returns The PublicKey object.
+ * Acceptable type with resolved values.
+ * Function types may be omitted if passed to destinations that do not support them.
  */
-declare const pk: (address: string | PublicKey) => PublicKey;
+type ITransactionSolanaExtResolvedValues = {
+    computePrice?: number | ComputePriceEstimate;
+    computeLimit?: number | ComputeLimitEstimate;
+};
+type KeysNotOfA<T, ToExclude> = Pick<T, Exclude<keyof T, keyof ToExclude>>;
+type ITransactionSolanaExtResolved<T extends ITransactionSolanaExt = ITransactionSolanaExt> = {
+    [AK in keyof KeysNotOfA<T, ITransactionSolanaExt>]: T[AK];
+} & ITransactionSolanaExtResolvedValues;
+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 TransactionExecutionParams extends ThrottleParams {
+    skipSimulation?: boolean;
+}
+interface IProgramAccount<T> {
+    publicKey: PublicKey;
+    account: T;
+}
+declare class TransactionFailedError extends Error {
+    constructor(m: string);
+}
 
 declare const buildSendThrottler: (sendRate: number, sendInterval?: number) => PQueue;
 /**
@@ -67,10 +119,10 @@ declare function signTransaction<T extends Transaction | VersionedTransaction>(i
  * @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
+ * @param transactionExecutionParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much and solana execution params (eg. skipSimulation)
  * @returns Transaction signature
  */
-declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, throttleParams: ThrottleParams): Promise<string>;
+declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, transactionExecutionParams: TransactionExecutionParams): Promise<string>;
 /**
  * Sends and confirms Transaction
  * Uses custom confirmation logic that:
@@ -83,10 +135,10 @@ declare function signAndExecuteTransaction(connection: Connection, invoker: Keyp
  * @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
+ * @param transactionExecutionParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much and solana execution params (eg. skipSimulation)
  * @returns Transaction signature
  */
-declare function executeTransaction(connection: Connection, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, throttleParams: ThrottleParams): Promise<string>;
+declare function executeTransaction(connection: Connection, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, transactionExecutionParams: TransactionExecutionParams): 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
@@ -172,8 +224,8 @@ declare function createAtaBatch(connection: Connection, invoker: Keypair | Signe
 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
- * - sets compute limit if `computeLimit` is provided
+ * - 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. If `computeLimit` is a function, it will be ignored (the value must be resolved before calling this function).
  */
 declare function prepareBaseInstructions(connection: Connection, { computePrice, computeLimit }: ITransactionSolanaExt): TransactionInstruction[];
 /**
@@ -201,10 +253,6 @@ declare function getMintAndProgram(connection: Connection, address: PublicKey, c
  */
 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;
@@ -216,5 +264,34 @@ declare function deserializeRawTransaction(serializedTx: string): {
     accounts: PublicKey[];
     writableAccounts: PublicKey[];
 };
+declare const resolveTransactionAccounts: (tx: VersionedTransaction | Transaction) => {
+    type: string;
+    transaction: Transaction;
+    accounts: PublicKey[];
+    writableAccounts: PublicKey[];
+} | {
+    type: string;
+    transaction: VersionedTransaction;
+    accounts: PublicKey[];
+    writableAccounts: PublicKey[];
+};
+
+declare const createTestTransaction: (ixs: Parameters<typeof createVersionedTransaction>[0], payer: Parameters<typeof createVersionedTransaction>[1], recentBlockhash?: Parameters<typeof createVersionedTransaction>[2], partialSigners?: Parameters<typeof createVersionedTransaction>[3]) => _solana_web3_js.VersionedTransaction;
+declare function estimateComputeUnitPrice(estimate: ComputePriceEstimate, testTx: ReturnType<typeof createTestTransaction>): Promise<number>;
+declare function createAndEstimateTransaction<ParamsT extends ITransactionSolanaExtResolved<IInteractSolanaExt>, CreateFn extends (extParams: ParamsT) => Promise<TransactionInstruction[]>>(createFn: CreateFn, extParams: ParamsT): Promise<Awaited<ReturnType<CreateFn>>>;
+declare function createAndEstimateTransaction<ParamsT extends ITransactionSolanaExtResolved<IInteractSolanaExt>, CreateFn extends (extParams: ParamsT) => Promise<any>>(createFn: CreateFn, extParams: ParamsT, select: (result: Awaited<ReturnType<CreateFn>>) => TransactionInstruction[]): Promise<Awaited<ReturnType<CreateFn>>>;
+
+/**
+ * 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 UnwrapAutoSimulate<T extends IInteractSolanaExt = IInteractSolanaExt> = Omit<T, "computeLimit"> & {
+    skipSimulation: boolean;
+    computeLimit?: ITransactionSolanaExtResolved["computeLimit"];
+};
+declare const unwrapExecutionParams: <T extends IInteractSolanaExt>({ computeLimit, ...rest }: T, connection: Connection) => UnwrapAutoSimulate<T>;
 
-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 };
+export { type Account, type AtaParams, type CheckAssociatedTokenAccountsData, type ComputeLimitEstimate, type ComputePriceEstimate, type ConfirmationParams, type IInteractSolanaExt, type IProgramAccount, type ITransactionSolanaExt, type ITransactionSolanaExtResolved, type ThrottleParams, type TransactionExecutionParams, 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, resolveTransactionAccounts, sendAndConfirmTransaction, signAndExecuteTransaction, signTransaction, simulateTransaction, unwrapExecutionParams };

package/dist/esm/solana/index.js

@@ -1,8 +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, Transaction } from '@solana/web3.js';
+import { SystemProgram, Keypair, TransactionMessage, VersionedTransaction, SendTransactionError, ComputeBudgetProgram, Transaction, PublicKey } from '@solana/web3.js';
 import bs58 from 'bs58';
 import 'bn.js';
-import { Buffer as Buffer$1 } from 'buffer';
+import { Buffer } from 'buffer';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -239,9 +239,6 @@ var prepareWrappedAccount = async (connection, senderAddress, amount) => {
     createSyncNativeInstruction(tokenAccount)
   ];
 };
-var pk = (address) => {
-  return typeof address === "string" ? new PublicKey(address) : address;
-};
 
 // solana/types.ts
 var TransactionFailedError = class _TransactionFailedError extends Error {
@@ -783,16 +780,18 @@ async function signTransaction(invoker, tx) {
   }
   return signedTx;
 }
-async function signAndExecuteTransaction(connection, invoker, tx, confirmationParams, throttleParams) {
+async function signAndExecuteTransaction(connection, invoker, tx, confirmationParams, transactionExecutionParams) {
   const signedTx = await signTransaction(invoker, tx);
-  return executeTransaction(connection, signedTx, confirmationParams, throttleParams);
+  return executeTransaction(connection, signedTx, confirmationParams, transactionExecutionParams);
 }
-async function executeTransaction(connection, tx, confirmationParams, throttleParams) {
+async function executeTransaction(connection, tx, confirmationParams, transactionExecutionParams) {
   if (tx.signatures.length === 0) {
     throw Error("Error with transaction parameters.");
   }
-  await simulateTransaction(connection, tx);
-  return sendAndConfirmTransaction(connection, tx, confirmationParams, throttleParams);
+  if (!transactionExecutionParams.skipSimulation) {
+    await simulateTransaction(connection, tx);
+  }
+  return sendAndConfirmTransaction(connection, tx, confirmationParams, transactionExecutionParams);
 }
 async function executeMultipleTransactions(connection, txs, confirmationParams, { sendRate = 1, sendThrottler, ...throttlingParams }) {
   if (!sendThrottler) {
@@ -989,10 +988,10 @@ async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programI
 }
 function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
   const ixs = [];
-  if (computePrice && typeof computePrice === "number") {
+  if (computePrice && typeof computePrice !== "function") {
     ixs.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: computePrice }));
   }
-  if (computeLimit) {
+  if (computeLimit && typeof computeLimit === "number") {
     ixs.push(ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }));
   }
   return ixs;
@@ -1018,69 +1017,103 @@ async function getMultipleAccountsInfoBatched(connection, pubKeys, commitment) {
   const results = await Promise.all(batches);
   return results.flat();
 }
+function deserializeRawTransaction(serializedTx) {
+  const txBuffer = Buffer.from(serializedTx, "base64");
+  try {
+    const tx = Transaction.from(txBuffer);
+    return resolveTransactionAccounts(tx);
+  } catch (error) {
+    try {
+      const vtx = VersionedTransaction.deserialize(txBuffer);
+      return resolveTransactionAccounts(vtx);
+    } catch (vError) {
+      throw new Error("Failed to deserialize transaction: " + (vError instanceof Error ? vError.message : vError), {
+        cause: vError
+      });
+    }
+  }
+}
+var resolveTransactionAccounts = (tx) => {
+  if (tx instanceof Transaction) {
+    const message2 = tx.compileMessage();
+    const accounts2 = message2.accountKeys;
+    const writableAccounts2 = accounts2.filter((_, idx) => message2.isAccountWritable(idx));
+    return {
+      type: "legacy",
+      transaction: tx,
+      accounts: accounts2,
+      writableAccounts: writableAccounts2
+    };
+  }
+  const message = tx.message;
+  const accounts = "staticAccountKeys" in message ? message.staticAccountKeys : message.accountKeys;
+  const writableAccounts = accounts.filter((_, idx) => message.isAccountWritable(idx));
+  return {
+    type: "versioned",
+    transaction: tx,
+    accounts,
+    writableAccounts
+  };
+};
+var pk = (address) => {
+  return typeof address === "string" ? new PublicKey(address) : address;
+};
 
 // 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"));
+var createTestTransaction = (ixs, payer, recentBlockhash, partialSigners) => {
+  return createVersionedTransaction(ixs, payer, "11111111111111111111111111111111", partialSigners);
+};
+async function estimateComputeUnitPrice(estimate, testTx) {
+  return estimate(resolveTransactionAccounts(testTx).writableAccounts);
 }
 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 { computePrice, computeLimit } = extParams;
   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)) : (
+  const testTx = createTestTransaction(prepareIxs, pk(invoker), void 0, void 0);
+  const estimatedComputeLimit = typeof computeLimit === "function" ? await computeLimit(testTx) : computeLimit;
+  if (typeof computePrice !== "function") {
+    if (typeof computeLimit !== "function") {
+      return createResult;
+    }
+    return createFn({
+      ...extParams,
+      computeLimit: estimatedComputeLimit
+    });
+  }
+  const estimatedComputeUnitPrice = typeof computePrice === "function" ? await estimateComputeUnitPrice(computePrice, testTx) : (
     // unachievable because we don't execute estimation for constant or undefined priority fee
-    priorityFee
+    computePrice
   );
   return createFn({
     ...extParams,
-    computePrice: estimatedComputeUnitPrice
+    computePrice: estimatedComputeUnitPrice,
+    computeLimit: estimatedComputeLimit
   });
 }
-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 };
+// solana/rpc/consume-limit-estimate/estimate.ts
+var estimateConsumeLimit = async (connection, tx, options = {}) => {
+  const { multiplierPercent = 0.05 } = options;
+  const simulationResults = await connection.simulateTransaction(tx, {
+    sigVerify: false,
+    replaceRecentBlockhash: true
+  });
+  return {
+    unitsConsumed: simulationResults.value.unitsConsumed ? Math.ceil(simulationResults.value.unitsConsumed * (1 + multiplierPercent)) : simulationResults.value.unitsConsumed,
+    data: simulationResults
+  };
+};
+
+// solana/lib/unwrap-auto-simulate-ext.ts
+var unwrapExecutionParams = ({ computeLimit, ...rest }, connection) => {
+  const consumeLimitFn = computeLimit === "autoSimulate" ? (tx) => estimateConsumeLimit(connection, tx).then((limit) => limit.unitsConsumed ?? 0) : computeLimit;
+  return { ...rest, computeLimit: consumeLimitFn, skipSimulation: computeLimit === "autoSimulate" };
+};
+
+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, resolveTransactionAccounts, sendAndConfirmTransaction, signAndExecuteTransaction, signTransaction, simulateTransaction, unwrapExecutionParams };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map