@streamflow/common 8.0.1 → 8.0.2-alpha.p287.a3616ff

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, Keypair, TransactionMessage, VersionedTransaction, SendTransactionError, ComputeBudgetProgram, Transaction, PublicKey } from '@solana/web3.js';
 import bs58 from 'bs58';
 import 'bn.js';
+import { Buffer } 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;
@@ -238,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 {
@@ -705,6 +703,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 +741,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;
@@ -761,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) {
@@ -937,13 +958,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,10 +988,10 @@ async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programI
 }
 function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
   const ixs = [];
-  if (computePrice) {
+  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;
@@ -1002,7 +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
+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 { computePrice, computeLimit } = extParams;
+  const invoker = extParams.invoker.publicKey;
+  invariant(invoker, "Invoker's PublicKey is not available, check passed wallet adapter!");
+  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
+    computePrice
+  );
+  return createFn({
+    ...extParams,
+    computePrice: estimatedComputeUnitPrice,
+    computeLimit: estimatedComputeLimit
+  });
+}
+
+// solana/rpc/consume-limit-estimate/estimate.ts
+var estimateConsumeLimit = async (connection, tx, options = {}) => {
+  const { increaseFactor = 0.05 } = options;
+  const simulationResults = await connection.simulateTransaction(tx, {
+    sigVerify: false,
+    replaceRecentBlockhash: true
+  });
+  return {
+    unitsConsumed: simulationResults.value.unitsConsumed ? Math.ceil(simulationResults.value.unitsConsumed * (1 + increaseFactor)) : 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, createAtaBatch, enrichAtaParams, 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, 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