@debridge-finance/solana-utils 6.0.0 → 6.1.0

package/dist/browser/index.js

@@ -2,6 +2,10 @@ import require$$1, { MessageV0, VersionedTransaction, Transaction, PublicKey, Tr
 
 var commonjsGlobal$1 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+function getDefaultExportFromCjs$1 (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 function getAugmentedNamespace(n) {
   var f = n.default;
 	if (typeof f == "function") {
@@ -11343,6 +11347,1595 @@ struct$1([
     publicKey$4('delegate'),
 ]);
 
+var nodeCache = {exports: {}};
+
+var node_cache = {exports: {}};
+
+var clone = {exports: {}};
+
+var hasRequiredClone;
+
+function requireClone () {
+	if (hasRequiredClone) return clone.exports;
+	hasRequiredClone = 1;
+	(function (module) {
+		var clone = (function() {
+
+		function _instanceof(obj, type) {
+		  return type != null && obj instanceof type;
+		}
+
+		var nativeMap;
+		try {
+		  nativeMap = Map;
+		} catch(_) {
+		  // maybe a reference error because no `Map`. Give it a dummy value that no
+		  // value will ever be an instanceof.
+		  nativeMap = function() {};
+		}
+
+		var nativeSet;
+		try {
+		  nativeSet = Set;
+		} catch(_) {
+		  nativeSet = function() {};
+		}
+
+		var nativePromise;
+		try {
+		  nativePromise = Promise;
+		} catch(_) {
+		  nativePromise = function() {};
+		}
+
+		/**
+		 * Clones (copies) an Object using deep copying.
+		 *
+		 * This function supports circular references by default, but if you are certain
+		 * there are no circular references in your object, you can save some CPU time
+		 * by calling clone(obj, false).
+		 *
+		 * Caution: if `circular` is false and `parent` contains circular references,
+		 * your program may enter an infinite loop and crash.
+		 *
+		 * @param `parent` - the object to be cloned
+		 * @param `circular` - set to true if the object to be cloned may contain
+		 *    circular references. (optional - true by default)
+		 * @param `depth` - set to a number if the object is only to be cloned to
+		 *    a particular depth. (optional - defaults to Infinity)
+		 * @param `prototype` - sets the prototype to be used when cloning an object.
+		 *    (optional - defaults to parent prototype).
+		 * @param `includeNonEnumerable` - set to true if the non-enumerable properties
+		 *    should be cloned as well. Non-enumerable properties on the prototype
+		 *    chain will be ignored. (optional - false by default)
+		*/
+		function clone(parent, circular, depth, prototype, includeNonEnumerable) {
+		  if (typeof circular === 'object') {
+		    depth = circular.depth;
+		    prototype = circular.prototype;
+		    includeNonEnumerable = circular.includeNonEnumerable;
+		    circular = circular.circular;
+		  }
+		  // maintain two arrays for circular references, where corresponding parents
+		  // and children have the same index
+		  var allParents = [];
+		  var allChildren = [];
+
+		  var useBuffer = typeof Buffer != 'undefined';
+
+		  if (typeof circular == 'undefined')
+		    circular = true;
+
+		  if (typeof depth == 'undefined')
+		    depth = Infinity;
+
+		  // recurse this function so we don't reset allParents and allChildren
+		  function _clone(parent, depth) {
+		    // cloning null always returns null
+		    if (parent === null)
+		      return null;
+
+		    if (depth === 0)
+		      return parent;
+
+		    var child;
+		    var proto;
+		    if (typeof parent != 'object') {
+		      return parent;
+		    }
+
+		    if (_instanceof(parent, nativeMap)) {
+		      child = new nativeMap();
+		    } else if (_instanceof(parent, nativeSet)) {
+		      child = new nativeSet();
+		    } else if (_instanceof(parent, nativePromise)) {
+		      child = new nativePromise(function (resolve, reject) {
+		        parent.then(function(value) {
+		          resolve(_clone(value, depth - 1));
+		        }, function(err) {
+		          reject(_clone(err, depth - 1));
+		        });
+		      });
+		    } else if (clone.__isArray(parent)) {
+		      child = [];
+		    } else if (clone.__isRegExp(parent)) {
+		      child = new RegExp(parent.source, __getRegExpFlags(parent));
+		      if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+		    } else if (clone.__isDate(parent)) {
+		      child = new Date(parent.getTime());
+		    } else if (useBuffer && Buffer.isBuffer(parent)) {
+		      if (Buffer.allocUnsafe) {
+		        // Node.js >= 4.5.0
+		        child = Buffer.allocUnsafe(parent.length);
+		      } else {
+		        // Older Node.js versions
+		        child = new Buffer(parent.length);
+		      }
+		      parent.copy(child);
+		      return child;
+		    } else if (_instanceof(parent, Error)) {
+		      child = Object.create(parent);
+		    } else {
+		      if (typeof prototype == 'undefined') {
+		        proto = Object.getPrototypeOf(parent);
+		        child = Object.create(proto);
+		      }
+		      else {
+		        child = Object.create(prototype);
+		        proto = prototype;
+		      }
+		    }
+
+		    if (circular) {
+		      var index = allParents.indexOf(parent);
+
+		      if (index != -1) {
+		        return allChildren[index];
+		      }
+		      allParents.push(parent);
+		      allChildren.push(child);
+		    }
+
+		    if (_instanceof(parent, nativeMap)) {
+		      parent.forEach(function(value, key) {
+		        var keyChild = _clone(key, depth - 1);
+		        var valueChild = _clone(value, depth - 1);
+		        child.set(keyChild, valueChild);
+		      });
+		    }
+		    if (_instanceof(parent, nativeSet)) {
+		      parent.forEach(function(value) {
+		        var entryChild = _clone(value, depth - 1);
+		        child.add(entryChild);
+		      });
+		    }
+
+		    for (var i in parent) {
+		      var attrs;
+		      if (proto) {
+		        attrs = Object.getOwnPropertyDescriptor(proto, i);
+		      }
+
+		      if (attrs && attrs.set == null) {
+		        continue;
+		      }
+		      child[i] = _clone(parent[i], depth - 1);
+		    }
+
+		    if (Object.getOwnPropertySymbols) {
+		      var symbols = Object.getOwnPropertySymbols(parent);
+		      for (var i = 0; i < symbols.length; i++) {
+		        // Don't need to worry about cloning a symbol because it is a primitive,
+		        // like a number or string.
+		        var symbol = symbols[i];
+		        var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+		        if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+		          continue;
+		        }
+		        child[symbol] = _clone(parent[symbol], depth - 1);
+		        if (!descriptor.enumerable) {
+		          Object.defineProperty(child, symbol, {
+		            enumerable: false
+		          });
+		        }
+		      }
+		    }
+
+		    if (includeNonEnumerable) {
+		      var allPropertyNames = Object.getOwnPropertyNames(parent);
+		      for (var i = 0; i < allPropertyNames.length; i++) {
+		        var propertyName = allPropertyNames[i];
+		        var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);
+		        if (descriptor && descriptor.enumerable) {
+		          continue;
+		        }
+		        child[propertyName] = _clone(parent[propertyName], depth - 1);
+		        Object.defineProperty(child, propertyName, {
+		          enumerable: false
+		        });
+		      }
+		    }
+
+		    return child;
+		  }
+
+		  return _clone(parent, depth);
+		}
+
+		/**
+		 * Simple flat clone using prototype, accepts only objects, usefull for property
+		 * override on FLAT configuration object (no nested props).
+		 *
+		 * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+		 * works.
+		 */
+		clone.clonePrototype = function clonePrototype(parent) {
+		  if (parent === null)
+		    return null;
+
+		  var c = function () {};
+		  c.prototype = parent;
+		  return new c();
+		};
+
+		// private utility functions
+
+		function __objToStr(o) {
+		  return Object.prototype.toString.call(o);
+		}
+		clone.__objToStr = __objToStr;
+
+		function __isDate(o) {
+		  return typeof o === 'object' && __objToStr(o) === '[object Date]';
+		}
+		clone.__isDate = __isDate;
+
+		function __isArray(o) {
+		  return typeof o === 'object' && __objToStr(o) === '[object Array]';
+		}
+		clone.__isArray = __isArray;
+
+		function __isRegExp(o) {
+		  return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
+		}
+		clone.__isRegExp = __isRegExp;
+
+		function __getRegExpFlags(re) {
+		  var flags = '';
+		  if (re.global) flags += 'g';
+		  if (re.ignoreCase) flags += 'i';
+		  if (re.multiline) flags += 'm';
+		  return flags;
+		}
+		clone.__getRegExpFlags = __getRegExpFlags;
+
+		return clone;
+		})();
+
+		if (module.exports) {
+		  module.exports = clone;
+		}
+} (clone));
+	return clone.exports;
+}
+
+var events = {exports: {}};
+
+var hasRequiredEvents;
+
+function requireEvents () {
+	if (hasRequiredEvents) return events.exports;
+	hasRequiredEvents = 1;
+
+	var R = typeof Reflect === 'object' ? Reflect : null;
+	var ReflectApply = R && typeof R.apply === 'function'
+	  ? R.apply
+	  : function ReflectApply(target, receiver, args) {
+	    return Function.prototype.apply.call(target, receiver, args);
+	  };
+
+	var ReflectOwnKeys;
+	if (R && typeof R.ownKeys === 'function') {
+	  ReflectOwnKeys = R.ownKeys;
+	} else if (Object.getOwnPropertySymbols) {
+	  ReflectOwnKeys = function ReflectOwnKeys(target) {
+	    return Object.getOwnPropertyNames(target)
+	      .concat(Object.getOwnPropertySymbols(target));
+	  };
+	} else {
+	  ReflectOwnKeys = function ReflectOwnKeys(target) {
+	    return Object.getOwnPropertyNames(target);
+	  };
+	}
+
+	function ProcessEmitWarning(warning) {
+	  if (console && console.warn) console.warn(warning);
+	}
+
+	var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+	  return value !== value;
+	};
+
+	function EventEmitter() {
+	  EventEmitter.init.call(this);
+	}
+	events.exports = EventEmitter;
+	events.exports.once = once;
+
+	// Backwards-compat with node 0.10.x
+	EventEmitter.EventEmitter = EventEmitter;
+
+	EventEmitter.prototype._events = undefined;
+	EventEmitter.prototype._eventsCount = 0;
+	EventEmitter.prototype._maxListeners = undefined;
+
+	// By default EventEmitters will print a warning if more than 10 listeners are
+	// added to it. This is a useful default which helps finding memory leaks.
+	var defaultMaxListeners = 10;
+
+	function checkListener(listener) {
+	  if (typeof listener !== 'function') {
+	    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+	  }
+	}
+
+	Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+	  enumerable: true,
+	  get: function() {
+	    return defaultMaxListeners;
+	  },
+	  set: function(arg) {
+	    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+	      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+	    }
+	    defaultMaxListeners = arg;
+	  }
+	});
+
+	EventEmitter.init = function() {
+
+	  if (this._events === undefined ||
+	      this._events === Object.getPrototypeOf(this)._events) {
+	    this._events = Object.create(null);
+	    this._eventsCount = 0;
+	  }
+
+	  this._maxListeners = this._maxListeners || undefined;
+	};
+
+	// Obviously not all Emitters should be limited to 10. This function allows
+	// that to be increased. Set to zero for unlimited.
+	EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+	  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+	    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+	  }
+	  this._maxListeners = n;
+	  return this;
+	};
+
+	function _getMaxListeners(that) {
+	  if (that._maxListeners === undefined)
+	    return EventEmitter.defaultMaxListeners;
+	  return that._maxListeners;
+	}
+
+	EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+	  return _getMaxListeners(this);
+	};
+
+	EventEmitter.prototype.emit = function emit(type) {
+	  var args = [];
+	  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+	  var doError = (type === 'error');
+
+	  var events = this._events;
+	  if (events !== undefined)
+	    doError = (doError && events.error === undefined);
+	  else if (!doError)
+	    return false;
+
+	  // If there is no 'error' event listener then throw.
+	  if (doError) {
+	    var er;
+	    if (args.length > 0)
+	      er = args[0];
+	    if (er instanceof Error) {
+	      // Note: The comments on the `throw` lines are intentional, they show
+	      // up in Node's output if this results in an unhandled exception.
+	      throw er; // Unhandled 'error' event
+	    }
+	    // At least give some kind of context to the user
+	    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+	    err.context = er;
+	    throw err; // Unhandled 'error' event
+	  }
+
+	  var handler = events[type];
+
+	  if (handler === undefined)
+	    return false;
+
+	  if (typeof handler === 'function') {
+	    ReflectApply(handler, this, args);
+	  } else {
+	    var len = handler.length;
+	    var listeners = arrayClone(handler, len);
+	    for (var i = 0; i < len; ++i)
+	      ReflectApply(listeners[i], this, args);
+	  }
+
+	  return true;
+	};
+
+	function _addListener(target, type, listener, prepend) {
+	  var m;
+	  var events;
+	  var existing;
+
+	  checkListener(listener);
+
+	  events = target._events;
+	  if (events === undefined) {
+	    events = target._events = Object.create(null);
+	    target._eventsCount = 0;
+	  } else {
+	    // To avoid recursion in the case that type === "newListener"! Before
+	    // adding it to the listeners, first emit "newListener".
+	    if (events.newListener !== undefined) {
+	      target.emit('newListener', type,
+	                  listener.listener ? listener.listener : listener);
+
+	      // Re-assign `events` because a newListener handler could have caused the
+	      // this._events to be assigned to a new object
+	      events = target._events;
+	    }
+	    existing = events[type];
+	  }
+
+	  if (existing === undefined) {
+	    // Optimize the case of one listener. Don't need the extra array object.
+	    existing = events[type] = listener;
+	    ++target._eventsCount;
+	  } else {
+	    if (typeof existing === 'function') {
+	      // Adding the second element, need to change to array.
+	      existing = events[type] =
+	        prepend ? [listener, existing] : [existing, listener];
+	      // If we've already got an array, just append.
+	    } else if (prepend) {
+	      existing.unshift(listener);
+	    } else {
+	      existing.push(listener);
+	    }
+
+	    // Check for listener leak
+	    m = _getMaxListeners(target);
+	    if (m > 0 && existing.length > m && !existing.warned) {
+	      existing.warned = true;
+	      // No error code for this since it is a Warning
+	      // eslint-disable-next-line no-restricted-syntax
+	      var w = new Error('Possible EventEmitter memory leak detected. ' +
+	                          existing.length + ' ' + String(type) + ' listeners ' +
+	                          'added. Use emitter.setMaxListeners() to ' +
+	                          'increase limit');
+	      w.name = 'MaxListenersExceededWarning';
+	      w.emitter = target;
+	      w.type = type;
+	      w.count = existing.length;
+	      ProcessEmitWarning(w);
+	    }
+	  }
+
+	  return target;
+	}
+
+	EventEmitter.prototype.addListener = function addListener(type, listener) {
+	  return _addListener(this, type, listener, false);
+	};
+
+	EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+	EventEmitter.prototype.prependListener =
+	    function prependListener(type, listener) {
+	      return _addListener(this, type, listener, true);
+	    };
+
+	function onceWrapper() {
+	  if (!this.fired) {
+	    this.target.removeListener(this.type, this.wrapFn);
+	    this.fired = true;
+	    if (arguments.length === 0)
+	      return this.listener.call(this.target);
+	    return this.listener.apply(this.target, arguments);
+	  }
+	}
+
+	function _onceWrap(target, type, listener) {
+	  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+	  var wrapped = onceWrapper.bind(state);
+	  wrapped.listener = listener;
+	  state.wrapFn = wrapped;
+	  return wrapped;
+	}
+
+	EventEmitter.prototype.once = function once(type, listener) {
+	  checkListener(listener);
+	  this.on(type, _onceWrap(this, type, listener));
+	  return this;
+	};
+
+	EventEmitter.prototype.prependOnceListener =
+	    function prependOnceListener(type, listener) {
+	      checkListener(listener);
+	      this.prependListener(type, _onceWrap(this, type, listener));
+	      return this;
+	    };
+
+	// Emits a 'removeListener' event if and only if the listener was removed.
+	EventEmitter.prototype.removeListener =
+	    function removeListener(type, listener) {
+	      var list, events, position, i, originalListener;
+
+	      checkListener(listener);
+
+	      events = this._events;
+	      if (events === undefined)
+	        return this;
+
+	      list = events[type];
+	      if (list === undefined)
+	        return this;
+
+	      if (list === listener || list.listener === listener) {
+	        if (--this._eventsCount === 0)
+	          this._events = Object.create(null);
+	        else {
+	          delete events[type];
+	          if (events.removeListener)
+	            this.emit('removeListener', type, list.listener || listener);
+	        }
+	      } else if (typeof list !== 'function') {
+	        position = -1;
+
+	        for (i = list.length - 1; i >= 0; i--) {
+	          if (list[i] === listener || list[i].listener === listener) {
+	            originalListener = list[i].listener;
+	            position = i;
+	            break;
+	          }
+	        }
+
+	        if (position < 0)
+	          return this;
+
+	        if (position === 0)
+	          list.shift();
+	        else {
+	          spliceOne(list, position);
+	        }
+
+	        if (list.length === 1)
+	          events[type] = list[0];
+
+	        if (events.removeListener !== undefined)
+	          this.emit('removeListener', type, originalListener || listener);
+	      }
+
+	      return this;
+	    };
+
+	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+	EventEmitter.prototype.removeAllListeners =
+	    function removeAllListeners(type) {
+	      var listeners, events, i;
+
+	      events = this._events;
+	      if (events === undefined)
+	        return this;
+
+	      // not listening for removeListener, no need to emit
+	      if (events.removeListener === undefined) {
+	        if (arguments.length === 0) {
+	          this._events = Object.create(null);
+	          this._eventsCount = 0;
+	        } else if (events[type] !== undefined) {
+	          if (--this._eventsCount === 0)
+	            this._events = Object.create(null);
+	          else
+	            delete events[type];
+	        }
+	        return this;
+	      }
+
+	      // emit removeListener for all listeners on all events
+	      if (arguments.length === 0) {
+	        var keys = Object.keys(events);
+	        var key;
+	        for (i = 0; i < keys.length; ++i) {
+	          key = keys[i];
+	          if (key === 'removeListener') continue;
+	          this.removeAllListeners(key);
+	        }
+	        this.removeAllListeners('removeListener');
+	        this._events = Object.create(null);
+	        this._eventsCount = 0;
+	        return this;
+	      }
+
+	      listeners = events[type];
+
+	      if (typeof listeners === 'function') {
+	        this.removeListener(type, listeners);
+	      } else if (listeners !== undefined) {
+	        // LIFO order
+	        for (i = listeners.length - 1; i >= 0; i--) {
+	          this.removeListener(type, listeners[i]);
+	        }
+	      }
+
+	      return this;
+	    };
+
+	function _listeners(target, type, unwrap) {
+	  var events = target._events;
+
+	  if (events === undefined)
+	    return [];
+
+	  var evlistener = events[type];
+	  if (evlistener === undefined)
+	    return [];
+
+	  if (typeof evlistener === 'function')
+	    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+	  return unwrap ?
+	    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+	}
+
+	EventEmitter.prototype.listeners = function listeners(type) {
+	  return _listeners(this, type, true);
+	};
+
+	EventEmitter.prototype.rawListeners = function rawListeners(type) {
+	  return _listeners(this, type, false);
+	};
+
+	EventEmitter.listenerCount = function(emitter, type) {
+	  if (typeof emitter.listenerCount === 'function') {
+	    return emitter.listenerCount(type);
+	  } else {
+	    return listenerCount.call(emitter, type);
+	  }
+	};
+
+	EventEmitter.prototype.listenerCount = listenerCount;
+	function listenerCount(type) {
+	  var events = this._events;
+
+	  if (events !== undefined) {
+	    var evlistener = events[type];
+
+	    if (typeof evlistener === 'function') {
+	      return 1;
+	    } else if (evlistener !== undefined) {
+	      return evlistener.length;
+	    }
+	  }
+
+	  return 0;
+	}
+
+	EventEmitter.prototype.eventNames = function eventNames() {
+	  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+	};
+
+	function arrayClone(arr, n) {
+	  var copy = new Array(n);
+	  for (var i = 0; i < n; ++i)
+	    copy[i] = arr[i];
+	  return copy;
+	}
+
+	function spliceOne(list, index) {
+	  for (; index + 1 < list.length; index++)
+	    list[index] = list[index + 1];
+	  list.pop();
+	}
+
+	function unwrapListeners(arr) {
+	  var ret = new Array(arr.length);
+	  for (var i = 0; i < ret.length; ++i) {
+	    ret[i] = arr[i].listener || arr[i];
+	  }
+	  return ret;
+	}
+
+	function once(emitter, name) {
+	  return new Promise(function (resolve, reject) {
+	    function errorListener(err) {
+	      emitter.removeListener(name, resolver);
+	      reject(err);
+	    }
+
+	    function resolver() {
+	      if (typeof emitter.removeListener === 'function') {
+	        emitter.removeListener('error', errorListener);
+	      }
+	      resolve([].slice.call(arguments));
+	    }
+	    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+	    if (name !== 'error') {
+	      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+	    }
+	  });
+	}
+
+	function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+	  if (typeof emitter.on === 'function') {
+	    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+	  }
+	}
+
+	function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+	  if (typeof emitter.on === 'function') {
+	    if (flags.once) {
+	      emitter.once(name, listener);
+	    } else {
+	      emitter.on(name, listener);
+	    }
+	  } else if (typeof emitter.addEventListener === 'function') {
+	    // EventTarget does not have `error` event semantics like Node
+	    // EventEmitters, we do not listen for `error` events here.
+	    emitter.addEventListener(name, function wrapListener(arg) {
+	      // IE does not have builtin `{ once: true }` support so we
+	      // have to do it manually.
+	      if (flags.once) {
+	        emitter.removeEventListener(name, wrapListener);
+	      }
+	      listener(arg);
+	    });
+	  } else {
+	    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+	  }
+	}
+	return events.exports;
+}
+
+/*
+ * node-cache 5.1.2 ( 2020-07-01 )
+ * https://github.com/node-cache/node-cache
+ *
+ * Released under the MIT license
+ * https://github.com/node-cache/node-cache/blob/master/LICENSE
+ *
+ * Maintained by  (  )
+*/
+
+var hasRequiredNode_cache;
+
+function requireNode_cache () {
+	if (hasRequiredNode_cache) return node_cache.exports;
+	hasRequiredNode_cache = 1;
+	(function() {
+	  var EventEmitter, clone,
+	    splice = [].splice,
+	    boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } },
+	    indexOf = [].indexOf;
+
+	  clone = requireClone();
+
+	  EventEmitter = requireEvents().EventEmitter;
+
+	  // generate superclass
+	  node_cache.exports = (function() {
+	    class NodeCache extends EventEmitter {
+	      constructor(options = {}) {
+	        super();
+	        // ## get
+
+	        // get a cached key and change the stats
+
+	        // **Parameters:**
+
+	        // * `key` ( String | Number ): cache key
+
+	        // **Example:**
+
+	        //	myCache.get "myKey", ( err, val )
+
+	        this.get = this.get.bind(this);
+	        // ## mget
+
+	        // get multiple cached keys at once and change the stats
+
+	        // **Parameters:**
+
+	        // * `keys` ( String|Number[] ): an array of keys
+
+	        // **Example:**
+
+	        //	myCache.mget [ "foo", "bar" ]
+
+	        this.mget = this.mget.bind(this);
+	        // ## set
+
+	        // set a cached key and change the stats
+
+	        // **Parameters:**
+
+	        // * `key` ( String | Number ): cache key
+	        // * `value` ( Any ): A element to cache. If the option `option.forceString` is `true` the module trys to translate it to a serialized JSON
+	        // * `[ ttl ]` ( Number | String ): ( optional ) The time to live in seconds.
+
+	        // **Example:**
+
+	        //	myCache.set "myKey", "my_String Value"
+
+	        //	myCache.set "myKey", "my_String Value", 10
+
+	        this.set = this.set.bind(this);
+	        
+	        // ## mset
+
+	        // set multiple keys at once
+
+	        // **Parameters:**
+
+	        // * `keyValueSet` ( Object[] ): an array of object which includes key,value and ttl
+
+	        // **Example:**
+
+	        //	myCache.mset(
+	        //		[
+	        //			{
+	        //				key: "myKey",
+	        //				val: "myValue",
+	        //				ttl: [ttl in seconds]
+	        //			}
+	        //		])
+
+	        this.mset = this.mset.bind(this);
+	        // ## del
+
+	        // remove keys
+
+	        // **Parameters:**
+
+	        // * `keys` ( String | Number | String|Number[] ): cache key to delete or a array of cache keys
+
+	        // **Return**
+
+	        // ( Number ): Number of deleted keys
+
+	        // **Example:**
+
+	        //	myCache.del( "myKey" )
+
+	        this.del = this.del.bind(this);
+	        // ## take
+
+	        // get the cached value and remove the key from the cache.
+	        // Equivalent to calling `get(key)` + `del(key)`.
+	        // Useful for implementing `single use` mechanism such as OTP, where once a value is read it will become obsolete.
+
+	        // **Parameters:**
+
+	        // * `key` ( String | Number ): cache key
+
+	        // **Example:**
+
+	        //	myCache.take "myKey", ( err, val )
+
+	        this.take = this.take.bind(this);
+	        // ## ttl
+
+	        // reset or redefine the ttl of a key. `ttl` = 0 means infinite lifetime.
+	        // If `ttl` is not passed the default ttl is used.
+	        // If `ttl` < 0 the key will be deleted.
+
+	        // **Parameters:**
+
+	        // * `key` ( String | Number ): cache key to reset the ttl value
+	        // * `ttl` ( Number ): ( optional -> options.stdTTL || 0 ) The time to live in seconds
+
+	        // **Return**
+
+	        // ( Boolen ): key found and ttl set
+
+	        // **Example:**
+
+	        //	myCache.ttl( "myKey" ) // will set ttl to default ttl
+
+	        //	myCache.ttl( "myKey", 1000 )
+
+	        this.ttl = this.ttl.bind(this);
+	        // ## getTtl
+
+	        // receive the ttl of a key.
+
+	        // **Parameters:**
+
+	        // * `key` ( String | Number ): cache key to check the ttl value
+
+	        // **Return**
+
+	        // ( Number|undefined ): The timestamp in ms when the key will expire, 0 if it will never expire or undefined if it not exists
+
+	        // **Example:**
+
+	        //	myCache.getTtl( "myKey" )
+
+	        this.getTtl = this.getTtl.bind(this);
+	        // ## keys
+
+	        // list all keys within this cache
+
+	        // **Return**
+
+	        // ( Array ): An array of all keys
+
+	        // **Example:**
+
+	        //     _keys = myCache.keys()
+
+	        //     # [ "foo", "bar", "fizz", "buzz", "anotherKeys" ]
+
+	        this.keys = this.keys.bind(this);
+	        // ## has
+
+	        // Check if a key is cached
+
+	        // **Parameters:**
+
+	        // * `key` ( String | Number ): cache key to check the ttl value
+
+	        // **Return**
+
+	        // ( Boolean ): A boolean that indicates if the key is cached
+
+	        // **Example:**
+
+	        //     _exists = myCache.has('myKey')
+
+	        //     # true
+
+	        this.has = this.has.bind(this);
+	        // ## getStats
+
+	        // get the stats
+
+	        // **Parameters:**
+
+	        // -
+
+	        // **Return**
+
+	        // ( Object ): Stats data
+
+	        // **Example:**
+
+	        //     myCache.getStats()
+	        //     # {
+	        //     # hits: 0,
+	        //     # misses: 0,
+	        //     # keys: 0,
+	        //     # ksize: 0,
+	        //     # vsize: 0
+	        //     # }
+
+	        this.getStats = this.getStats.bind(this);
+	        // ## flushAll
+
+	        // flush the whole data and reset the stats
+
+	        // **Example:**
+
+	        //     myCache.flushAll()
+
+	        //     myCache.getStats()
+	        //     # {
+	        //     # hits: 0,
+	        //     # misses: 0,
+	        //     # keys: 0,
+	        //     # ksize: 0,
+	        //     # vsize: 0
+	        //     # }
+
+	        this.flushAll = this.flushAll.bind(this);
+	        
+	        // ## flushStats
+
+	        // flush the stats and reset all counters to 0
+
+	        // **Example:**
+
+	        //     myCache.flushStats()
+
+	        //     myCache.getStats()
+	        //     # {
+	        //     # hits: 0,
+	        //     # misses: 0,
+	        //     # keys: 0,
+	        //     # ksize: 0,
+	        //     # vsize: 0
+	        //     # }
+
+	        this.flushStats = this.flushStats.bind(this);
+	        // ## close
+
+	        // This will clear the interval timeout which is set on checkperiod option.
+
+	        // **Example:**
+
+	        //     myCache.close()
+
+	        this.close = this.close.bind(this);
+	        // ## _checkData
+
+	        // internal housekeeping method.
+	        // Check all the cached data and delete the invalid values
+	        this._checkData = this._checkData.bind(this);
+	        // ## _check
+
+	        // internal method the check the value. If it's not valid any more delete it
+	        this._check = this._check.bind(this);
+	        // ## _isInvalidKey
+
+	        // internal method to check if the type of a key is either `number` or `string`
+	        this._isInvalidKey = this._isInvalidKey.bind(this);
+	        // ## _wrap
+
+	        // internal method to wrap a value in an object with some metadata
+	        this._wrap = this._wrap.bind(this);
+	        // ## _getValLength
+
+	        // internal method to calculate the value length
+	        this._getValLength = this._getValLength.bind(this);
+	        // ## _error
+
+	        // internal method to handle an error message
+	        this._error = this._error.bind(this);
+	        // ## _initErrors
+
+	        // internal method to generate error message templates
+	        this._initErrors = this._initErrors.bind(this);
+	        this.options = options;
+	        this._initErrors();
+	        // container for cached data
+	        this.data = {};
+	        // module options
+	        this.options = Object.assign({
+	          // convert all elements to string
+	          forceString: false,
+	          // used standard size for calculating value size
+	          objectValueSize: 80,
+	          promiseValueSize: 80,
+	          arrayValueSize: 40,
+	          // standard time to live in seconds. 0 = infinity;
+	          stdTTL: 0,
+	          // time in seconds to check all data and delete expired keys
+	          checkperiod: 600,
+	          // en/disable cloning of variables. If `true` you'll get a copy of the cached variable. If `false` you'll save and get just the reference
+	          useClones: true,
+	          // whether values should be deleted automatically at expiration
+	          deleteOnExpire: true,
+	          // enable legacy callbacks
+	          enableLegacyCallbacks: false,
+	          // max amount of keys that are being stored
+	          maxKeys: -1
+	        }, this.options);
+	        // generate functions with callbacks (legacy)
+	        if (this.options.enableLegacyCallbacks) {
+	          console.warn("WARNING! node-cache legacy callback support will drop in v6.x");
+	          ["get", "mget", "set", "del", "ttl", "getTtl", "keys", "has"].forEach((methodKey) => {
+	            var oldMethod;
+	            // reference real function
+	            oldMethod = this[methodKey];
+	            this[methodKey] = function(...args) {
+	              var cb, err, ref, res;
+	              ref = args, [...args] = ref, [cb] = splice.call(args, -1);
+	              // return a callback if cb is defined and a function
+	              if (typeof cb === "function") {
+	                try {
+	                  res = oldMethod(...args);
+	                  cb(null, res);
+	                } catch (error1) {
+	                  err = error1;
+	                  cb(err);
+	                }
+	              } else {
+	                return oldMethod(...args, cb);
+	              }
+	            };
+	          });
+	        }
+	        // statistics container
+	        this.stats = {
+	          hits: 0,
+	          misses: 0,
+	          keys: 0,
+	          ksize: 0,
+	          vsize: 0
+	        };
+	        // pre allocate valid keytypes array
+	        this.validKeyTypes = ["string", "number"];
+	        // initalize checking period
+	        this._checkData();
+	        return;
+	      }
+
+	      get(key) {
+	        var _ret, err;
+	        boundMethodCheck(this, NodeCache);
+	        // handle invalid key types
+	        if ((err = this._isInvalidKey(key)) != null) {
+	          throw err;
+	        }
+	        // get data and incremet stats
+	        if ((this.data[key] != null) && this._check(key, this.data[key])) {
+	          this.stats.hits++;
+	          _ret = this._unwrap(this.data[key]);
+	          // return data
+	          return _ret;
+	        } else {
+	          // if not found return undefined
+	          this.stats.misses++;
+	          return void 0;
+	        }
+	      }
+
+	      mget(keys) {
+	        var _err, err, i, key, len, oRet;
+	        boundMethodCheck(this, NodeCache);
+	        // convert a string to an array of one key
+	        if (!Array.isArray(keys)) {
+	          _err = this._error("EKEYSTYPE");
+	          throw _err;
+	        }
+	        // define return
+	        oRet = {};
+	        for (i = 0, len = keys.length; i < len; i++) {
+	          key = keys[i];
+	          // handle invalid key types
+	          if ((err = this._isInvalidKey(key)) != null) {
+	            throw err;
+	          }
+	          // get data and increment stats
+	          if ((this.data[key] != null) && this._check(key, this.data[key])) {
+	            this.stats.hits++;
+	            oRet[key] = this._unwrap(this.data[key]);
+	          } else {
+	            // if not found return a error
+	            this.stats.misses++;
+	          }
+	        }
+	        // return all found keys
+	        return oRet;
+	      }
+
+	      set(key, value, ttl) {
+	        var _err, err, existent;
+	        boundMethodCheck(this, NodeCache);
+	        // check if cache is overflowing
+	        if (this.options.maxKeys > -1 && this.stats.keys >= this.options.maxKeys) {
+	          _err = this._error("ECACHEFULL");
+	          throw _err;
+	        }
+	        // force the data to string
+	        if (this.options.forceString && !typeof value === "string") {
+	          value = JSON.stringify(value);
+	        }
+	        // set default ttl if not passed
+	        if (ttl == null) {
+	          ttl = this.options.stdTTL;
+	        }
+	        // handle invalid key types
+	        if ((err = this._isInvalidKey(key)) != null) {
+	          throw err;
+	        }
+	        // internal helper variables
+	        existent = false;
+	        // remove existing data from stats
+	        if (this.data[key]) {
+	          existent = true;
+	          this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
+	        }
+	        // set the value
+	        this.data[key] = this._wrap(value, ttl);
+	        this.stats.vsize += this._getValLength(value);
+	        // only add the keys and key-size if the key is new
+	        if (!existent) {
+	          this.stats.ksize += this._getKeyLength(key);
+	          this.stats.keys++;
+	        }
+	        this.emit("set", key, value);
+	        // return true
+	        return true;
+	      }
+
+	      mset(keyValueSet) {
+	        var _err, err, i, j, key, keyValuePair, len, len1, ttl, val;
+	        boundMethodCheck(this, NodeCache);
+	        // check if cache is overflowing
+	        if (this.options.maxKeys > -1 && this.stats.keys + keyValueSet.length >= this.options.maxKeys) {
+	          _err = this._error("ECACHEFULL");
+	          throw _err;
+	        }
+
+	// loop over keyValueSet to validate key and ttl
+	        for (i = 0, len = keyValueSet.length; i < len; i++) {
+	          keyValuePair = keyValueSet[i];
+	          ({key, val, ttl} = keyValuePair);
+	          // check if there is ttl and it's a number
+	          if (ttl && typeof ttl !== "number") {
+	            _err = this._error("ETTLTYPE");
+	            throw _err;
+	          }
+	          // handle invalid key types
+	          if ((err = this._isInvalidKey(key)) != null) {
+	            throw err;
+	          }
+	        }
+	        for (j = 0, len1 = keyValueSet.length; j < len1; j++) {
+	          keyValuePair = keyValueSet[j];
+	          ({key, val, ttl} = keyValuePair);
+	          this.set(key, val, ttl);
+	        }
+	        return true;
+	      }
+
+	      del(keys) {
+	        var delCount, err, i, key, len, oldVal;
+	        boundMethodCheck(this, NodeCache);
+	        // convert keys to an array of itself
+	        if (!Array.isArray(keys)) {
+	          keys = [keys];
+	        }
+	        delCount = 0;
+	        for (i = 0, len = keys.length; i < len; i++) {
+	          key = keys[i];
+	          // handle invalid key types
+	          if ((err = this._isInvalidKey(key)) != null) {
+	            throw err;
+	          }
+	          // only delete if existent
+	          if (this.data[key] != null) {
+	            // calc the stats
+	            this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
+	            this.stats.ksize -= this._getKeyLength(key);
+	            this.stats.keys--;
+	            delCount++;
+	            // delete the value
+	            oldVal = this.data[key];
+	            delete this.data[key];
+	            // return true
+	            this.emit("del", key, oldVal.v);
+	          }
+	        }
+	        return delCount;
+	      }
+
+	      take(key) {
+	        var _ret;
+	        boundMethodCheck(this, NodeCache);
+	        _ret = this.get(key);
+	        if ((_ret != null)) {
+	          this.del(key);
+	        }
+	        return _ret;
+	      }
+
+	      ttl(key, ttl) {
+	        var err;
+	        boundMethodCheck(this, NodeCache);
+	        ttl || (ttl = this.options.stdTTL);
+	        if (!key) {
+	          return false;
+	        }
+	        // handle invalid key types
+	        if ((err = this._isInvalidKey(key)) != null) {
+	          throw err;
+	        }
+	        // check for existent data and update the ttl value
+	        if ((this.data[key] != null) && this._check(key, this.data[key])) {
+	          // if ttl < 0 delete the key. otherwise reset the value
+	          if (ttl >= 0) {
+	            this.data[key] = this._wrap(this.data[key].v, ttl, false);
+	          } else {
+	            this.del(key);
+	          }
+	          return true;
+	        } else {
+	          // return false if key has not been found
+	          return false;
+	        }
+	      }
+
+	      getTtl(key) {
+	        var _ttl, err;
+	        boundMethodCheck(this, NodeCache);
+	        if (!key) {
+	          return void 0;
+	        }
+	        // handle invalid key types
+	        if ((err = this._isInvalidKey(key)) != null) {
+	          throw err;
+	        }
+	        // check for existant data and update the ttl value
+	        if ((this.data[key] != null) && this._check(key, this.data[key])) {
+	          _ttl = this.data[key].t;
+	          return _ttl;
+	        } else {
+	          // return undefined if key has not been found
+	          return void 0;
+	        }
+	      }
+
+	      keys() {
+	        var _keys;
+	        boundMethodCheck(this, NodeCache);
+	        _keys = Object.keys(this.data);
+	        return _keys;
+	      }
+
+	      has(key) {
+	        var _exists;
+	        boundMethodCheck(this, NodeCache);
+	        _exists = (this.data[key] != null) && this._check(key, this.data[key]);
+	        return _exists;
+	      }
+
+	      getStats() {
+	        boundMethodCheck(this, NodeCache);
+	        return this.stats;
+	      }
+
+	      flushAll(_startPeriod = true) {
+	        boundMethodCheck(this, NodeCache);
+	        // parameter just for testing
+
+	        // set data empty
+	        this.data = {};
+	        // reset stats
+	        this.stats = {
+	          hits: 0,
+	          misses: 0,
+	          keys: 0,
+	          ksize: 0,
+	          vsize: 0
+	        };
+	        // reset check period
+	        this._killCheckPeriod();
+	        this._checkData(_startPeriod);
+	        this.emit("flush");
+	      }
+
+	      flushStats() {
+	        boundMethodCheck(this, NodeCache);
+	        // reset stats
+	        this.stats = {
+	          hits: 0,
+	          misses: 0,
+	          keys: 0,
+	          ksize: 0,
+	          vsize: 0
+	        };
+	        this.emit("flush_stats");
+	      }
+
+	      close() {
+	        boundMethodCheck(this, NodeCache);
+	        this._killCheckPeriod();
+	      }
+
+	      _checkData(startPeriod = true) {
+	        var key, ref, value;
+	        boundMethodCheck(this, NodeCache);
+	        ref = this.data;
+	        // run the housekeeping method
+	        for (key in ref) {
+	          value = ref[key];
+	          this._check(key, value);
+	        }
+	        if (startPeriod && this.options.checkperiod > 0) {
+	          this.checkTimeout = setTimeout(this._checkData, this.options.checkperiod * 1000, startPeriod);
+	          if ((this.checkTimeout != null) && (this.checkTimeout.unref != null)) {
+	            this.checkTimeout.unref();
+	          }
+	        }
+	      }
+
+	      // ## _killCheckPeriod
+
+	      // stop the checkdata period. Only needed to abort the script in testing mode.
+	      _killCheckPeriod() {
+	        if (this.checkTimeout != null) {
+	          return clearTimeout(this.checkTimeout);
+	        }
+	      }
+
+	      _check(key, data) {
+	        var _retval;
+	        boundMethodCheck(this, NodeCache);
+	        _retval = true;
+	        // data is invalid if the ttl is too old and is not 0
+	        // console.log data.t < Date.now(), data.t, Date.now()
+	        if (data.t !== 0 && data.t < Date.now()) {
+	          if (this.options.deleteOnExpire) {
+	            _retval = false;
+	            this.del(key);
+	          }
+	          this.emit("expired", key, this._unwrap(data));
+	        }
+	        return _retval;
+	      }
+
+	      _isInvalidKey(key) {
+	        var ref;
+	        boundMethodCheck(this, NodeCache);
+	        if (ref = typeof key, indexOf.call(this.validKeyTypes, ref) < 0) {
+	          return this._error("EKEYTYPE", {
+	            type: typeof key
+	          });
+	        }
+	      }
+
+	      _wrap(value, ttl, asClone = true) {
+	        var livetime, now, ttlMultiplicator;
+	        boundMethodCheck(this, NodeCache);
+	        if (!this.options.useClones) {
+	          asClone = false;
+	        }
+	        // define the time to live
+	        now = Date.now();
+	        livetime = 0;
+	        ttlMultiplicator = 1000;
+	        // use given ttl
+	        if (ttl === 0) {
+	          livetime = 0;
+	        } else if (ttl) {
+	          livetime = now + (ttl * ttlMultiplicator);
+	        } else {
+	          // use standard ttl
+	          if (this.options.stdTTL === 0) {
+	            livetime = this.options.stdTTL;
+	          } else {
+	            livetime = now + (this.options.stdTTL * ttlMultiplicator);
+	          }
+	        }
+	        // return the wrapped value
+	        return {
+	          t: livetime,
+	          v: asClone ? clone(value) : value
+	        };
+	      }
+
+	      // ## _unwrap
+
+	      // internal method to extract get the value out of the wrapped value
+	      _unwrap(value, asClone = true) {
+	        if (!this.options.useClones) {
+	          asClone = false;
+	        }
+	        if (value.v != null) {
+	          if (asClone) {
+	            return clone(value.v);
+	          } else {
+	            return value.v;
+	          }
+	        }
+	        return null;
+	      }
+
+	      // ## _getKeyLength
+
+	      // internal method the calculate the key length
+	      _getKeyLength(key) {
+	        return key.toString().length;
+	      }
+
+	      _getValLength(value) {
+	        boundMethodCheck(this, NodeCache);
+	        if (typeof value === "string") {
+	          // if the value is a String get the real length
+	          return value.length;
+	        } else if (this.options.forceString) {
+	          // force string if it's defined and not passed
+	          return JSON.stringify(value).length;
+	        } else if (Array.isArray(value)) {
+	          // if the data is an Array multiply each element with a defined default length
+	          return this.options.arrayValueSize * value.length;
+	        } else if (typeof value === "number") {
+	          return 8;
+	        } else if (typeof (value != null ? value.then : void 0) === "function") {
+	          // if the data is a Promise, use defined default
+	          // (can't calculate actual/resolved value size synchronously)
+	          return this.options.promiseValueSize;
+	        } else if (typeof Buffer !== "undefined" && Buffer !== null ? Buffer.isBuffer(value) : void 0) {
+	          return value.length;
+	        } else if ((value != null) && typeof value === "object") {
+	          // if the data is an Object multiply each element with a defined default length
+	          return this.options.objectValueSize * Object.keys(value).length;
+	        } else if (typeof value === "boolean") {
+	          return 8;
+	        } else {
+	          // default fallback
+	          return 0;
+	        }
+	      }
+
+	      _error(type, data = {}) {
+	        var error;
+	        boundMethodCheck(this, NodeCache);
+	        // generate the error object
+	        error = new Error();
+	        error.name = type;
+	        error.errorcode = type;
+	        error.message = this.ERRORS[type] != null ? this.ERRORS[type](data) : "-";
+	        error.data = data;
+	        // return the error object
+	        return error;
+	      }
+
+	      _initErrors() {
+	        var _errMsg, _errT, ref;
+	        boundMethodCheck(this, NodeCache);
+	        this.ERRORS = {};
+	        ref = this._ERRORS;
+	        for (_errT in ref) {
+	          _errMsg = ref[_errT];
+	          this.ERRORS[_errT] = this.createErrorMessage(_errMsg);
+	        }
+	      }
+
+	      createErrorMessage(errMsg) {
+	        return function(args) {
+	          return errMsg.replace("__key", args.type);
+	        };
+	      }
+
+	    }
+	    NodeCache.prototype._ERRORS = {
+	      "ENOTFOUND": "Key `__key` not found",
+	      "ECACHEFULL": "Cache max keys amount exceeded",
+	      "EKEYTYPE": "The key argument has to be of type `string` or `number`. Found: `__key`",
+	      "EKEYSTYPE": "The keys argument has to be an array.",
+	      "ETTLTYPE": "The ttl argument has to be a number."
+	    };
+
+	    return NodeCache;
+
+	  }).call(this);
+
+	}).call(commonjsGlobal$1);
+	return node_cache.exports;
+}
+
+/*
+ * node-cache 5.1.2 ( 2020-07-01 )
+ * https://github.com/node-cache/node-cache
+ *
+ * Released under the MIT license
+ * https://github.com/node-cache/node-cache/blob/master/LICENSE
+ *
+ * Maintained by  (  )
+*/
+
+(function (module) {
+	(function() {
+	  var exports;
+
+	  exports = module.exports = requireNode_cache();
+
+	  exports.version = '5.1.2';
+
+	}).call(commonjsGlobal$1);
+} (nodeCache));
+
+var NodeCache = /*@__PURE__*/getDefaultExportFromCjs$1(nodeCache.exports);
+
 var AccountState;
 (function (AccountState) {
     AccountState[AccountState["Uninitialized"] = 0] = "Uninitialized";
@@ -11370,90 +12963,124 @@ var AccountType;
     AccountType[AccountType["Unknown"] = 3] = "Unknown";
     AccountType[AccountType["NotExists"] = 4] = "NotExists";
 })(AccountType || (AccountType = {}));
+const TOKEN_PROGRAM_CACHE = new NodeCache({
+    // cache never expires
+    stdTTL: 0,
+    // this cache stores values (including Promises). Using clones causes node to crash when a race condition occurs
+    useClones: false,
+});
+const decodeMetaplexMetadataPartial = (data) => {
+    const rawName = data.subarray(65 + 4, 65 + 36); // omit first 4 bytes, size is already hardcoded
+    const rawSymbol = data.subarray(101 + 4, 115); // omit first 4 bytes, size is already hardcoded
+    const rawUri = data.subarray(115 + 4, 204); // omit first 4 bytes, size is already hardcoded
+    return {
+        uri: rawUri.toString("utf-8").replace(/\u0000/g, ""),
+        symbol: rawSymbol.toString("utf-8").replace(/\u0000/g, ""),
+        name: rawName.toString("utf-8").replace(/\u0000/g, ""),
+    };
+};
 /**
  * Get name, symbol and decimals for provided token
  * @param connection solana web3 connection
  * @param tokenAddress address to get metaplex info for
  * @returns
  */
-function getTokenInfo(connection, tokenAddress) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const tokenMetaProgramId = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
-        const findMetaplexMetadataPda = (tokenMint) => PublicKey.findProgramAddressSync([
-            buffer.Buffer.from("metadata", "utf-8"),
-            tokenMetaProgramId.toBuffer(),
-            tokenMint.toBuffer(),
-        ], tokenMetaProgramId)[0];
-        const decodeMetaplexMetadataPartial = (data) => {
-            const rawName = data.subarray(65 + 4, 65 + 36); // omit first 4 bytes, size is already hardcoded
-            const rawSymbol = data.subarray(101 + 4, 115); // omit first 4 bytes, size is already hardcoded
-            const rawUri = data.subarray(115 + 4, 204); // omit first 4 bytes, size is already hardcoded
+function getTokenInfo(connection_1, tokenAddress_1) {
+    return __awaiter(this, arguments, void 0, function* (connection, tokenAddress, useCache = false) {
+        const tokenAddressStr = tokenAddress.toBase58();
+        if (tokenAddressStr === "11111111111111111111111111111111") {
             return {
-                uri: rawUri.toString("utf-8").replace(/\u0000/g, ""),
-                symbol: rawSymbol.toString("utf-8").replace(/\u0000/g, ""),
-                name: rawName.toString("utf-8").replace(/\u0000/g, ""),
+                address: tokenAddress,
+                decimals: 9,
+                name: "Native SOL",
+                symbol: "SOL",
+                json: "",
+                tokenProgram: SystemProgram.programId,
             };
-        };
-        const pda = findMetaplexMetadataPda(tokenAddress);
-        const [tokenAccount, pdaAccount] = yield connection.getMultipleAccountsInfo([
-            tokenAddress,
-            pda,
-        ]);
-        if (tokenAccount === null) {
-            return null;
         }
-        const mint2022 = unpackMint(tokenAddress, tokenAccount, tokenAccount.owner);
-        const extTypes = getExtensionTypes((_a = mint2022.tlvData) !== null && _a !== void 0 ? _a : buffer.Buffer.alloc(0));
-        const tokenMetaBuf = extTypes.includes(ExtensionType.TokenMetadata)
-            ? getExtensionData(ExtensionType.TokenMetadata, mint2022.tlvData)
-            : null;
-        if (tokenMetaBuf) {
-            const meta = unpack(tokenMetaBuf);
+        // if requested, try returning cached Promise (in-flight or resolved)
+        if (useCache) {
+            const cached = TOKEN_PROGRAM_CACHE.get(tokenAddressStr);
+            if (cached)
+                return cached;
+        }
+        // fetcher encapsulates the actual work and is stored in cache when useCache is true
+        const fetcher = (() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const [pda] = getTokenMetadataAddress(tokenAddress, TOKEN_METADATA_PROGRAM_ID);
+            const [tokenAccount, pdaAccount] = yield connection.getMultipleAccountsInfo([tokenAddress, pda]);
+            if (!tokenAccount || (tokenAccount === null || tokenAccount === void 0 ? void 0 : tokenAccount.lamports) === 0) {
+                return null;
+            }
+            const mint2022 = unpackMint(tokenAddress, tokenAccount, tokenAccount.owner);
+            const extTypes = getExtensionTypes((_a = mint2022.tlvData) !== null && _a !== void 0 ? _a : buffer.Buffer.alloc(0));
+            const tokenMetaBuf = extTypes.includes(ExtensionType.TokenMetadata)
+                ? getExtensionData(ExtensionType.TokenMetadata, mint2022.tlvData)
+                : null;
+            if (tokenMetaBuf) {
+                const meta = unpack(tokenMetaBuf);
+                return {
+                    address: tokenAddress,
+                    decimals: mint2022.decimals,
+                    name: meta.name,
+                    symbol: meta.symbol,
+                    json: meta.uri,
+                    tokenProgram: tokenAccount.owner,
+                };
+            }
+            if (extTypes.includes(ExtensionType.MetadataPointer)) {
+                const mpState = getMetadataPointerState(mint2022);
+                if ((mpState === null || mpState === void 0 ? void 0 : mpState.metadataAddress) &&
+                    mpState.metadataAddress.equals(tokenAddress)) {
+                    const inlineMetaBuf = getExtensionData(ExtensionType.TokenMetadata, mint2022.tlvData);
+                    if (inlineMetaBuf) {
+                        const meta = unpack(inlineMetaBuf);
+                        return {
+                            address: tokenAddress,
+                            decimals: mint2022.decimals,
+                            name: meta.name,
+                            symbol: meta.symbol,
+                            json: meta.uri,
+                            tokenProgram: tokenAccount.owner,
+                        };
+                    }
+                }
+            }
+            if (!pdaAccount || pdaAccount.lamports === 0) {
+                return null;
+            }
+            // parse token account
+            // mint_authority - coption(pubkey) = 4 or 36
+            // supply - u64 = 8
+            // decimals - u8
+            let decimalsOffset = 12;
+            if (tokenAccount.data[0] === 1)
+                decimalsOffset += 32;
+            const decimals = tokenAccount.data[decimalsOffset];
+            const { name, symbol, uri } = decodeMetaplexMetadataPartial(pdaAccount.data);
             return {
                 address: tokenAddress,
-                decimals: mint2022.decimals,
-                name: meta.name,
-                symbol: meta.symbol,
-                json: meta.uri,
+                decimals,
+                name,
+                symbol,
+                json: uri,
+                tokenProgram: tokenAccount.owner,
             };
-        }
-        if (extTypes.includes(ExtensionType.MetadataPointer)) {
-            const mpState = getMetadataPointerState(mint2022);
-            if ((mpState === null || mpState === void 0 ? void 0 : mpState.metadataAddress) &&
-                mpState.metadataAddress.equals(tokenAddress)) {
-                const inlineMetaBuf = getExtensionData(ExtensionType.TokenMetadata, mint2022.tlvData);
-                if (inlineMetaBuf) {
-                    const meta = unpack(inlineMetaBuf);
-                    return {
-                        address: tokenAddress,
-                        decimals: mint2022.decimals,
-                        name: meta.name,
-                        symbol: meta.symbol,
-                        json: meta.uri,
-                    };
+        }))();
+        if (useCache) {
+            // store the in-flight Promise so concurrent callers reuse it
+            // but ensure we don't keep null results in the cache: if the promise
+            // resolves to null, remove the cache entry.
+            const wrapped = fetcher.then((res) => {
+                if (res === null) {
+                    TOKEN_PROGRAM_CACHE.del(tokenAddressStr);
                 }
-            }
-        }
-        if (pdaAccount === null || (pdaAccount === null || pdaAccount === void 0 ? void 0 : pdaAccount.lamports) === 0) {
-            return null;
+                return res;
+            });
+            TOKEN_PROGRAM_CACHE.set(tokenAddressStr, wrapped);
+            return wrapped;
         }
-        // parse token account
-        // mint_authority - coption(pubkey) = 4 or 36
-        // supply - u64 = 8
-        // decimals - u8
-        let decimalsOffset = 12;
-        if (tokenAccount.data[0] === 1)
-            decimalsOffset += 32;
-        const decimals = tokenAccount.data[decimalsOffset];
-        const { name, symbol, uri } = decodeMetaplexMetadataPartial(pdaAccount.data);
-        return {
-            address: tokenAddress,
-            decimals,
-            name,
-            symbol,
-            json: uri,
-        };
+        return fetcher;
     });
 }
 /**