@solana/web3.js 1.11.1 → 1.12.1

package/lib/index.iife.js

@@ -8375,16 +8375,1091 @@ var solanaWeb3 = (function (exports) {
 	};
 	var sha256 = create$1('SHA-256');
 
+	var lib$1 = {};
+
+	var encoding_lib = {};
+
+	// This is free and unencumbered software released into the public domain.
+	// See LICENSE.md for more information.
+
+	//
+	// Utilities
+	//
+
+	/**
+	 * @param {number} a The number to test.
+	 * @param {number} min The minimum value in the range, inclusive.
+	 * @param {number} max The maximum value in the range, inclusive.
+	 * @return {boolean} True if a >= min and a <= max.
+	 */
+	function inRange(a, min, max) {
+	  return min <= a && a <= max;
+	}
+
+	/**
+	 * @param {*} o
+	 * @return {Object}
+	 */
+	function ToDictionary(o) {
+	  if (o === undefined) return {};
+	  if (o === Object(o)) return o;
+	  throw TypeError('Could not convert argument to dictionary');
+	}
+
+	/**
+	 * @param {string} string Input string of UTF-16 code units.
+	 * @return {!Array.<number>} Code points.
+	 */
+	function stringToCodePoints(string) {
+	  // https://heycam.github.io/webidl/#dfn-obtain-unicode
+
+	  // 1. Let S be the DOMString value.
+	  var s = String(string);
+
+	  // 2. Let n be the length of S.
+	  var n = s.length;
+
+	  // 3. Initialize i to 0.
+	  var i = 0;
+
+	  // 4. Initialize U to be an empty sequence of Unicode characters.
+	  var u = [];
+
+	  // 5. While i < n:
+	  while (i < n) {
+
+	    // 1. Let c be the code unit in S at index i.
+	    var c = s.charCodeAt(i);
+
+	    // 2. Depending on the value of c:
+
+	    // c < 0xD800 or c > 0xDFFF
+	    if (c < 0xD800 || c > 0xDFFF) {
+	      // Append to U the Unicode character with code point c.
+	      u.push(c);
+	    }
+
+	    // 0xDC00 ≤ c ≤ 0xDFFF
+	    else if (0xDC00 <= c && c <= 0xDFFF) {
+	      // Append to U a U+FFFD REPLACEMENT CHARACTER.
+	      u.push(0xFFFD);
+	    }
+
+	    // 0xD800 ≤ c ≤ 0xDBFF
+	    else if (0xD800 <= c && c <= 0xDBFF) {
+	      // 1. If i = n−1, then append to U a U+FFFD REPLACEMENT
+	      // CHARACTER.
+	      if (i === n - 1) {
+	        u.push(0xFFFD);
+	      }
+	      // 2. Otherwise, i < n−1:
+	      else {
+	        // 1. Let d be the code unit in S at index i+1.
+	        var d = string.charCodeAt(i + 1);
+
+	        // 2. If 0xDC00 ≤ d ≤ 0xDFFF, then:
+	        if (0xDC00 <= d && d <= 0xDFFF) {
+	          // 1. Let a be c & 0x3FF.
+	          var a = c & 0x3FF;
+
+	          // 2. Let b be d & 0x3FF.
+	          var b = d & 0x3FF;
+
+	          // 3. Append to U the Unicode character with code point
+	          // 2^16+2^10*a+b.
+	          u.push(0x10000 + (a << 10) + b);
+
+	          // 4. Set i to i+1.
+	          i += 1;
+	        }
+
+	        // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a
+	        // U+FFFD REPLACEMENT CHARACTER.
+	        else  {
+	          u.push(0xFFFD);
+	        }
+	      }
+	    }
+
+	    // 3. Set i to i+1.
+	    i += 1;
+	  }
+
+	  // 6. Return U.
+	  return u;
+	}
+
+	/**
+	 * @param {!Array.<number>} code_points Array of code points.
+	 * @return {string} string String of UTF-16 code units.
+	 */
+	function codePointsToString(code_points) {
+	  var s = '';
+	  for (var i = 0; i < code_points.length; ++i) {
+	    var cp = code_points[i];
+	    if (cp <= 0xFFFF) {
+	      s += String.fromCharCode(cp);
+	    } else {
+	      cp -= 0x10000;
+	      s += String.fromCharCode((cp >> 10) + 0xD800,
+	                               (cp & 0x3FF) + 0xDC00);
+	    }
+	  }
+	  return s;
+	}
+
+
+	//
+	// Implementation of Encoding specification
+	// https://encoding.spec.whatwg.org/
+	//
+
+	//
+	// 3. Terminology
+	//
+
+	/**
+	 * End-of-stream is a special token that signifies no more tokens
+	 * are in the stream.
+	 * @const
+	 */ var end_of_stream = -1;
+
+	/**
+	 * A stream represents an ordered sequence of tokens.
+	 *
+	 * @constructor
+	 * @param {!(Array.<number>|Uint8Array)} tokens Array of tokens that provide the
+	 * stream.
+	 */
+	function Stream(tokens) {
+	  /** @type {!Array.<number>} */
+	  this.tokens = [].slice.call(tokens);
+	}
+
+	Stream.prototype = {
+	  /**
+	   * @return {boolean} True if end-of-stream has been hit.
+	   */
+	  endOfStream: function() {
+	    return !this.tokens.length;
+	  },
+
+	  /**
+	   * When a token is read from a stream, the first token in the
+	   * stream must be returned and subsequently removed, and
+	   * end-of-stream must be returned otherwise.
+	   *
+	   * @return {number} Get the next token from the stream, or
+	   * end_of_stream.
+	   */
+	   read: function() {
+	    if (!this.tokens.length)
+	      return end_of_stream;
+	     return this.tokens.shift();
+	   },
+
+	  /**
+	   * When one or more tokens are prepended to a stream, those tokens
+	   * must be inserted, in given order, before the first token in the
+	   * stream.
+	   *
+	   * @param {(number|!Array.<number>)} token The token(s) to prepend to the stream.
+	   */
+	  prepend: function(token) {
+	    if (Array.isArray(token)) {
+	      var tokens = /**@type {!Array.<number>}*/(token);
+	      while (tokens.length)
+	        this.tokens.unshift(tokens.pop());
+	    } else {
+	      this.tokens.unshift(token);
+	    }
+	  },
+
+	  /**
+	   * When one or more tokens are pushed to a stream, those tokens
+	   * must be inserted, in given order, after the last token in the
+	   * stream.
+	   *
+	   * @param {(number|!Array.<number>)} token The tokens(s) to prepend to the stream.
+	   */
+	  push: function(token) {
+	    if (Array.isArray(token)) {
+	      var tokens = /**@type {!Array.<number>}*/(token);
+	      while (tokens.length)
+	        this.tokens.push(tokens.shift());
+	    } else {
+	      this.tokens.push(token);
+	    }
+	  }
+	};
+
+	//
+	// 4. Encodings
+	//
+
+	// 4.1 Encoders and decoders
+
+	/** @const */
+	var finished = -1;
+
+	/**
+	 * @param {boolean} fatal If true, decoding errors raise an exception.
+	 * @param {number=} opt_code_point Override the standard fallback code point.
+	 * @return {number} The code point to insert on a decoding error.
+	 */
+	function decoderError(fatal, opt_code_point) {
+	  if (fatal)
+	    throw TypeError('Decoder error');
+	  return opt_code_point || 0xFFFD;
+	}
+
+	//
+	// 7. API
+	//
+
+	/** @const */ var DEFAULT_ENCODING = 'utf-8';
+
+	// 7.1 Interface TextDecoder
+
+	/**
+	 * @constructor
+	 * @param {string=} encoding The label of the encoding;
+	 *     defaults to 'utf-8'.
+	 * @param {Object=} options
+	 */
+	function TextDecoder$1(encoding, options) {
+	  if (!(this instanceof TextDecoder$1)) {
+	    return new TextDecoder$1(encoding, options);
+	  }
+	  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;
+	  if (encoding !== DEFAULT_ENCODING) {
+	    throw new Error('Encoding not supported. Only utf-8 is supported');
+	  }
+	  options = ToDictionary(options);
+
+	  /** @private @type {boolean} */
+	  this._streaming = false;
+	  /** @private @type {boolean} */
+	  this._BOMseen = false;
+	  /** @private @type {?Decoder} */
+	  this._decoder = null;
+	  /** @private @type {boolean} */
+	  this._fatal = Boolean(options['fatal']);
+	  /** @private @type {boolean} */
+	  this._ignoreBOM = Boolean(options['ignoreBOM']);
+
+	  Object.defineProperty(this, 'encoding', {value: 'utf-8'});
+	  Object.defineProperty(this, 'fatal', {value: this._fatal});
+	  Object.defineProperty(this, 'ignoreBOM', {value: this._ignoreBOM});
+	}
+
+	TextDecoder$1.prototype = {
+	  /**
+	   * @param {ArrayBufferView=} input The buffer of bytes to decode.
+	   * @param {Object=} options
+	   * @return {string} The decoded string.
+	   */
+	  decode: function decode(input, options) {
+	    var bytes;
+	    if (typeof input === 'object' && input instanceof ArrayBuffer) {
+	      bytes = new Uint8Array(input);
+	    } else if (typeof input === 'object' && 'buffer' in input &&
+	               input.buffer instanceof ArrayBuffer) {
+	      bytes = new Uint8Array(input.buffer,
+	                             input.byteOffset,
+	                             input.byteLength);
+	    } else {
+	      bytes = new Uint8Array(0);
+	    }
+
+	    options = ToDictionary(options);
+
+	    if (!this._streaming) {
+	      this._decoder = new UTF8Decoder({fatal: this._fatal});
+	      this._BOMseen = false;
+	    }
+	    this._streaming = Boolean(options['stream']);
+
+	    var input_stream = new Stream(bytes);
+
+	    var code_points = [];
+
+	    /** @type {?(number|!Array.<number>)} */
+	    var result;
+
+	    while (!input_stream.endOfStream()) {
+	      result = this._decoder.handler(input_stream, input_stream.read());
+	      if (result === finished)
+	        break;
+	      if (result === null)
+	        continue;
+	      if (Array.isArray(result))
+	        code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));
+	      else
+	        code_points.push(result);
+	    }
+	    if (!this._streaming) {
+	      do {
+	        result = this._decoder.handler(input_stream, input_stream.read());
+	        if (result === finished)
+	          break;
+	        if (result === null)
+	          continue;
+	        if (Array.isArray(result))
+	          code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));
+	        else
+	          code_points.push(result);
+	      } while (!input_stream.endOfStream());
+	      this._decoder = null;
+	    }
+
+	    if (code_points.length) {
+	      // If encoding is one of utf-8, utf-16be, and utf-16le, and
+	      // ignore BOM flag and BOM seen flag are unset, run these
+	      // subsubsteps:
+	      if (['utf-8'].indexOf(this.encoding) !== -1 &&
+	          !this._ignoreBOM && !this._BOMseen) {
+	        // If token is U+FEFF, set BOM seen flag.
+	        if (code_points[0] === 0xFEFF) {
+	          this._BOMseen = true;
+	          code_points.shift();
+	        } else {
+	          // Otherwise, if token is not end-of-stream, set BOM seen
+	          // flag and append token to output.
+	          this._BOMseen = true;
+	        }
+	      }
+	    }
+
+	    return codePointsToString(code_points);
+	  }
+	};
+
+	// 7.2 Interface TextEncoder
+
+	/**
+	 * @constructor
+	 * @param {string=} encoding The label of the encoding;
+	 *     defaults to 'utf-8'.
+	 * @param {Object=} options
+	 */
+	function TextEncoder$1(encoding, options) {
+	  if (!(this instanceof TextEncoder$1))
+	    return new TextEncoder$1(encoding, options);
+	  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;
+	  if (encoding !== DEFAULT_ENCODING) {
+	    throw new Error('Encoding not supported. Only utf-8 is supported');
+	  }
+	  options = ToDictionary(options);
+
+	  /** @private @type {boolean} */
+	  this._streaming = false;
+	  /** @private @type {?Encoder} */
+	  this._encoder = null;
+	  /** @private @type {{fatal: boolean}} */
+	  this._options = {fatal: Boolean(options['fatal'])};
+
+	  Object.defineProperty(this, 'encoding', {value: 'utf-8'});
+	}
+
+	TextEncoder$1.prototype = {
+	  /**
+	   * @param {string=} opt_string The string to encode.
+	   * @param {Object=} options
+	   * @return {Uint8Array} Encoded bytes, as a Uint8Array.
+	   */
+	  encode: function encode(opt_string, options) {
+	    opt_string = opt_string ? String(opt_string) : '';
+	    options = ToDictionary(options);
+
+	    // NOTE: This option is nonstandard. None of the encodings
+	    // permitted for encoding (i.e. UTF-8, UTF-16) are stateful,
+	    // so streaming is not necessary.
+	    if (!this._streaming)
+	      this._encoder = new UTF8Encoder(this._options);
+	    this._streaming = Boolean(options['stream']);
+
+	    var bytes = [];
+	    var input_stream = new Stream(stringToCodePoints(opt_string));
+	    /** @type {?(number|!Array.<number>)} */
+	    var result;
+	    while (!input_stream.endOfStream()) {
+	      result = this._encoder.handler(input_stream, input_stream.read());
+	      if (result === finished)
+	        break;
+	      if (Array.isArray(result))
+	        bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));
+	      else
+	        bytes.push(result);
+	    }
+	    if (!this._streaming) {
+	      while (true) {
+	        result = this._encoder.handler(input_stream, input_stream.read());
+	        if (result === finished)
+	          break;
+	        if (Array.isArray(result))
+	          bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));
+	        else
+	          bytes.push(result);
+	      }
+	      this._encoder = null;
+	    }
+	    return new Uint8Array(bytes);
+	  }
+	};
+
+	//
+	// 8. The encoding
+	//
+
+	// 8.1 utf-8
+
+	/**
+	 * @constructor
+	 * @implements {Decoder}
+	 * @param {{fatal: boolean}} options
+	 */
+	function UTF8Decoder(options) {
+	  var fatal = options.fatal;
+
+	  // utf-8's decoder's has an associated utf-8 code point, utf-8
+	  // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8
+	  // lower boundary (initially 0x80), and a utf-8 upper boundary
+	  // (initially 0xBF).
+	  var /** @type {number} */ utf8_code_point = 0,
+	      /** @type {number} */ utf8_bytes_seen = 0,
+	      /** @type {number} */ utf8_bytes_needed = 0,
+	      /** @type {number} */ utf8_lower_boundary = 0x80,
+	      /** @type {number} */ utf8_upper_boundary = 0xBF;
+
+	  /**
+	   * @param {Stream} stream The stream of bytes being decoded.
+	   * @param {number} bite The next byte read from the stream.
+	   * @return {?(number|!Array.<number>)} The next code point(s)
+	   *     decoded, or null if not enough data exists in the input
+	   *     stream to decode a complete code point.
+	   */
+	  this.handler = function(stream, bite) {
+	    // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,
+	    // set utf-8 bytes needed to 0 and return error.
+	    if (bite === end_of_stream && utf8_bytes_needed !== 0) {
+	      utf8_bytes_needed = 0;
+	      return decoderError(fatal);
+	    }
+
+	    // 2. If byte is end-of-stream, return finished.
+	    if (bite === end_of_stream)
+	      return finished;
+
+	    // 3. If utf-8 bytes needed is 0, based on byte:
+	    if (utf8_bytes_needed === 0) {
+
+	      // 0x00 to 0x7F
+	      if (inRange(bite, 0x00, 0x7F)) {
+	        // Return a code point whose value is byte.
+	        return bite;
+	      }
+
+	      // 0xC2 to 0xDF
+	      if (inRange(bite, 0xC2, 0xDF)) {
+	        // Set utf-8 bytes needed to 1 and utf-8 code point to byte
+	        // − 0xC0.
+	        utf8_bytes_needed = 1;
+	        utf8_code_point = bite - 0xC0;
+	      }
+
+	      // 0xE0 to 0xEF
+	      else if (inRange(bite, 0xE0, 0xEF)) {
+	        // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.
+	        if (bite === 0xE0)
+	          utf8_lower_boundary = 0xA0;
+	        // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.
+	        if (bite === 0xED)
+	          utf8_upper_boundary = 0x9F;
+	        // 3. Set utf-8 bytes needed to 2 and utf-8 code point to
+	        // byte − 0xE0.
+	        utf8_bytes_needed = 2;
+	        utf8_code_point = bite - 0xE0;
+	      }
+
+	      // 0xF0 to 0xF4
+	      else if (inRange(bite, 0xF0, 0xF4)) {
+	        // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.
+	        if (bite === 0xF0)
+	          utf8_lower_boundary = 0x90;
+	        // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.
+	        if (bite === 0xF4)
+	          utf8_upper_boundary = 0x8F;
+	        // 3. Set utf-8 bytes needed to 3 and utf-8 code point to
+	        // byte − 0xF0.
+	        utf8_bytes_needed = 3;
+	        utf8_code_point = bite - 0xF0;
+	      }
+
+	      // Otherwise
+	      else {
+	        // Return error.
+	        return decoderError(fatal);
+	      }
+
+	      // Then (byte is in the range 0xC2 to 0xF4) set utf-8 code
+	      // point to utf-8 code point << (6 × utf-8 bytes needed) and
+	      // return continue.
+	      utf8_code_point = utf8_code_point << (6 * utf8_bytes_needed);
+	      return null;
+	    }
+
+	    // 4. If byte is not in the range utf-8 lower boundary to utf-8
+	    // upper boundary, run these substeps:
+	    if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {
+
+	      // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8
+	      // bytes seen to 0, set utf-8 lower boundary to 0x80, and set
+	      // utf-8 upper boundary to 0xBF.
+	      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+	      utf8_lower_boundary = 0x80;
+	      utf8_upper_boundary = 0xBF;
+
+	      // 2. Prepend byte to stream.
+	      stream.prepend(bite);
+
+	      // 3. Return error.
+	      return decoderError(fatal);
+	    }
+
+	    // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary
+	    // to 0xBF.
+	    utf8_lower_boundary = 0x80;
+	    utf8_upper_boundary = 0xBF;
+
+	    // 6. Increase utf-8 bytes seen by one and set utf-8 code point
+	    // to utf-8 code point + (byte − 0x80) << (6 × (utf-8 bytes
+	    // needed − utf-8 bytes seen)).
+	    utf8_bytes_seen += 1;
+	    utf8_code_point += (bite - 0x80) << (6 * (utf8_bytes_needed - utf8_bytes_seen));
+
+	    // 7. If utf-8 bytes seen is not equal to utf-8 bytes needed,
+	    // continue.
+	    if (utf8_bytes_seen !== utf8_bytes_needed)
+	      return null;
+
+	    // 8. Let code point be utf-8 code point.
+	    var code_point = utf8_code_point;
+
+	    // 9. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes
+	    // seen to 0.
+	    utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+
+	    // 10. Return a code point whose value is code point.
+	    return code_point;
+	  };
+	}
+
+	/**
+	 * @constructor
+	 * @implements {Encoder}
+	 * @param {{fatal: boolean}} options
+	 */
+	function UTF8Encoder(options) {
+	  options.fatal;
+	  /**
+	   * @param {Stream} stream Input stream.
+	   * @param {number} code_point Next code point read from the stream.
+	   * @return {(number|!Array.<number>)} Byte(s) to emit.
+	   */
+	  this.handler = function(stream, code_point) {
+	    // 1. If code point is end-of-stream, return finished.
+	    if (code_point === end_of_stream)
+	      return finished;
+
+	    // 2. If code point is in the range U+0000 to U+007F, return a
+	    // byte whose value is code point.
+	    if (inRange(code_point, 0x0000, 0x007f))
+	      return code_point;
+
+	    // 3. Set count and offset based on the range code point is in:
+	    var count, offset;
+	    // U+0080 to U+07FF:    1 and 0xC0
+	    if (inRange(code_point, 0x0080, 0x07FF)) {
+	      count = 1;
+	      offset = 0xC0;
+	    }
+	    // U+0800 to U+FFFF:    2 and 0xE0
+	    else if (inRange(code_point, 0x0800, 0xFFFF)) {
+	      count = 2;
+	      offset = 0xE0;
+	    }
+	    // U+10000 to U+10FFFF: 3 and 0xF0
+	    else if (inRange(code_point, 0x10000, 0x10FFFF)) {
+	      count = 3;
+	      offset = 0xF0;
+	    }
+
+	    // 4.Let bytes be a byte sequence whose first byte is (code
+	    // point >> (6 × count)) + offset.
+	    var bytes = [(code_point >> (6 * count)) + offset];
+
+	    // 5. Run these substeps while count is greater than 0:
+	    while (count > 0) {
+
+	      // 1. Set temp to code point >> (6 × (count − 1)).
+	      var temp = code_point >> (6 * (count - 1));
+
+	      // 2. Append to bytes 0x80 | (temp & 0x3F).
+	      bytes.push(0x80 | (temp & 0x3F));
+
+	      // 3. Decrease count by one.
+	      count -= 1;
+	    }
+
+	    // 6. Return bytes bytes, in order.
+	    return bytes;
+	  };
+	}
+
+	encoding_lib.TextEncoder = TextEncoder$1;
+	encoding_lib.TextDecoder = TextDecoder$1;
+
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
+	    Object.defineProperty(o, "default", { enumerable: true, value: v });
+	}) : function(o, v) {
+	    o["default"] = v;
+	});
+	var __decorate = (commonjsGlobal && commonjsGlobal.__decorate) || function (decorators, target, key, desc) {
+	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	    return c > 3 && r && Object.defineProperty(target, key, r), r;
+	};
+	var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
+	    if (mod && mod.__esModule) return mod;
+	    var result = {};
+	    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	    __setModuleDefault(result, mod);
+	    return result;
+	};
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(lib$1, "__esModule", { value: true });
+	lib$1.deserializeUnchecked = deserialize_1 = lib$1.deserialize = serialize_1 = lib$1.serialize = lib$1.BinaryReader = lib$1.BinaryWriter = lib$1.BorshError = lib$1.baseDecode = lib$1.baseEncode = void 0;
+	const bn_js_1 = __importDefault(bn.exports);
+	const bs58_1 = __importDefault(bs58);
+	// TODO: Make sure this polyfill not included when not required
+	const encoding = __importStar(encoding_lib);
+	const TextDecoder = (typeof commonjsGlobal.TextDecoder !== 'function') ? encoding.TextDecoder : commonjsGlobal.TextDecoder;
+	const textDecoder = new TextDecoder('utf-8', { fatal: true });
+	function baseEncode(value) {
+	    if (typeof (value) === 'string') {
+	        value = buffer.Buffer.from(value, 'utf8');
+	    }
+	    return bs58_1.default.encode(buffer.Buffer.from(value));
+	}
+	lib$1.baseEncode = baseEncode;
+	function baseDecode(value) {
+	    return buffer.Buffer.from(bs58_1.default.decode(value));
+	}
+	lib$1.baseDecode = baseDecode;
+	const INITIAL_LENGTH = 1024;
+	class BorshError extends Error {
+	    constructor(message) {
+	        super(message);
+	        this.fieldPath = [];
+	        this.originalMessage = message;
+	    }
+	    addToFieldPath(fieldName) {
+	        this.fieldPath.splice(0, 0, fieldName);
+	        // NOTE: Modifying message directly as jest doesn't use .toString()
+	        this.message = this.originalMessage + ': ' + this.fieldPath.join('.');
+	    }
+	}
+	lib$1.BorshError = BorshError;
+	/// Binary encoder.
+	class BinaryWriter {
+	    constructor() {
+	        this.buf = buffer.Buffer.alloc(INITIAL_LENGTH);
+	        this.length = 0;
+	    }
+	    maybeResize() {
+	        if (this.buf.length < 16 + this.length) {
+	            this.buf = buffer.Buffer.concat([this.buf, buffer.Buffer.alloc(INITIAL_LENGTH)]);
+	        }
+	    }
+	    writeU8(value) {
+	        this.maybeResize();
+	        this.buf.writeUInt8(value, this.length);
+	        this.length += 1;
+	    }
+	    writeU16(value) {
+	        this.maybeResize();
+	        this.buf.writeUInt16LE(value, this.length);
+	        this.length += 2;
+	    }
+	    writeU32(value) {
+	        this.maybeResize();
+	        this.buf.writeUInt32LE(value, this.length);
+	        this.length += 4;
+	    }
+	    writeU64(value) {
+	        this.maybeResize();
+	        this.writeBuffer(buffer.Buffer.from(new bn_js_1.default(value).toArray('le', 8)));
+	    }
+	    writeU128(value) {
+	        this.maybeResize();
+	        this.writeBuffer(buffer.Buffer.from(new bn_js_1.default(value).toArray('le', 16)));
+	    }
+	    writeU256(value) {
+	        this.maybeResize();
+	        this.writeBuffer(buffer.Buffer.from(new bn_js_1.default(value).toArray('le', 32)));
+	    }
+	    writeU512(value) {
+	        this.maybeResize();
+	        this.writeBuffer(buffer.Buffer.from(new bn_js_1.default(value).toArray('le', 64)));
+	    }
+	    writeBuffer(buffer$1) {
+	        // Buffer.from is needed as this.buf.subarray can return plain Uint8Array in browser
+	        this.buf = buffer.Buffer.concat([buffer.Buffer.from(this.buf.subarray(0, this.length)), buffer$1, buffer.Buffer.alloc(INITIAL_LENGTH)]);
+	        this.length += buffer$1.length;
+	    }
+	    writeString(str) {
+	        this.maybeResize();
+	        const b = buffer.Buffer.from(str, 'utf8');
+	        this.writeU32(b.length);
+	        this.writeBuffer(b);
+	    }
+	    writeFixedArray(array) {
+	        this.writeBuffer(buffer.Buffer.from(array));
+	    }
+	    writeArray(array, fn) {
+	        this.maybeResize();
+	        this.writeU32(array.length);
+	        for (const elem of array) {
+	            this.maybeResize();
+	            fn(elem);
+	        }
+	    }
+	    toArray() {
+	        return this.buf.subarray(0, this.length);
+	    }
+	}
+	lib$1.BinaryWriter = BinaryWriter;
+	function handlingRangeError(target, propertyKey, propertyDescriptor) {
+	    const originalMethod = propertyDescriptor.value;
+	    propertyDescriptor.value = function (...args) {
+	        try {
+	            return originalMethod.apply(this, args);
+	        }
+	        catch (e) {
+	            if (e instanceof RangeError) {
+	                const code = e.code;
+	                if (['ERR_BUFFER_OUT_OF_BOUNDS', 'ERR_OUT_OF_RANGE'].indexOf(code) >= 0) {
+	                    throw new BorshError('Reached the end of buffer when deserializing');
+	                }
+	            }
+	            throw e;
+	        }
+	    };
+	}
+	class BinaryReader {
+	    constructor(buf) {
+	        this.buf = buf;
+	        this.offset = 0;
+	    }
+	    readU8() {
+	        const value = this.buf.readUInt8(this.offset);
+	        this.offset += 1;
+	        return value;
+	    }
+	    readU16() {
+	        const value = this.buf.readUInt16LE(this.offset);
+	        this.offset += 2;
+	        return value;
+	    }
+	    readU32() {
+	        const value = this.buf.readUInt32LE(this.offset);
+	        this.offset += 4;
+	        return value;
+	    }
+	    readU64() {
+	        const buf = this.readBuffer(8);
+	        return new bn_js_1.default(buf, 'le');
+	    }
+	    readU128() {
+	        const buf = this.readBuffer(16);
+	        return new bn_js_1.default(buf, 'le');
+	    }
+	    readU256() {
+	        const buf = this.readBuffer(32);
+	        return new bn_js_1.default(buf, 'le');
+	    }
+	    readU512() {
+	        const buf = this.readBuffer(64);
+	        return new bn_js_1.default(buf, 'le');
+	    }
+	    readBuffer(len) {
+	        if ((this.offset + len) > this.buf.length) {
+	            throw new BorshError(`Expected buffer length ${len} isn't within bounds`);
+	        }
+	        const result = this.buf.slice(this.offset, this.offset + len);
+	        this.offset += len;
+	        return result;
+	    }
+	    readString() {
+	        const len = this.readU32();
+	        const buf = this.readBuffer(len);
+	        try {
+	            // NOTE: Using TextDecoder to fail on invalid UTF-8
+	            return textDecoder.decode(buf);
+	        }
+	        catch (e) {
+	            throw new BorshError(`Error decoding UTF-8 string: ${e}`);
+	        }
+	    }
+	    readFixedArray(len) {
+	        return new Uint8Array(this.readBuffer(len));
+	    }
+	    readArray(fn) {
+	        const len = this.readU32();
+	        const result = Array();
+	        for (let i = 0; i < len; ++i) {
+	            result.push(fn());
+	        }
+	        return result;
+	    }
+	}
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readU8", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readU16", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readU32", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readU64", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readU128", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readU256", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readU512", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readString", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readFixedArray", null);
+	__decorate([
+	    handlingRangeError
+	], BinaryReader.prototype, "readArray", null);
+	lib$1.BinaryReader = BinaryReader;
+	function capitalizeFirstLetter(string) {
+	    return string.charAt(0).toUpperCase() + string.slice(1);
+	}
+	function serializeField(schema, fieldName, value, fieldType, writer) {
+	    try {
+	        // TODO: Handle missing values properly (make sure they never result in just skipped write)
+	        if (typeof fieldType === 'string') {
+	            writer[`write${capitalizeFirstLetter(fieldType)}`](value);
+	        }
+	        else if (fieldType instanceof Array) {
+	            if (typeof fieldType[0] === 'number') {
+	                if (value.length !== fieldType[0]) {
+	                    throw new BorshError(`Expecting byte array of length ${fieldType[0]}, but got ${value.length} bytes`);
+	                }
+	                writer.writeFixedArray(value);
+	            }
+	            else {
+	                writer.writeArray(value, (item) => { serializeField(schema, fieldName, item, fieldType[0], writer); });
+	            }
+	        }
+	        else if (fieldType.kind !== undefined) {
+	            switch (fieldType.kind) {
+	                case 'option': {
+	                    if (value === null || value === undefined) {
+	                        writer.writeU8(0);
+	                    }
+	                    else {
+	                        writer.writeU8(1);
+	                        serializeField(schema, fieldName, value, fieldType.type, writer);
+	                    }
+	                    break;
+	                }
+	                default: throw new BorshError(`FieldType ${fieldType} unrecognized`);
+	            }
+	        }
+	        else {
+	            serializeStruct(schema, value, writer);
+	        }
+	    }
+	    catch (error) {
+	        if (error instanceof BorshError) {
+	            error.addToFieldPath(fieldName);
+	        }
+	        throw error;
+	    }
+	}
+	function serializeStruct(schema, obj, writer) {
+	    const structSchema = schema.get(obj.constructor);
+	    if (!structSchema) {
+	        throw new BorshError(`Class ${obj.constructor.name} is missing in schema`);
+	    }
+	    if (structSchema.kind === 'struct') {
+	        structSchema.fields.map(([fieldName, fieldType]) => {
+	            serializeField(schema, fieldName, obj[fieldName], fieldType, writer);
+	        });
+	    }
+	    else if (structSchema.kind === 'enum') {
+	        const name = obj[structSchema.field];
+	        for (let idx = 0; idx < structSchema.values.length; ++idx) {
+	            const [fieldName, fieldType] = structSchema.values[idx];
+	            if (fieldName === name) {
+	                writer.writeU8(idx);
+	                serializeField(schema, fieldName, obj[fieldName], fieldType, writer);
+	                break;
+	            }
+	        }
+	    }
+	    else {
+	        throw new BorshError(`Unexpected schema kind: ${structSchema.kind} for ${obj.constructor.name}`);
+	    }
+	}
+	/// Serialize given object using schema of the form:
+	/// { class_name -> [ [field_name, field_type], .. ], .. }
+	function serialize(schema, obj) {
+	    const writer = new BinaryWriter();
+	    serializeStruct(schema, obj, writer);
+	    return writer.toArray();
+	}
+	var serialize_1 = lib$1.serialize = serialize;
+	function deserializeField(schema, fieldName, fieldType, reader) {
+	    try {
+	        if (typeof fieldType === 'string') {
+	            return reader[`read${capitalizeFirstLetter(fieldType)}`]();
+	        }
+	        if (fieldType instanceof Array) {
+	            if (typeof fieldType[0] === 'number') {
+	                return reader.readFixedArray(fieldType[0]);
+	            }
+	            return reader.readArray(() => deserializeField(schema, fieldName, fieldType[0], reader));
+	        }
+	        if (fieldType.kind === 'option') {
+	            const option = reader.readU8();
+	            if (option) {
+	                return deserializeField(schema, fieldName, fieldType.type, reader);
+	            }
+	            return undefined;
+	        }
+	        return deserializeStruct(schema, fieldType, reader);
+	    }
+	    catch (error) {
+	        if (error instanceof BorshError) {
+	            error.addToFieldPath(fieldName);
+	        }
+	        throw error;
+	    }
+	}
+	function deserializeStruct(schema, classType, reader) {
+	    const structSchema = schema.get(classType);
+	    if (!structSchema) {
+	        throw new BorshError(`Class ${classType.name} is missing in schema`);
+	    }
+	    if (structSchema.kind === 'struct') {
+	        const result = {};
+	        for (const [fieldName, fieldType] of schema.get(classType).fields) {
+	            result[fieldName] = deserializeField(schema, fieldName, fieldType, reader);
+	        }
+	        return new classType(result);
+	    }
+	    if (structSchema.kind === 'enum') {
+	        const idx = reader.readU8();
+	        if (idx >= structSchema.values.length) {
+	            throw new BorshError(`Enum index: ${idx} is out of range`);
+	        }
+	        const [fieldName, fieldType] = structSchema.values[idx];
+	        const fieldValue = deserializeField(schema, fieldName, fieldType, reader);
+	        return new classType({ [fieldName]: fieldValue });
+	    }
+	    throw new BorshError(`Unexpected schema kind: ${structSchema.kind} for ${classType.constructor.name}`);
+	}
+	/// Deserializes object from bytes using schema.
+	function deserialize(schema, classType, buffer) {
+	    const reader = new BinaryReader(buffer);
+	    const result = deserializeStruct(schema, classType, reader);
+	    if (reader.offset < buffer.length) {
+	        throw new BorshError(`Unexpected ${buffer.length - reader.offset} bytes after deserialized data`);
+	    }
+	    return result;
+	}
+	var deserialize_1 = lib$1.deserialize = deserialize;
+	/// Deserializes object from bytes using schema, without checking the length read
+	function deserializeUnchecked(schema, classType, buffer) {
+	    const reader = new BinaryReader(buffer);
+	    return deserializeStruct(schema, classType, reader);
+	}
+	lib$1.deserializeUnchecked = deserializeUnchecked;
+
+	class Struct$1 {
+	  constructor(properties) {
+	    Object.assign(this, properties);
+	  }
+
+	  encode() {
+	    return buffer.Buffer.from(serialize_1(SOLANA_SCHEMA, this));
+	  }
+
+	  static decode(data) {
+	    return deserialize_1(SOLANA_SCHEMA, this, data);
+	  }
+
+	} // Class representing a Rust-compatible enum, since enums are only strings or
+	// numbers in pure JS
+
+	class Enum extends Struct$1 {
+	  constructor(properties) {
+	    super(properties);
+
+	    _defineProperty(this, "enum", '');
+
+	    if (Object.keys(properties).length !== 1) {
+	      throw new Error('Enum can only take single value');
+	    }
+
+	    Object.keys(properties).map(key => {
+	      this.enum = key;
+	    });
+	  }
+
+	}
+	const SOLANA_SCHEMA = new Map();
+
 	/**
 	 * Maximum length of derived pubkey seed
 	 */
 
 	const MAX_SEED_LENGTH = 32;
+
+	function isPublicKeyData(value) {
+	  return value._bn !== undefined;
+	}
 	/**
 	 * A public key
 	 */
 
-	class PublicKey {
+
+	class PublicKey extends Struct$1 {
 	  /** @internal */
 
 	  /**
@@ -8392,21 +9467,27 @@ var solanaWeb3 = (function (exports) {
 	   * @param value ed25519 public key as buffer or base-58 encoded string
 	   */
 	  constructor(value) {
-	    if (typeof value === 'string') {
-	      // assume base 58 encoding by default
-	      const decoded = bs58.decode(value);
-
-	      if (decoded.length != 32) {
-	        throw new Error("Invalid public key input");
-	      }
+	    super({});
 
-	      this._bn = new BN$9(decoded);
+	    if (isPublicKeyData(value)) {
+	      this._bn = value._bn;
 	    } else {
-	      this._bn = new BN$9(value);
-	    }
+	      if (typeof value === 'string') {
+	        // assume base 58 encoding by default
+	        const decoded = bs58.decode(value);
+
+	        if (decoded.length != 32) {
+	          throw new Error("Invalid public key input");
+	        }
+
+	        this._bn = new BN$9(decoded);
+	      } else {
+	        this._bn = new BN$9(value);
+	      }
 
-	    if (this._bn.byteLength() > 32) {
-	      throw new Error("Invalid public key input");
+	      if (this._bn.byteLength() > 32) {
+	        throw new Error("Invalid public key input");
+	      }
 	    }
 	  }
 	  /**
@@ -8534,10 +9615,15 @@ var solanaWeb3 = (function (exports) {
 	    return is_on_curve(pubkey) == 1;
 	  }
 
-	} // @ts-ignore
+	}
 
 	_defineProperty(PublicKey, "default", new PublicKey('11111111111111111111111111111111'));
 
+	SOLANA_SCHEMA.set(PublicKey, {
+	  kind: 'struct',
+	  fields: [['_bn', 'u256']]
+	}); // @ts-ignore
+
 	let naclLowLevel = nacl.lowlevel; // Check that a pubkey is on the curve.
 	// This function and its dependents were sourced from:
 	// https://github.com/dchest/tweetnacl-js/blob/f1ec050ceae0861f34280e62498b1d3ed9c350c6/nacl.js#L792
@@ -27736,6 +28822,7 @@ var solanaWeb3 = (function (exports) {
 	exports.BPF_LOADER_PROGRAM_ID = BPF_LOADER_PROGRAM_ID;
 	exports.BpfLoader = BpfLoader;
 	exports.Connection = Connection;
+	exports.Enum = Enum;
 	exports.FeeCalculatorLayout = FeeCalculatorLayout;
 	exports.Keypair = Keypair;
 	exports.LAMPORTS_PER_SOL = LAMPORTS_PER_SOL;
@@ -27747,6 +28834,7 @@ var solanaWeb3 = (function (exports) {
 	exports.NonceAccount = NonceAccount;
 	exports.PACKET_DATA_SIZE = PACKET_DATA_SIZE;
 	exports.PublicKey = PublicKey;
+	exports.SOLANA_SCHEMA = SOLANA_SCHEMA;
 	exports.STAKE_CONFIG_ID = STAKE_CONFIG_ID;
 	exports.STAKE_INSTRUCTION_LAYOUTS = STAKE_INSTRUCTION_LAYOUTS;
 	exports.SYSTEM_INSTRUCTION_LAYOUTS = SYSTEM_INSTRUCTION_LAYOUTS;
@@ -27760,6 +28848,7 @@ var solanaWeb3 = (function (exports) {
 	exports.StakeAuthorizationLayout = StakeAuthorizationLayout;
 	exports.StakeInstruction = StakeInstruction;
 	exports.StakeProgram = StakeProgram;
+	exports.Struct = Struct$1;
 	exports.SystemInstruction = SystemInstruction;
 	exports.SystemProgram = SystemProgram;
 	exports.Transaction = Transaction;