@streamflow/common 9.0.3 → 10.0.0-alpha.p313.3ce4d29

package/dist/cjs/index.cjs

@@ -1,13 +1,258 @@
 'use strict';
 
-require('@solana/web3.js');
+var splToken = require('@solana/spl-token');
+var web3_js = require('@solana/web3.js');
+var bs58 = require('bs58');
 var BN = require('bn.js');
+var buffer = require('buffer');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
 var BN__default = /*#__PURE__*/_interopDefault(BN);
 
-// types.ts
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+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 = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix2 = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      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;
+      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];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      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 (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      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++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      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 = prefix2 ? prefix2 + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix2 ? prefix2 + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix2 ? prefix2 + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix2;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// solana/account-filters.ts
+var getFilters = (criteria, byteOffsets) => {
+  return Object.entries(criteria).reduce((acc, [key, value]) => {
+    const criteriaKey = key;
+    const effectiveByteOffset = byteOffsets[criteriaKey];
+    if (criteria[criteriaKey] && effectiveByteOffset) {
+      acc.push({
+        memcmp: {
+          offset: effectiveByteOffset,
+          bytes: value.toString()
+        }
+      });
+    }
+    return acc;
+  }, []);
+};
+var prepareWrappedAccount = async (connection, senderAddress, amount) => {
+  const tokenAccount = await splToken.getAssociatedTokenAddress(splToken.NATIVE_MINT, senderAddress, true);
+  const accInfo = await connection.getParsedAccountInfo(tokenAccount);
+  const instructions = (accInfo.value?.lamports ?? 0) > 0 ? [] : [splToken.createAssociatedTokenAccountInstruction(senderAddress, tokenAccount, senderAddress, splToken.NATIVE_MINT)];
+  return [
+    ...instructions,
+    web3_js.SystemProgram.transfer({
+      fromPubkey: senderAddress,
+      toPubkey: tokenAccount,
+      lamports: amount.toNumber()
+    }),
+    splToken.createSyncNativeInstruction(tokenAccount)
+  ];
+};
+var TransactionFailedError = class _TransactionFailedError extends Error {
+  constructor(m) {
+    super(m);
+    Object.setPrototypeOf(this, _TransactionFailedError.prototype);
+    this.name = "TransactionFailedError";
+  }
+};
 var ICluster = /* @__PURE__ */ ((ICluster2) => {
   ICluster2["Mainnet"] = "mainnet";
   ICluster2["Devnet"] = "devnet";
@@ -15,15 +260,6 @@ var ICluster = /* @__PURE__ */ ((ICluster2) => {
   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
@@ -40,19 +276,454 @@ var ContractError = class _ContractError extends Error {
   }
 };
 
-// lib/assertions.ts
-var prefix = "Assertion failed";
-var invariant = (condition, message) => {
-  if (condition) {
-    return;
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3());
+
+// ../../node_modules/.pnpm/p-timeout@6.1.2/node_modules/p-timeout/index.js
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
   }
-  const provided = typeof message === "function" ? message() : message;
-  const value = provided ? `${prefix}: ${provided}` : prefix;
-  throw new Error(value);
 };
-function assertHasPublicKey(value, message) {
-  invariant(value.publicKey, message ?? "publicKey is missing");
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+  const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
+  return reason instanceof Error ? reason : getDOMException(reason);
+};
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout }
+  } = options;
+  let timer;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      signal.addEventListener("abort", () => {
+        reject(getAbortedReason(signal));
+      });
+    }
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      promise.then(resolve, reject);
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+        reject(timeoutError);
+      }
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve(await promise);
+      } catch (error) {
+        reject(error);
+      }
+    })();
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/lower-bound.js
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
 }
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+var _queue;
+var PriorityQueue = class {
+  constructor() {
+    __privateAdd(this, _queue, []);
+  }
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      run
+    };
+    if (this.size && __privateGet(this, _queue)[this.size - 1].priority >= options.priority) {
+      __privateGet(this, _queue).push(element);
+      return;
+    }
+    const index = lowerBound(__privateGet(this, _queue), element, (a, b) => b.priority - a.priority);
+    __privateGet(this, _queue).splice(index, 0, element);
+  }
+  dequeue() {
+    const item = __privateGet(this, _queue).shift();
+    return item?.run;
+  }
+  filter(options) {
+    return __privateGet(this, _queue).filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return __privateGet(this, _queue).length;
+  }
+};
+_queue = new WeakMap();
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+var _carryoverConcurrencyCount, _isIntervalIgnored, _intervalCount, _intervalCap, _interval, _intervalEnd, _intervalId, _timeoutId, _queue2, _queueClass, _pending, _concurrency, _isPaused, _throwOnTimeout, _PQueue_instances, doesIntervalAllowAnother_get, doesConcurrentAllowAnother_get, next_fn, onResumeInterval_fn, isIntervalPaused_get, tryToStartAnother_fn, initializeIntervalIfNeeded_fn, onInterval_fn, processQueue_fn, throwOnAbort_fn, onEvent_fn;
+var PQueue = class extends import_index.default {
+  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
+  constructor(options) {
+    super();
+    __privateAdd(this, _PQueue_instances);
+    __privateAdd(this, _carryoverConcurrencyCount);
+    __privateAdd(this, _isIntervalIgnored);
+    __privateAdd(this, _intervalCount, 0);
+    __privateAdd(this, _intervalCap);
+    __privateAdd(this, _interval);
+    __privateAdd(this, _intervalEnd, 0);
+    __privateAdd(this, _intervalId);
+    __privateAdd(this, _timeoutId);
+    __privateAdd(this, _queue2);
+    __privateAdd(this, _queueClass);
+    __privateAdd(this, _pending, 0);
+    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+    __privateAdd(this, _concurrency);
+    __privateAdd(this, _isPaused);
+    __privateAdd(this, _throwOnTimeout);
+    /**
+        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+    
+        Applies to each future operation.
+        */
+    __publicField(this, "timeout");
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
+    }
+    __privateSet(this, _carryoverConcurrencyCount, options.carryoverConcurrencyCount);
+    __privateSet(this, _isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0);
+    __privateSet(this, _intervalCap, options.intervalCap);
+    __privateSet(this, _interval, options.interval);
+    __privateSet(this, _queue2, new options.queueClass());
+    __privateSet(this, _queueClass, options.queueClass);
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    __privateSet(this, _throwOnTimeout, options.throwOnTimeout === true);
+    __privateSet(this, _isPaused, options.autoStart === false);
+  }
+  get concurrency() {
+    return __privateGet(this, _concurrency);
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    __privateSet(this, _concurrency, newConcurrency);
+    __privateMethod(this, _PQueue_instances, processQueue_fn).call(this);
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: __privateGet(this, _throwOnTimeout),
+      ...options
+    };
+    return new Promise((resolve, reject) => {
+      __privateGet(this, _queue2).enqueue(async () => {
+        __privateWrapper(this, _pending)._++;
+        __privateWrapper(this, _intervalCount)._++;
+        try {
+          options.signal?.throwIfAborted();
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, __privateMethod(this, _PQueue_instances, throwOnAbort_fn).call(this, options.signal)]);
+          }
+          const result = await operation;
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          if (error instanceof TimeoutError && !options.throwOnTimeout) {
+            resolve();
+            return;
+          }
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          __privateMethod(this, _PQueue_instances, next_fn).call(this);
+        }
+      }, options);
+      this.emit("add");
+      __privateMethod(this, _PQueue_instances, tryToStartAnother_fn).call(this);
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!__privateGet(this, _isPaused)) {
+      return this;
+    }
+    __privateSet(this, _isPaused, false);
+    __privateMethod(this, _PQueue_instances, processQueue_fn).call(this);
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    __privateSet(this, _isPaused, true);
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    __privateSet(this, _queue2, new (__privateGet(this, _queueClass))());
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (__privateGet(this, _queue2).size === 0) {
+      return;
+    }
+    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (__privateGet(this, _queue2).size < limit) {
+      return;
+    }
+    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "next", () => __privateGet(this, _queue2).size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (__privateGet(this, _pending) === 0 && __privateGet(this, _queue2).size === 0) {
+      return;
+    }
+    await __privateMethod(this, _PQueue_instances, onEvent_fn).call(this, "idle");
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return __privateGet(this, _queue2).size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return __privateGet(this, _queue2).filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return __privateGet(this, _pending);
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return __privateGet(this, _isPaused);
+  }
+};
+_carryoverConcurrencyCount = new WeakMap();
+_isIntervalIgnored = new WeakMap();
+_intervalCount = new WeakMap();
+_intervalCap = new WeakMap();
+_interval = new WeakMap();
+_intervalEnd = new WeakMap();
+_intervalId = new WeakMap();
+_timeoutId = new WeakMap();
+_queue2 = new WeakMap();
+_queueClass = new WeakMap();
+_pending = new WeakMap();
+_concurrency = new WeakMap();
+_isPaused = new WeakMap();
+_throwOnTimeout = new WeakMap();
+_PQueue_instances = new WeakSet();
+doesIntervalAllowAnother_get = function() {
+  return __privateGet(this, _isIntervalIgnored) || __privateGet(this, _intervalCount) < __privateGet(this, _intervalCap);
+};
+doesConcurrentAllowAnother_get = function() {
+  return __privateGet(this, _pending) < __privateGet(this, _concurrency);
+};
+next_fn = function() {
+  __privateWrapper(this, _pending)._--;
+  __privateMethod(this, _PQueue_instances, tryToStartAnother_fn).call(this);
+  this.emit("next");
+};
+onResumeInterval_fn = function() {
+  __privateMethod(this, _PQueue_instances, onInterval_fn).call(this);
+  __privateMethod(this, _PQueue_instances, initializeIntervalIfNeeded_fn).call(this);
+  __privateSet(this, _timeoutId, void 0);
+};
+isIntervalPaused_get = function() {
+  const now = Date.now();
+  if (__privateGet(this, _intervalId) === void 0) {
+    const delay = __privateGet(this, _intervalEnd) - now;
+    if (delay < 0) {
+      __privateSet(this, _intervalCount, __privateGet(this, _carryoverConcurrencyCount) ? __privateGet(this, _pending) : 0);
+    } else {
+      if (__privateGet(this, _timeoutId) === void 0) {
+        __privateSet(this, _timeoutId, setTimeout(() => {
+          __privateMethod(this, _PQueue_instances, onResumeInterval_fn).call(this);
+        }, delay));
+      }
+      return true;
+    }
+  }
+  return false;
+};
+tryToStartAnother_fn = function() {
+  if (__privateGet(this, _queue2).size === 0) {
+    if (__privateGet(this, _intervalId)) {
+      clearInterval(__privateGet(this, _intervalId));
+    }
+    __privateSet(this, _intervalId, void 0);
+    this.emit("empty");
+    if (__privateGet(this, _pending) === 0) {
+      this.emit("idle");
+    }
+    return false;
+  }
+  if (!__privateGet(this, _isPaused)) {
+    const canInitializeInterval = !__privateGet(this, _PQueue_instances, isIntervalPaused_get);
+    if (__privateGet(this, _PQueue_instances, doesIntervalAllowAnother_get) && __privateGet(this, _PQueue_instances, doesConcurrentAllowAnother_get)) {
+      const job = __privateGet(this, _queue2).dequeue();
+      if (!job) {
+        return false;
+      }
+      this.emit("active");
+      job();
+      if (canInitializeInterval) {
+        __privateMethod(this, _PQueue_instances, initializeIntervalIfNeeded_fn).call(this);
+      }
+      return true;
+    }
+  }
+  return false;
+};
+initializeIntervalIfNeeded_fn = function() {
+  if (__privateGet(this, _isIntervalIgnored) || __privateGet(this, _intervalId) !== void 0) {
+    return;
+  }
+  __privateSet(this, _intervalId, setInterval(() => {
+    __privateMethod(this, _PQueue_instances, onInterval_fn).call(this);
+  }, __privateGet(this, _interval)));
+  __privateSet(this, _intervalEnd, Date.now() + __privateGet(this, _interval));
+};
+onInterval_fn = function() {
+  if (__privateGet(this, _intervalCount) === 0 && __privateGet(this, _pending) === 0 && __privateGet(this, _intervalId)) {
+    clearInterval(__privateGet(this, _intervalId));
+    __privateSet(this, _intervalId, void 0);
+  }
+  __privateSet(this, _intervalCount, __privateGet(this, _carryoverConcurrencyCount) ? __privateGet(this, _pending) : 0);
+  __privateMethod(this, _PQueue_instances, processQueue_fn).call(this);
+};
+/**
+Executes all queued functions until it reaches the limit.
+*/
+processQueue_fn = function() {
+  while (__privateMethod(this, _PQueue_instances, tryToStartAnother_fn).call(this)) {
+  }
+};
+throwOnAbort_fn = async function(signal) {
+  return new Promise((_resolve, reject) => {
+    signal.addEventListener("abort", () => {
+      reject(signal.reason);
+    }, { once: true });
+  });
+};
+onEvent_fn = async function(event, filter) {
+  return new Promise((resolve) => {
+    const listener = () => {
+      if (filter && !filter()) {
+        return;
+      }
+      this.off(event, listener);
+      resolve();
+    };
+    this.on(event, listener);
+  });
+};
 var getBN = (value, decimals) => {
   const decimalPart = value - Math.trunc(value);
   const integerPart = new BN__default.default(Math.trunc(value));
@@ -93,6 +764,423 @@ function multiplyBigIntByNumber(x, y, scaleDigits = 9) {
   return isNegative ? -product : product;
 }
 
+// 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);
+};
+function assertHasPublicKey(value, message) {
+  invariant(value.publicKey, message ?? "publicKey is missing");
+}
+
+// solana/utils.ts
+var SIMULATE_TRIES = 3;
+var buildSendThrottler = (sendRate, sendInterval = 1e3) => {
+  return new PQueue({ concurrency: sendRate, intervalCap: 1, interval: sendInterval });
+};
+async function getProgramAccounts(connection, wallet, offset, programId) {
+  const programAccounts = await connection?.getProgramAccounts(programId, {
+    filters: [
+      {
+        memcmp: {
+          offset,
+          bytes: wallet.toBase58()
+        }
+      }
+    ]
+  });
+  return [...programAccounts];
+}
+function isSignerWallet(walletOrKeypair) {
+  return walletOrKeypair.signTransaction !== void 0;
+}
+function isSignerKeypair(walletOrKeypair) {
+  return walletOrKeypair instanceof web3_js.Keypair || walletOrKeypair.constructor === web3_js.Keypair || walletOrKeypair.constructor.name === web3_js.Keypair.prototype.constructor.name;
+}
+function isTransactionVersioned(tx) {
+  return "message" in tx;
+}
+async function prepareTransaction(connection, ixs, payer, commitment, partialSigners, lookupTables) {
+  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, lookupTables),
+    hash,
+    context
+  };
+}
+function createVersionedTransaction(ixs, payer, recentBlockhash, partialSigners, lookupTables) {
+  invariant(payer, "Payer public key is not provided!");
+  const messageV0 = new web3_js.TransactionMessage({
+    payerKey: payer,
+    recentBlockhash,
+    instructions: ixs
+  }).compileToV0Message(lookupTables);
+  const tx = new web3_js.VersionedTransaction(messageV0);
+  const signers = partialSigners?.filter((item) => !!item) ?? void 0;
+  if (signers) {
+    tx.sign(signers);
+  }
+  return tx;
+}
+async function signTransaction(invoker, tx) {
+  let signedTx;
+  if (isSignerWallet(invoker)) {
+    signedTx = await invoker.signTransaction(tx);
+  } else {
+    if (isTransactionVersioned(tx)) {
+      tx.sign([invoker]);
+    } else {
+      tx.partialSign(invoker);
+    }
+    signedTx = tx;
+  }
+  return signedTx;
+}
+async function signAndExecuteTransaction(connection, invoker, tx, confirmationParams, transactionExecutionParams) {
+  const signedTx = await signTransaction(invoker, tx);
+  return executeTransaction(connection, signedTx, confirmationParams, transactionExecutionParams);
+}
+async function executeTransaction(connection, tx, confirmationParams, transactionExecutionParams) {
+  if (tx.signatures.length === 0) {
+    throw Error("Error with transaction parameters.");
+  }
+  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) {
+    sendThrottler = buildSendThrottler(sendRate);
+  }
+  return Promise.allSettled(
+    txs.map(
+      (tx) => executeTransaction(connection, tx, confirmationParams, {
+        ...throttlingParams,
+        sendRate,
+        sendThrottler
+      })
+    )
+  );
+}
+async function sendAndConfirmTransaction(connection, tx, { hash, context, commitment }, { sendRate = 1, sendThrottler, waitBeforeConfirming }) {
+  const isVersioned = isTransactionVersioned(tx);
+  let signature;
+  if (isVersioned) {
+    signature = bs58__default.default.encode(tx.signatures[0]);
+  } else {
+    signature = bs58__default.default.encode(tx.signature);
+  }
+  if (!sendThrottler) {
+    sendThrottler = buildSendThrottler(sendRate);
+  }
+  let blockheight = await connection.getBlockHeight(commitment);
+  let transactionSent = false;
+  const rawTransaction = tx.serialize();
+  while (blockheight < hash.lastValidBlockHeight + 15) {
+    try {
+      if (blockheight < hash.lastValidBlockHeight || !transactionSent) {
+        await sendThrottler.add(
+          async () => connection.sendRawTransaction(rawTransaction, {
+            maxRetries: 0,
+            minContextSlot: context.slot,
+            preflightCommitment: commitment,
+            skipPreflight: true
+          })
+        );
+        transactionSent = true;
+      }
+    } catch (e) {
+      if (transactionSent || e instanceof web3_js.SendTransactionError && e.message.includes("Minimum context slot has not been reached")) {
+        await sleep(500);
+        continue;
+      }
+      throw e;
+    }
+    await sleep(waitBeforeConfirming ?? 2e3);
+    try {
+      const value = await confirmAndEnsureTransaction(connection, signature);
+      if (value) {
+        return signature;
+      }
+    } catch (e) {
+      if (e instanceof TransactionFailedError) {
+        throw e;
+      }
+      await sleep(500);
+    }
+    try {
+      blockheight = await connection.getBlockHeight(commitment);
+    } catch (_e) {
+      await sleep(500);
+    }
+  }
+  throw new Error(`Transaction ${signature} expired.`);
+}
+async function simulateTransaction(connection, tx) {
+  let res;
+  for (let i = 0; i < SIMULATE_TRIES; i++) {
+    if (isTransactionVersioned(tx)) {
+      res = await connection.simulateTransaction(tx);
+    } else {
+      res = await connection.simulateTransaction(tx);
+    }
+    if (res.value.err) {
+      const errMessage = JSON.stringify(res.value.err);
+      if (!errMessage.includes("BlockhashNotFound") || i === SIMULATE_TRIES - 1) {
+        throw new web3_js.SendTransactionError({
+          action: "simulate",
+          signature: "",
+          transactionMessage: `failed to simulate transaction: ${typeof res.value.err === "string" ? res.value.err : errMessage}`,
+          logs: res.value.logs ?? void 0
+        });
+      }
+      continue;
+    }
+    return res;
+  }
+  throw new web3_js.SendTransactionError({
+    action: "simulate",
+    signature: "",
+    transactionMessage: "failed to simulate transaction"
+  });
+}
+async function confirmAndEnsureTransaction(connection, signature, ignoreError) {
+  const response = await connection.getSignatureStatuses([signature]);
+  if (!response || response.value.length === 0 || response.value[0] === null) {
+    return null;
+  }
+  const value = response.value[0];
+  if (!value) {
+    return null;
+  }
+  if (!ignoreError && value.err) {
+    throw new TransactionFailedError(`Raw transaction ${signature} failed (${JSON.stringify({ err: value.err })})`);
+  }
+  switch (connection.commitment) {
+    case "confirmed":
+    case "single":
+    case "singleGossip": {
+      if (value.confirmationStatus === "processed") {
+        return null;
+      }
+      break;
+    }
+    case "finalized":
+    case "max":
+    case "root": {
+      if (value.confirmationStatus === "processed" || value.confirmationStatus === "confirmed") {
+        return null;
+      }
+      break;
+    }
+  }
+  return value;
+}
+function ata(mint, owner, programId) {
+  return splToken.getAssociatedTokenAddress(mint, owner, true, programId);
+}
+async function ataBatchExist(connection, paramsBatch) {
+  const tokenAccounts = await Promise.all(
+    paramsBatch.map(async ({ mint, owner, programId }) => {
+      return ata(mint, owner, programId);
+    })
+  );
+  const response = await connection.getMultipleAccountsInfo(tokenAccounts);
+  return response.map((accInfo) => !!accInfo);
+}
+async function enrichAtaParams(connection, paramsBatch) {
+  const programIdByMint = {};
+  return Promise.all(
+    paramsBatch.map(async (params) => {
+      if (params.programId) {
+        return params;
+      }
+      const mintStr = params.mint.toString();
+      if (!(mintStr in programIdByMint)) {
+        const { tokenProgramId } = await getMintAndProgram(connection, params.mint);
+        programIdByMint[mintStr] = tokenProgramId;
+      }
+      params.programId = programIdByMint[mintStr];
+      return params;
+    })
+  );
+}
+async function generateCreateAtaBatchTx(connection, payer, paramsBatch, commitment) {
+  paramsBatch = await enrichAtaParams(connection, paramsBatch);
+  const ixs = await Promise.all(
+    paramsBatch.map(async ({ mint, owner, programId }) => {
+      return splToken.createAssociatedTokenAccountInstruction(payer, await ata(mint, owner), owner, mint, programId);
+    })
+  );
+  const { value: hash, context } = await connection.getLatestBlockhashAndContext({ commitment });
+  return { tx: createVersionedTransaction(ixs, payer, hash.blockhash), hash, context };
+}
+async function createAtaBatch(connection, invoker, paramsBatch, commitment, rate) {
+  const { tx, hash, context } = await generateCreateAtaBatchTx(
+    connection,
+    invoker.publicKey,
+    await enrichAtaParams(connection, paramsBatch),
+    commitment
+  );
+  return signAndExecuteTransaction(connection, invoker, tx, { hash, context, commitment }, { sendRate: rate });
+}
+async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programId, payer) {
+  assertHasPublicKey(invoker, "Invoker's PublicKey is not available, check passed wallet adapter!");
+  const ixs = [];
+  if (!programId) {
+    programId = (await getMintAndProgram(connection, mint)).tokenProgramId;
+  }
+  const atas = [];
+  for (const owner of owners) {
+    atas.push(await ata(mint, owner, programId));
+  }
+  const response = await connection.getMultipleAccountsInfo(atas);
+  for (let i = 0; i < response.length; i++) {
+    if (!response[i]) {
+      ixs.push(
+        splToken.createAssociatedTokenAccountInstruction(payer ?? invoker.publicKey, atas[i], owners[i], mint, programId)
+      );
+    }
+  }
+  return ixs;
+}
+function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
+  const ixs = [];
+  if (computePrice && typeof computePrice !== "function") {
+    ixs.push(web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: computePrice }));
+  }
+  if (computeLimit && typeof computeLimit === "number") {
+    ixs.push(web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }));
+  }
+  return ixs;
+}
+async function getMintAndProgram(connection, address, commitment) {
+  const accountInfo = await connection.getAccountInfo(address, commitment);
+  let programId = accountInfo?.owner;
+  if (!programId?.equals(splToken.TOKEN_PROGRAM_ID) && !programId?.equals(splToken.TOKEN_2022_PROGRAM_ID)) {
+    programId = splToken.TOKEN_PROGRAM_ID;
+  }
+  return {
+    mint: splToken.unpackMint(address, accountInfo, programId),
+    tokenProgramId: programId
+  };
+}
+async function getMultipleAccountsInfoBatched(connection, pubKeys, commitment) {
+  const batchSize = 99;
+  const batches = [];
+  for (let i = 0; i < pubKeys.length; i += batchSize) {
+    const batch = pubKeys.slice(i, i + batchSize);
+    batches.push(connection.getMultipleAccountsInfo(batch, commitment));
+  }
+  const results = await Promise.all(batches);
+  return results.flat();
+}
+function deserializeRawTransaction(serializedTx) {
+  const txBuffer = buffer.Buffer.from(serializedTx, "base64");
+  try {
+    const tx = web3_js.Transaction.from(txBuffer);
+    return resolveTransactionAccounts(tx);
+  } catch (error) {
+    try {
+      const vtx = web3_js.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 web3_js.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 web3_js.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" };
+};
+
 // lib/fetch-token-price.ts
 var fetchTokenPrice = async (mintId, cluster = "mainnet" /* Mainnet */, options) => {
   const url = `https://token-api.streamflow.finance/price?ids=${encodeURIComponent(mintId)}&cluster=${encodeURIComponent(cluster)}`;
@@ -116,16 +1204,47 @@ var fetchTokenPrice = async (mintId, cluster = "mainnet" /* Mainnet */, options)
 };
 
 exports.ContractError = ContractError;
-exports.IChain = IChain;
 exports.ICluster = ICluster;
+exports.TransactionFailedError = TransactionFailedError;
 exports.assertHasPublicKey = assertHasPublicKey;
+exports.ata = ata;
+exports.ataBatchExist = ataBatchExist;
+exports.buildSendThrottler = buildSendThrottler;
+exports.checkOrCreateAtaBatch = checkOrCreateAtaBatch;
+exports.confirmAndEnsureTransaction = confirmAndEnsureTransaction;
+exports.createAndEstimateTransaction = createAndEstimateTransaction;
+exports.createAtaBatch = createAtaBatch;
+exports.createVersionedTransaction = createVersionedTransaction;
+exports.deserializeRawTransaction = deserializeRawTransaction;
 exports.divCeilN = divCeilN;
+exports.enrichAtaParams = enrichAtaParams;
+exports.estimateComputeUnitPrice = estimateComputeUnitPrice;
+exports.executeMultipleTransactions = executeMultipleTransactions;
+exports.executeTransaction = executeTransaction;
 exports.fetchTokenPrice = fetchTokenPrice;
+exports.generateCreateAtaBatchTx = generateCreateAtaBatchTx;
 exports.getBN = getBN;
+exports.getFilters = getFilters;
+exports.getMintAndProgram = getMintAndProgram;
+exports.getMultipleAccountsInfoBatched = getMultipleAccountsInfoBatched;
 exports.getNumberFromBN = getNumberFromBN;
+exports.getProgramAccounts = getProgramAccounts;
 exports.handleContractError = handleContractError;
 exports.invariant = invariant;
+exports.isSignerKeypair = isSignerKeypair;
+exports.isSignerWallet = isSignerWallet;
+exports.isTransactionVersioned = isTransactionVersioned;
 exports.multiplyBigIntByNumber = multiplyBigIntByNumber;
+exports.pk = pk;
+exports.prepareBaseInstructions = prepareBaseInstructions;
+exports.prepareTransaction = prepareTransaction;
+exports.prepareWrappedAccount = prepareWrappedAccount;
+exports.resolveTransactionAccounts = resolveTransactionAccounts;
+exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
+exports.signAndExecuteTransaction = signAndExecuteTransaction;
+exports.signTransaction = signTransaction;
+exports.simulateTransaction = simulateTransaction;
 exports.sleep = sleep;
+exports.unwrapExecutionParams = unwrapExecutionParams;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map