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

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

@@ -1,10 +1,8 @@
-import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, Keypair, Transaction, VersionedTransaction, Commitment, BlockhashWithExpiryBlockHeight, Context, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus, AccountInfo } from '@solana/web3.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 { 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[];
 
@@ -17,6 +15,44 @@ 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
@@ -54,12 +90,11 @@ 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
@@ -201,20 +236,4 @@ 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;
-    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 };
+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 };

package/dist/esm/solana/index.js

@@ -1,8 +1,7 @@
 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, PublicKey, Keypair, TransactionMessage, VersionedTransaction, SendTransactionError, ComputeBudgetProgram } 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;
@@ -52,12 +51,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 prefix2 = "~";
+    var prefix = "~";
     function Events() {
     }
     if (Object.create) {
       Events.prototype = /* @__PURE__ */ Object.create(null);
-      if (!new Events().__proto__) prefix2 = false;
+      if (!new Events().__proto__) prefix = false;
     }
     function EE(fn, context, once) {
       this.fn = fn;
@@ -68,7 +67,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 = prefix2 ? prefix2 + event : event;
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + 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];
@@ -86,7 +85,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(prefix2 ? name.slice(1) : name);
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
       }
       if (Object.getOwnPropertySymbols) {
         return names.concat(Object.getOwnPropertySymbols(events));
@@ -94,7 +93,7 @@ var require_eventemitter3 = __commonJS({
       return names;
     };
     EventEmitter2.prototype.listeners = function listeners(event) {
-      var evt = prefix2 ? prefix2 + event : event, handlers = this._events[evt];
+      var evt = prefix ? prefix + 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++) {
@@ -103,13 +102,13 @@ var require_eventemitter3 = __commonJS({
       return ee;
     };
     EventEmitter2.prototype.listenerCount = function listenerCount(event) {
-      var evt = prefix2 ? prefix2 + event : event, listeners = this._events[evt];
+      var evt = prefix ? prefix + 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 = prefix2 ? prefix2 + event : event;
+      var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return false;
       var listeners = this._events[evt], len = arguments.length, args, i;
       if (listeners.fn) {
@@ -166,7 +165,7 @@ var require_eventemitter3 = __commonJS({
       return addListener(this, event, fn, context, true);
     };
     EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
-      var evt = prefix2 ? prefix2 + event : event;
+      var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return this;
       if (!fn) {
         clearEvent(this, evt);
@@ -191,7 +190,7 @@ var require_eventemitter3 = __commonJS({
     EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
       var evt;
       if (event) {
-        evt = prefix2 ? prefix2 + event : event;
+        evt = prefix ? prefix + event : event;
         if (this._events[evt]) clearEvent(this, evt);
       } else {
         this._events = new Events();
@@ -201,7 +200,7 @@ var require_eventemitter3 = __commonJS({
     };
     EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
     EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
-    EventEmitter2.prefixed = prefix2;
+    EventEmitter2.prefixed = prefix;
     EventEmitter2.EventEmitter = EventEmitter2;
     if ("undefined" !== typeof module) {
       module.exports = EventEmitter2;
@@ -706,17 +705,6 @@ 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) => {
@@ -744,30 +732,20 @@ 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,
+    recentBlockhash: hash.blockhash,
     instructions: ixs
   }).compileToV0Message();
   const tx = new VersionedTransaction(messageV0);
-  const signers = partialSigners?.filter((item) => !!item) ?? void 0;
-  if (signers) {
-    tx.sign(signers);
-  }
-  return tx;
+  const signers = partialSigners.filter((item) => !!item);
+  tx.sign(signers);
+  return { tx, context, hash };
 }
 async function signTransaction(invoker, tx) {
   let signedTx;
@@ -959,7 +937,13 @@ async function generateCreateAtaBatchTx(connection, payer, paramsBatch, commitme
     })
   );
   const { value: hash, context } = await connection.getLatestBlockhashAndContext({ commitment });
-  return { tx: createVersionedTransaction(ixs, payer, hash.blockhash), hash, context };
+  const messageV0 = new TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: hash.blockhash,
+    instructions: ixs
+  }).compileToV0Message();
+  const tx = new VersionedTransaction(messageV0);
+  return { tx, hash, context };
 }
 async function createAtaBatch(connection, invoker, paramsBatch, commitment, rate) {
   const { tx, hash, context } = await generateCreateAtaBatchTx(
@@ -989,7 +973,7 @@ async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programI
 }
 function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
   const ixs = [];
-  if (computePrice && typeof computePrice === "number") {
+  if (computePrice) {
     ixs.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: computePrice }));
   }
   if (computeLimit) {
@@ -1019,68 +1003,6 @@ async function getMultipleAccountsInfoBatched(connection, pubKeys, commitment) {
   return results.flat();
 }
 
-// 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 };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map