@solana/web3.js 1.24.2 → 1.28.0

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 = {};
 
@@ -9462,6 +9466,9 @@ var solanaWeb3 = (function (exports) {
    */
 
   const MAX_SEED_LENGTH = 32;
+  /**
+   * Value to be converted into public key
+   */
 
   function isPublicKeyData(value) {
     return value._bn !== undefined;
@@ -11937,7 +11944,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 +12011,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 +12319,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. */
@@ -12435,16 +12442,35 @@ var solanaWeb3 = (function (exports) {
 
       _defineProperty(this, "instructions", void 0);
 
+      _defineProperty(this, "indexToProgramIds", new Map());
+
       this.header = args.header;
       this.accountKeys = args.accountKeys.map(account => new PublicKey(account));
       this.recentBlockhash = args.recentBlockhash;
       this.instructions = args.instructions;
+      this.instructions.forEach(ix => this.indexToProgramIds.set(ix.programIdIndex, this.accountKeys[ix.programIdIndex]));
+    }
+
+    isAccountSigner(index) {
+      return index < this.header.numRequiredSignatures;
     }
 
     isAccountWritable(index) {
       return index < this.header.numRequiredSignatures - this.header.numReadonlySignedAccounts || index >= this.header.numRequiredSignatures && index < this.accountKeys.length - this.header.numReadonlyUnsignedAccounts;
     }
 
+    isProgramId(index) {
+      return this.indexToProgramIds.has(index);
+    }
+
+    programIds() {
+      return [...this.indexToProgramIds.values()];
+    }
+
+    nonProgramIds() {
+      return this.accountKeys.filter((_, index) => !this.isProgramId(index));
+    }
+
     serialize() {
       const numKeys = this.accountKeys.length;
       let keyCount = [];
@@ -13159,7 +13185,7 @@ var solanaWeb3 = (function (exports) {
      */
 
 
-    static populate(message, signatures) {
+    static populate(message, signatures = []) {
       const transaction = new Transaction();
       transaction.recentBlockhash = message.recentBlockhash;
 
@@ -13179,7 +13205,7 @@ var solanaWeb3 = (function (exports) {
           const pubkey = message.accountKeys[account];
           return {
             pubkey,
-            isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()),
+            isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()) || message.isAccountSigner(account),
             isWritable: message.isAccountWritable(account)
           };
         });
@@ -14241,36 +14267,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 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
+    };
 
-  var global = getGlobal();
+    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]'
+      ];
 
-  module.exports = exports = global.fetch;
+      var isArrayBufferView =
+        ArrayBuffer.isView ||
+        function(obj) {
+          return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+        };
+    }
 
-  // Needed for TypeScript and Webpack.
-  if (global.fetch) {
-  	exports.default = global.fetch.bind(global);
-  }
+    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()
+    }
 
-  exports.Headers = global.Headers;
-  exports.Request = global.Request;
-  exports.Response = global.Response;
-  }(browser$1, browser$1.exports));
+    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
+        };
+      }
 
-  var fetch = browser$1.exports;
+      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
+    };
+
+    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;
+
+  })({}));
+  })(__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.
@@ -17706,7 +18262,15 @@ var solanaWeb3 = (function (exports) {
   });
   const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(type({
     err: nullable(union([type({}), string()])),
-    logs: nullable(array(string()))
+    logs: nullable(array(string())),
+    accounts: optional(nullable(array(type({
+      executable: boolean(),
+      owner: string(),
+      lamports: number(),
+      data: array(string()),
+      rentEpoch: optional(number())
+    })))),
+    unitsConsumed: optional(number())
   }));
 
   function createRpcClient(url, useHttps, httpHeaders, fetchMiddleware, disableRetryOnRateLimit) {
@@ -18432,6 +18996,8 @@ var solanaWeb3 = (function (exports) {
 
     /** @internal */
 
+    /** @internal */
+
     /**
      * Establish a JSON RPC connection
      *
@@ -18441,6 +19007,8 @@ var solanaWeb3 = (function (exports) {
     constructor(endpoint, commitmentOrConfig) {
       _defineProperty(this, "_commitment", void 0);
 
+      _defineProperty(this, "_confirmTransactionInitialTimeout", void 0);
+
       _defineProperty(this, "_rpcEndpoint", void 0);
 
       _defineProperty(this, "_rpcWsEndpoint", void 0);
@@ -18509,6 +19077,7 @@ var solanaWeb3 = (function (exports) {
         this._commitment = commitmentOrConfig;
       } else if (commitmentOrConfig) {
         this._commitment = commitmentOrConfig.commitment;
+        this._confirmTransactionInitialTimeout = commitmentOrConfig.confirmTransactionInitialTimeout;
         wsEndpoint = commitmentOrConfig.wsEndpoint;
         httpHeaders = commitmentOrConfig.httpHeaders;
         fetchMiddleware = commitmentOrConfig.fetchMiddleware;
@@ -18968,7 +19537,7 @@ var solanaWeb3 = (function (exports) {
           reject(err);
         }
       });
-      let timeoutMs = 60 * 1000;
+      let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
 
       switch (subscriptionCommitment) {
         case 'processed':
@@ -18977,7 +19546,7 @@ var solanaWeb3 = (function (exports) {
         case 'confirmed':
         case 'singleGossip':
           {
-            timeoutMs = 30 * 1000;
+            timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
             break;
           }
       }
@@ -19349,6 +19918,21 @@ var solanaWeb3 = (function (exports) {
 
       return res.result;
     }
+    /**
+     * Fetch the genesis hash
+     */
+
+
+    async getGenesisHash() {
+      const unsafeRes = await this._rpcRequest('getGenesisHash', []);
+      const res = create(unsafeRes, jsonRpcResult(string()));
+
+      if ('error' in res) {
+        throw new Error('failed to get genesis hash: ' + res.error.message);
+      }
+
+      return res.result;
+    }
     /**
      * Fetch a processed block from the cluster.
      */
@@ -19749,7 +20333,15 @@ var solanaWeb3 = (function (exports) {
      */
 
 
-    async simulateTransaction(transaction, signers) {
+    async simulateTransaction(transactionOrMessage, signers, includeAccounts) {
+      let transaction;
+
+      if (transactionOrMessage instanceof Transaction) {
+        transaction = transactionOrMessage;
+      } else {
+        transaction = Transaction.populate(transactionOrMessage);
+      }
+
       if (transaction.nonceInfo && signers) {
         transaction.sign(...signers);
       } else {
@@ -19782,7 +20374,9 @@ var solanaWeb3 = (function (exports) {
         }
       }
 
-      const signData = transaction.serializeMessage();
+      const message = transaction._compile();
+
+      const signData = message.serialize();
 
       const wireTransaction = transaction._serialize(signData);
 
@@ -19792,6 +20386,14 @@ var solanaWeb3 = (function (exports) {
         commitment: this.commitment
       };
 
+      if (includeAccounts) {
+        const addresses = (Array.isArray(includeAccounts) ? includeAccounts : message.nonProgramIds()).map(key => key.toBase58());
+        config['accounts'] = {
+          encoding: 'base64',
+          addresses
+        };
+      }
+
       if (signers) {
         config.sigVerify = true;
       }
@@ -20672,6 +21274,96 @@ var solanaWeb3 = (function (exports) {
 
   }
 
+  const PRIVATE_KEY_BYTES$1 = 64;
+  const PUBLIC_KEY_BYTES$1 = 32;
+  const SIGNATURE_BYTES = 64;
+  /**
+   * Params for creating an ed25519 instruction using a public key
+   */
+
+  const ED25519_INSTRUCTION_LAYOUT = struct([u8('numSignatures'), u8('padding'), u16('signatureOffset'), u16('signatureInstructionIndex'), u16('publicKeyOffset'), u16('publicKeyInstructionIndex'), u16('messageDataOffset'), u16('messageDataSize'), u16('messageInstructionIndex')]);
+  class Ed25519Program {
+    /**
+     * @internal
+     */
+    constructor() {}
+    /**
+     * Public key that identifies the ed25519 program
+     */
+
+
+    /**
+     * Create an ed25519 instruction with a public key and signature. The
+     * public key must be a buffer that is 32 bytes long, and the signature
+     * must be a buffer of 64 bytes.
+     */
+    static createInstructionWithPublicKey(params) {
+      const {
+        publicKey,
+        message,
+        signature,
+        instructionIndex
+      } = params;
+      assert$i(publicKey.length === PUBLIC_KEY_BYTES$1, `Public Key must be ${PUBLIC_KEY_BYTES$1} bytes but received ${publicKey.length} bytes`);
+      assert$i(signature.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`);
+      const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
+      const signatureOffset = publicKeyOffset + publicKey.length;
+      const messageDataOffset = signatureOffset + signature.length;
+      const numSignatures = 1;
+      const instructionData = buffer.Buffer.alloc(messageDataOffset + message.length);
+      ED25519_INSTRUCTION_LAYOUT.encode({
+        numSignatures,
+        padding: 0,
+        signatureOffset,
+        signatureInstructionIndex: instructionIndex,
+        publicKeyOffset,
+        publicKeyInstructionIndex: instructionIndex,
+        messageDataOffset,
+        messageDataSize: message.length,
+        messageInstructionIndex: instructionIndex
+      }, instructionData);
+      instructionData.fill(publicKey, publicKeyOffset);
+      instructionData.fill(signature, signatureOffset);
+      instructionData.fill(message, messageDataOffset);
+      return new TransactionInstruction({
+        keys: [],
+        programId: Ed25519Program.programId,
+        data: instructionData
+      });
+    }
+    /**
+     * Create an ed25519 instruction with a private key. The private key
+     * must be a buffer that is 64 bytes long.
+     */
+
+
+    static createInstructionWithPrivateKey(params) {
+      const {
+        privateKey,
+        message,
+        instructionIndex
+      } = params;
+      assert$i(privateKey.length === PRIVATE_KEY_BYTES$1, `Private key must be ${PRIVATE_KEY_BYTES$1} bytes but received ${privateKey.length} bytes`);
+
+      try {
+        const keypair = Keypair.fromSecretKey(privateKey);
+        const publicKey = keypair.publicKey.toBytes();
+        const signature = nacl.sign.detached(message, keypair.secretKey);
+        return this.createInstructionWithPublicKey({
+          publicKey,
+          message,
+          signature,
+          instructionIndex
+        });
+      } catch (error) {
+        throw new Error(`Error creating instruction; ${error}`);
+      }
+    }
+
+  }
+
+  _defineProperty(Ed25519Program, "programId", new PublicKey('Ed25519SigVerify111111111111111111111111111'));
+
   /**
    * Address of the stake config account which configures the rate
    * of stake warmup and cooldown as well as the slashing penalty.
@@ -28679,6 +29371,7 @@ var solanaWeb3 = (function (exports) {
   exports.BPF_LOADER_PROGRAM_ID = BPF_LOADER_PROGRAM_ID;
   exports.BpfLoader = BpfLoader;
   exports.Connection = Connection;
+  exports.Ed25519Program = Ed25519Program;
   exports.Enum = Enum;
   exports.EpochSchedule = EpochSchedule;
   exports.FeeCalculatorLayout = FeeCalculatorLayout;