@solana/web3.js 1.24.3 → 1.25.1

package/lib/index.iife.js

@@ -18,6 +18,10 @@ var solanaWeb3 = (function (exports) {
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+  function getDefaultExportFromCjs (x) {
+  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+  }
+
   function getAugmentedNamespace(n) {
   	if (n.__esModule) return n;
   	var a = Object.defineProperty({}, '__esModule', {value: true});
@@ -8327,7 +8331,7 @@ var solanaWeb3 = (function (exports) {
 
   var bs58$1 = bs58;
 
-  var browser$2 = {};
+  var browser$1 = {};
 
   /* eslint-env browser */
 
@@ -8378,10 +8382,10 @@ var solanaWeb3 = (function (exports) {
   	return options.outputFormat === 'hex' ? bufferToHex(hash) : hash;
   };
 
-  browser$2.sha1 = create$1('SHA-1');
-  var sha256 = browser$2.sha256 = create$1('SHA-256');
-  browser$2.sha384 = create$1('SHA-384');
-  browser$2.sha512 = create$1('SHA-512');
+  browser$1.sha1 = create$1('SHA-1');
+  var sha256 = browser$1.sha256 = create$1('SHA-256');
+  browser$1.sha384 = create$1('SHA-384');
+  browser$1.sha512 = create$1('SHA-512');
 
   var lib$1 = {};
 
@@ -11937,7 +11941,7 @@ var solanaWeb3 = (function (exports) {
    *
    * @augments {Layout}
    */
-  var Blob = /** @class */ (function (_super) {
+  var Blob$1 = /** @class */ (function (_super) {
       __extends(Blob, _super);
       function Blob(length, property) {
           var _this = this;
@@ -12004,7 +12008,7 @@ var solanaWeb3 = (function (exports) {
       };
       return Blob;
   }(Layout));
-  Layout$1.Blob = Blob;
+  Layout$1.Blob = Blob$1;
   /**
    * Contain a `NUL`-terminated UTF8 string.
    *
@@ -12312,7 +12316,7 @@ var solanaWeb3 = (function (exports) {
   /** Factory for {@link UnionLayoutDiscriminator} values. */
   Layout$1.unionLayoutDiscriminator = (function (layout, property) { return new UnionLayoutDiscriminator(layout, property); });
   /** Factory for {@link Blob} values. */
-  var blob = Layout$1.blob = (function (length, property) { return new Blob(length, property); });
+  var blob = Layout$1.blob = (function (length, property) { return new Blob$1(length, property); });
   /** Factory for {@link CString} values. */
   Layout$1.cstr = (function (property) { return new CString(property); });
   /** Factory for {@link UTF8} values. */
@@ -14270,36 +14274,566 @@ var solanaWeb3 = (function (exports) {
 
   }
 
-  var browser$1 = {exports: {}};
+  var browserPonyfill = {exports: {}};
 
   (function (module, exports) {
+  var global = typeof self !== 'undefined' ? self : commonjsGlobal;
+  var __self__ = (function () {
+  function F() {
+  this.fetch = false;
+  this.DOMException = global.DOMException;
+  }
+  F.prototype = global;
+  return new F();
+  })();
+  (function(self) {
 
-  // ref: https://github.com/tc39/proposal-global
-  var getGlobal = function () {
-  	// the only reliable means to get the global object is
-  	// `Function('return this')()`
-  	// However, this causes CSP violations in Chrome apps.
-  	if (typeof self !== 'undefined') { return self; }
-  	if (typeof window !== 'undefined') { return window; }
-  	if (typeof global !== 'undefined') { return global; }
-  	throw new Error('unable to locate global object');
-  };
+  ((function (exports) {
 
-  var global = getGlobal();
+    var support = {
+      searchParams: 'URLSearchParams' in self,
+      iterable: 'Symbol' in self && 'iterator' in Symbol,
+      blob:
+        'FileReader' in self &&
+        'Blob' in self &&
+        (function() {
+          try {
+            new Blob();
+            return true
+          } catch (e) {
+            return false
+          }
+        })(),
+      formData: 'FormData' in self,
+      arrayBuffer: 'ArrayBuffer' in self
+    };
 
-  module.exports = exports = global.fetch;
+    function isDataView(obj) {
+      return obj && DataView.prototype.isPrototypeOf(obj)
+    }
+
+    if (support.arrayBuffer) {
+      var viewClasses = [
+        '[object Int8Array]',
+        '[object Uint8Array]',
+        '[object Uint8ClampedArray]',
+        '[object Int16Array]',
+        '[object Uint16Array]',
+        '[object Int32Array]',
+        '[object Uint32Array]',
+        '[object Float32Array]',
+        '[object Float64Array]'
+      ];
 
-  // Needed for TypeScript and Webpack.
-  if (global.fetch) {
-  	exports.default = global.fetch.bind(global);
-  }
+      var isArrayBufferView =
+        ArrayBuffer.isView ||
+        function(obj) {
+          return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+        };
+    }
+
+    function normalizeName(name) {
+      if (typeof name !== 'string') {
+        name = String(name);
+      }
+      if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
+        throw new TypeError('Invalid character in header field name')
+      }
+      return name.toLowerCase()
+    }
+
+    function normalizeValue(value) {
+      if (typeof value !== 'string') {
+        value = String(value);
+      }
+      return value
+    }
+
+    // Build a destructive iterator for the value list
+    function iteratorFor(items) {
+      var iterator = {
+        next: function() {
+          var value = items.shift();
+          return {done: value === undefined, value: value}
+        }
+      };
+
+      if (support.iterable) {
+        iterator[Symbol.iterator] = function() {
+          return iterator
+        };
+      }
+
+      return iterator
+    }
+
+    function Headers(headers) {
+      this.map = {};
+
+      if (headers instanceof Headers) {
+        headers.forEach(function(value, name) {
+          this.append(name, value);
+        }, this);
+      } else if (Array.isArray(headers)) {
+        headers.forEach(function(header) {
+          this.append(header[0], header[1]);
+        }, this);
+      } else if (headers) {
+        Object.getOwnPropertyNames(headers).forEach(function(name) {
+          this.append(name, headers[name]);
+        }, this);
+      }
+    }
+
+    Headers.prototype.append = function(name, value) {
+      name = normalizeName(name);
+      value = normalizeValue(value);
+      var oldValue = this.map[name];
+      this.map[name] = oldValue ? oldValue + ', ' + value : value;
+    };
+
+    Headers.prototype['delete'] = function(name) {
+      delete this.map[normalizeName(name)];
+    };
+
+    Headers.prototype.get = function(name) {
+      name = normalizeName(name);
+      return this.has(name) ? this.map[name] : null
+    };
+
+    Headers.prototype.has = function(name) {
+      return this.map.hasOwnProperty(normalizeName(name))
+    };
+
+    Headers.prototype.set = function(name, value) {
+      this.map[normalizeName(name)] = normalizeValue(value);
+    };
+
+    Headers.prototype.forEach = function(callback, thisArg) {
+      for (var name in this.map) {
+        if (this.map.hasOwnProperty(name)) {
+          callback.call(thisArg, this.map[name], name, this);
+        }
+      }
+    };
+
+    Headers.prototype.keys = function() {
+      var items = [];
+      this.forEach(function(value, name) {
+        items.push(name);
+      });
+      return iteratorFor(items)
+    };
+
+    Headers.prototype.values = function() {
+      var items = [];
+      this.forEach(function(value) {
+        items.push(value);
+      });
+      return iteratorFor(items)
+    };
+
+    Headers.prototype.entries = function() {
+      var items = [];
+      this.forEach(function(value, name) {
+        items.push([name, value]);
+      });
+      return iteratorFor(items)
+    };
+
+    if (support.iterable) {
+      Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+    }
+
+    function consumed(body) {
+      if (body.bodyUsed) {
+        return Promise.reject(new TypeError('Already read'))
+      }
+      body.bodyUsed = true;
+    }
+
+    function fileReaderReady(reader) {
+      return new Promise(function(resolve, reject) {
+        reader.onload = function() {
+          resolve(reader.result);
+        };
+        reader.onerror = function() {
+          reject(reader.error);
+        };
+      })
+    }
+
+    function readBlobAsArrayBuffer(blob) {
+      var reader = new FileReader();
+      var promise = fileReaderReady(reader);
+      reader.readAsArrayBuffer(blob);
+      return promise
+    }
+
+    function readBlobAsText(blob) {
+      var reader = new FileReader();
+      var promise = fileReaderReady(reader);
+      reader.readAsText(blob);
+      return promise
+    }
+
+    function readArrayBufferAsText(buf) {
+      var view = new Uint8Array(buf);
+      var chars = new Array(view.length);
+
+      for (var i = 0; i < view.length; i++) {
+        chars[i] = String.fromCharCode(view[i]);
+      }
+      return chars.join('')
+    }
+
+    function bufferClone(buf) {
+      if (buf.slice) {
+        return buf.slice(0)
+      } else {
+        var view = new Uint8Array(buf.byteLength);
+        view.set(new Uint8Array(buf));
+        return view.buffer
+      }
+    }
+
+    function Body() {
+      this.bodyUsed = false;
+
+      this._initBody = function(body) {
+        this._bodyInit = body;
+        if (!body) {
+          this._bodyText = '';
+        } else if (typeof body === 'string') {
+          this._bodyText = body;
+        } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+          this._bodyBlob = body;
+        } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+          this._bodyFormData = body;
+        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          this._bodyText = body.toString();
+        } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+          this._bodyArrayBuffer = bufferClone(body.buffer);
+          // IE 10-11 can't handle a DataView body.
+          this._bodyInit = new Blob([this._bodyArrayBuffer]);
+        } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+          this._bodyArrayBuffer = bufferClone(body);
+        } else {
+          this._bodyText = body = Object.prototype.toString.call(body);
+        }
+
+        if (!this.headers.get('content-type')) {
+          if (typeof body === 'string') {
+            this.headers.set('content-type', 'text/plain;charset=UTF-8');
+          } else if (this._bodyBlob && this._bodyBlob.type) {
+            this.headers.set('content-type', this._bodyBlob.type);
+          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+            this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+          }
+        }
+      };
+
+      if (support.blob) {
+        this.blob = function() {
+          var rejected = consumed(this);
+          if (rejected) {
+            return rejected
+          }
+
+          if (this._bodyBlob) {
+            return Promise.resolve(this._bodyBlob)
+          } else if (this._bodyArrayBuffer) {
+            return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+          } else if (this._bodyFormData) {
+            throw new Error('could not read FormData body as blob')
+          } else {
+            return Promise.resolve(new Blob([this._bodyText]))
+          }
+        };
+
+        this.arrayBuffer = function() {
+          if (this._bodyArrayBuffer) {
+            return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
+          } else {
+            return this.blob().then(readBlobAsArrayBuffer)
+          }
+        };
+      }
+
+      this.text = function() {
+        var rejected = consumed(this);
+        if (rejected) {
+          return rejected
+        }
+
+        if (this._bodyBlob) {
+          return readBlobAsText(this._bodyBlob)
+        } else if (this._bodyArrayBuffer) {
+          return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+        } else if (this._bodyFormData) {
+          throw new Error('could not read FormData body as text')
+        } else {
+          return Promise.resolve(this._bodyText)
+        }
+      };
+
+      if (support.formData) {
+        this.formData = function() {
+          return this.text().then(decode)
+        };
+      }
+
+      this.json = function() {
+        return this.text().then(JSON.parse)
+      };
+
+      return this
+    }
+
+    // HTTP methods whose capitalization should be normalized
+    var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+
+    function normalizeMethod(method) {
+      var upcased = method.toUpperCase();
+      return methods.indexOf(upcased) > -1 ? upcased : method
+    }
+
+    function Request(input, options) {
+      options = options || {};
+      var body = options.body;
+
+      if (input instanceof Request) {
+        if (input.bodyUsed) {
+          throw new TypeError('Already read')
+        }
+        this.url = input.url;
+        this.credentials = input.credentials;
+        if (!options.headers) {
+          this.headers = new Headers(input.headers);
+        }
+        this.method = input.method;
+        this.mode = input.mode;
+        this.signal = input.signal;
+        if (!body && input._bodyInit != null) {
+          body = input._bodyInit;
+          input.bodyUsed = true;
+        }
+      } else {
+        this.url = String(input);
+      }
+
+      this.credentials = options.credentials || this.credentials || 'same-origin';
+      if (options.headers || !this.headers) {
+        this.headers = new Headers(options.headers);
+      }
+      this.method = normalizeMethod(options.method || this.method || 'GET');
+      this.mode = options.mode || this.mode || null;
+      this.signal = options.signal || this.signal;
+      this.referrer = null;
+
+      if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+        throw new TypeError('Body not allowed for GET or HEAD requests')
+      }
+      this._initBody(body);
+    }
+
+    Request.prototype.clone = function() {
+      return new Request(this, {body: this._bodyInit})
+    };
+
+    function decode(body) {
+      var form = new FormData();
+      body
+        .trim()
+        .split('&')
+        .forEach(function(bytes) {
+          if (bytes) {
+            var split = bytes.split('=');
+            var name = split.shift().replace(/\+/g, ' ');
+            var value = split.join('=').replace(/\+/g, ' ');
+            form.append(decodeURIComponent(name), decodeURIComponent(value));
+          }
+        });
+      return form
+    }
+
+    function parseHeaders(rawHeaders) {
+      var headers = new Headers();
+      // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+      // https://tools.ietf.org/html/rfc7230#section-3.2
+      var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+      preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
+        var parts = line.split(':');
+        var key = parts.shift().trim();
+        if (key) {
+          var value = parts.join(':').trim();
+          headers.append(key, value);
+        }
+      });
+      return headers
+    }
+
+    Body.call(Request.prototype);
+
+    function Response(bodyInit, options) {
+      if (!options) {
+        options = {};
+      }
+
+      this.type = 'default';
+      this.status = options.status === undefined ? 200 : options.status;
+      this.ok = this.status >= 200 && this.status < 300;
+      this.statusText = 'statusText' in options ? options.statusText : 'OK';
+      this.headers = new Headers(options.headers);
+      this.url = options.url || '';
+      this._initBody(bodyInit);
+    }
+
+    Body.call(Response.prototype);
+
+    Response.prototype.clone = function() {
+      return new Response(this._bodyInit, {
+        status: this.status,
+        statusText: this.statusText,
+        headers: new Headers(this.headers),
+        url: this.url
+      })
+    };
+
+    Response.error = function() {
+      var response = new Response(null, {status: 0, statusText: ''});
+      response.type = 'error';
+      return response
+    };
 
-  exports.Headers = global.Headers;
-  exports.Request = global.Request;
-  exports.Response = global.Response;
-  }(browser$1, browser$1.exports));
+    var redirectStatuses = [301, 302, 303, 307, 308];
+
+    Response.redirect = function(url, status) {
+      if (redirectStatuses.indexOf(status) === -1) {
+        throw new RangeError('Invalid status code')
+      }
+
+      return new Response(null, {status: status, headers: {location: url}})
+    };
+
+    exports.DOMException = self.DOMException;
+    try {
+      new exports.DOMException();
+    } catch (err) {
+      exports.DOMException = function(message, name) {
+        this.message = message;
+        this.name = name;
+        var error = Error(message);
+        this.stack = error.stack;
+      };
+      exports.DOMException.prototype = Object.create(Error.prototype);
+      exports.DOMException.prototype.constructor = exports.DOMException;
+    }
+
+    function fetch(input, init) {
+      return new Promise(function(resolve, reject) {
+        var request = new Request(input, init);
+
+        if (request.signal && request.signal.aborted) {
+          return reject(new exports.DOMException('Aborted', 'AbortError'))
+        }
+
+        var xhr = new XMLHttpRequest();
+
+        function abortXhr() {
+          xhr.abort();
+        }
+
+        xhr.onload = function() {
+          var options = {
+            status: xhr.status,
+            statusText: xhr.statusText,
+            headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+          };
+          options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+          var body = 'response' in xhr ? xhr.response : xhr.responseText;
+          resolve(new Response(body, options));
+        };
+
+        xhr.onerror = function() {
+          reject(new TypeError('Network request failed'));
+        };
+
+        xhr.ontimeout = function() {
+          reject(new TypeError('Network request failed'));
+        };
+
+        xhr.onabort = function() {
+          reject(new exports.DOMException('Aborted', 'AbortError'));
+        };
+
+        xhr.open(request.method, request.url, true);
+
+        if (request.credentials === 'include') {
+          xhr.withCredentials = true;
+        } else if (request.credentials === 'omit') {
+          xhr.withCredentials = false;
+        }
+
+        if ('responseType' in xhr && support.blob) {
+          xhr.responseType = 'blob';
+        }
+
+        request.headers.forEach(function(value, name) {
+          xhr.setRequestHeader(name, value);
+        });
+
+        if (request.signal) {
+          request.signal.addEventListener('abort', abortXhr);
+
+          xhr.onreadystatechange = function() {
+            // DONE (success or failure)
+            if (xhr.readyState === 4) {
+              request.signal.removeEventListener('abort', abortXhr);
+            }
+          };
+        }
+
+        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+      })
+    }
+
+    fetch.polyfill = true;
+
+    if (!self.fetch) {
+      self.fetch = fetch;
+      self.Headers = Headers;
+      self.Request = Request;
+      self.Response = Response;
+    }
+
+    exports.Headers = Headers;
+    exports.Request = Request;
+    exports.Response = Response;
+    exports.fetch = fetch;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
 
-  var fetch = browser$1.exports;
+  })({}));
+  })(__self__);
+  __self__.fetch.ponyfill = true;
+  // Remove "polyfill" property added by whatwg-fetch
+  delete __self__.fetch.polyfill;
+  // Choose between native implementation (global) or custom implementation (__self__)
+  // var ctx = global.fetch ? global : __self__;
+  var ctx = __self__; // this line disable service worker support temporarily
+  exports = ctx.fetch; // To enable: import fetch from 'cross-fetch'
+  exports.default = ctx.fetch; // For TypeScript consumers without esModuleInterop.
+  exports.fetch = ctx.fetch; // To enable: import {fetch} from 'cross-fetch'
+  exports.Headers = ctx.Headers;
+  exports.Request = ctx.Request;
+  exports.Response = ctx.Response;
+  module.exports = exports;
+  }(browserPonyfill, browserPonyfill.exports));
+
+  var fetch = /*@__PURE__*/getDefaultExportFromCjs(browserPonyfill.exports);
 
   /**
    * A `StructFailure` represents a single specific failure in validation.