@solana/web3.js 1.98.0 → 1.98.1

package/lib/index.iife.js

@@ -14074,106 +14074,227 @@ var solanaWeb3 = (function (exports) {
 	  }
 	}
 
-	var browser$1 = {};
-
-	var hasRequiredBrowser$1;
-
-	function requireBrowser$1 () {
-		if (hasRequiredBrowser$1) return browser$1;
-		hasRequiredBrowser$1 = 1;
+	// src/codes.ts
+	var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY = 8078e3;
+	var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH = 8078001;
+	var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH = 8078004;
+	var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH = 8078005;
+	var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH = 8078006;
+	var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE = 8078011;
+
+	// src/context.ts
+	function encodeValue(value) {
+	  if (Array.isArray(value)) {
+	    const commaSeparatedValues = value.map(encodeValue).join(
+	      "%2C%20"
+	      /* ", " */
+	    );
+	    return "%5B" + commaSeparatedValues + /* "]" */
+	    "%5D";
+	  } else if (typeof value === "bigint") {
+	    return `${value}n`;
+	  } else {
+	    return encodeURIComponent(
+	      String(
+	        value != null && Object.getPrototypeOf(value) === null ? (
+	          // Plain objects with no prototype don't have a `toString` method.
+	          // Convert them before stringifying them.
+	          { ...value }
+	        ) : value
+	      )
+	    );
+	  }
+	}
+	function encodeObjectContextEntry([key, value]) {
+	  return `${key}=${encodeValue(value)}`;
+	}
+	function encodeContextObject(context) {
+	  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry).join("&");
+	  return btoa(searchParamsString);
+	}
+	function getErrorMessage(code, context = {}) {
+	  {
+	    let decodingAdviceMessage = `Solana error #${code}; Decode this error by running \`npx @solana/errors decode -- ${code}`;
+	    if (Object.keys(context).length) {
+	      decodingAdviceMessage += ` '${encodeContextObject(context)}'`;
+	    }
+	    return `${decodingAdviceMessage}\``;
+	  }
+	}
+	var SolanaError = class extends Error {
+	  /**
+	   * Indicates the root cause of this {@link SolanaError}, if any.
+	   *
+	   * For example, a transaction error might have an instruction error as its root cause. In this
+	   * case, you will be able to access the instruction error on the transaction error as `cause`.
+	   */
+	  cause = this.cause;
+	  /**
+	   * Contains context that can assist in understanding or recovering from a {@link SolanaError}.
+	   */
+	  context;
+	  constructor(...[code, contextAndErrorOptions]) {
+	    let context;
+	    let errorOptions;
+	    if (contextAndErrorOptions) {
+	      const { cause, ...contextRest } = contextAndErrorOptions;
+	      if (cause) {
+	        errorOptions = { cause };
+	      }
+	      if (Object.keys(contextRest).length > 0) {
+	        context = contextRest;
+	      }
+	    }
+	    const message = getErrorMessage(code, context);
+	    super(message, errorOptions);
+	    this.context = {
+	      __code: code,
+	      ...context
+	    };
+	    this.name = "SolanaError";
+	  }
+	};
 
-		Object.defineProperty(browser$1, "__esModule", { value: true });
-		/**
-		 * Convert a little-endian buffer into a BigInt.
-		 * @param buf The little-endian buffer to convert
-		 * @returns A BigInt with the little-endian representation of buf.
-		 */
-		function toBigIntLE(buf) {
-		    {
-		        const reversed = Buffer.from(buf);
-		        reversed.reverse();
-		        const hex = reversed.toString('hex');
-		        if (hex.length === 0) {
-		            return BigInt(0);
-		        }
-		        return BigInt(`0x${hex}`);
-		    }
-		}
-		browser$1.toBigIntLE = toBigIntLE;
-		/**
-		 * Convert a big-endian buffer into a BigInt
-		 * @param buf The big-endian buffer to convert.
-		 * @returns A BigInt with the big-endian representation of buf.
-		 */
-		function toBigIntBE(buf) {
-		    {
-		        const hex = buf.toString('hex');
-		        if (hex.length === 0) {
-		            return BigInt(0);
-		        }
-		        return BigInt(`0x${hex}`);
-		    }
-		}
-		browser$1.toBigIntBE = toBigIntBE;
-		/**
-		 * Convert a BigInt to a little-endian buffer.
-		 * @param num   The BigInt to convert.
-		 * @param width The number of bytes that the resulting buffer should be.
-		 * @returns A little-endian buffer representation of num.
-		 */
-		function toBufferLE(num, width) {
-		    {
-		        const hex = num.toString(16);
-		        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-		        buffer.reverse();
-		        return buffer;
-		    }
-		}
-		browser$1.toBufferLE = toBufferLE;
-		/**
-		 * Convert a BigInt to a big-endian buffer.
-		 * @param num   The BigInt to convert.
-		 * @param width The number of bytes that the resulting buffer should be.
-		 * @returns A big-endian buffer representation of num.
-		 */
-		function toBufferBE(num, width) {
-		    {
-		        const hex = num.toString(16);
-		        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-		    }
-		}
-		browser$1.toBufferBE = toBufferBE;
-		return browser$1;
+	function getEncodedSize(value, encoder) {
+	  return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+	}
+	function createEncoder(encoder) {
+	  return Object.freeze({
+	    ...encoder,
+	    encode: (value) => {
+	      const bytes = new Uint8Array(getEncodedSize(value, encoder));
+	      encoder.write(value, bytes, 0);
+	      return bytes;
+	    }
+	  });
+	}
+	function createDecoder(decoder) {
+	  return Object.freeze({
+	    ...decoder,
+	    decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+	  });
+	}
+	function isFixedSize(codec) {
+	  return "fixedSize" in codec && typeof codec.fixedSize === "number";
+	}
+	function combineCodec(encoder, decoder) {
+	  if (isFixedSize(encoder) !== isFixedSize(decoder)) {
+	    throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH);
+	  }
+	  if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {
+	    throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH, {
+	      decoderFixedSize: decoder.fixedSize,
+	      encoderFixedSize: encoder.fixedSize
+	    });
+	  }
+	  if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {
+	    throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH, {
+	      decoderMaxSize: decoder.maxSize,
+	      encoderMaxSize: encoder.maxSize
+	    });
+	  }
+	  return {
+	    ...decoder,
+	    ...encoder,
+	    decode: decoder.decode,
+	    encode: encoder.encode,
+	    read: decoder.read,
+	    write: encoder.write
+	  };
+	}
+	function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
+	  if (bytes.length - offset <= 0) {
+	    throw new SolanaError(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY, {
+	      codecDescription
+	    });
+	  }
+	}
+	function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
+	  const bytesLength = bytes.length - offset;
+	  if (bytesLength < expected) {
+	    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH, {
+	      bytesLength,
+	      codecDescription,
+	      expected
+	    });
+	  }
 	}
 
-	var browserExports$1 = /*@__PURE__*/ requireBrowser$1();
+	// src/assertions.ts
+	function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+	  if (value < min || value > max) {
+	    throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+	      codecDescription,
+	      max,
+	      min,
+	      value
+	    });
+	  }
+	}
+	function isLittleEndian(config) {
+	  return config?.endian === 1 /* Big */ ? false : true;
+	}
+	function numberEncoderFactory(input) {
+	  return createEncoder({
+	    fixedSize: input.size,
+	    write(value, bytes, offset) {
+	      if (input.range) {
+	        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+	      }
+	      const arrayBuffer = new ArrayBuffer(input.size);
+	      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+	      bytes.set(new Uint8Array(arrayBuffer), offset);
+	      return offset + input.size;
+	    }
+	  });
+	}
+	function numberDecoderFactory(input) {
+	  return createDecoder({
+	    fixedSize: input.size,
+	    read(bytes, offset = 0) {
+	      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+	      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+	      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+	      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+	    }
+	  });
+	}
+	function toArrayBuffer(bytes, offset, length) {
+	  const bytesOffset = bytes.byteOffset + (offset ?? 0);
+	  const bytesLength = length ?? bytes.byteLength;
+	  return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
+	}
+	var getU64Encoder = (config = {}) => numberEncoderFactory({
+	  config,
+	  name: "u64",
+	  range: [0n, BigInt("0xffffffffffffffff")],
+	  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+	  size: 8
+	});
+	var getU64Decoder = (config = {}) => numberDecoderFactory({
+	  config,
+	  get: (view, le) => view.getBigUint64(0, le),
+	  name: "u64",
+	  size: 8
+	});
+	var getU64Codec = (config = {}) => combineCodec(getU64Encoder(config), getU64Decoder(config));
 
-	const encodeDecode = layout => {
+	function u64(property) {
+	  const layout = LayoutExports.blob(8 /* bytes */, property);
 	  const decode = layout.decode.bind(layout);
 	  const encode = layout.encode.bind(layout);
-	  return {
-	    decode,
-	    encode
-	  };
-	};
-	const bigInt = length => property => {
-	  const layout = LayoutExports.blob(length, property);
-	  const {
-	    encode,
-	    decode
-	  } = encodeDecode(layout);
 	  const bigIntLayout = layout;
+	  const codec = getU64Codec();
 	  bigIntLayout.decode = (buffer, offset) => {
 	    const src = decode(buffer, offset);
-	    return browserExports$1.toBigIntLE(bufferExports.Buffer.from(src));
+	    return codec.decode(src);
 	  };
 	  bigIntLayout.encode = (bigInt, buffer, offset) => {
-	    const src = browserExports$1.toBufferLE(bigInt, length);
+	    const src = codec.encode(bigInt);
 	    return encode(src, buffer, offset);
 	  };
 	  return bigIntLayout;
-	};
-	const u64 = bigInt(8);
+	}
 
 	/**
 	 * Create account system transaction params
@@ -22270,7 +22391,7 @@ var solanaWeb3 = (function (exports) {
 	   */
 	  constructor() {}
 	  static createLookupTable(params) {
-	    const [lookupTableAddress, bumpSeed] = PublicKey.findProgramAddressSync([params.authority.toBuffer(), browserExports$1.toBufferLE(BigInt(params.recentSlot), 8)], this.programId);
+	    const [lookupTableAddress, bumpSeed] = PublicKey.findProgramAddressSync([params.authority.toBuffer(), getU64Encoder().encode(params.recentSlot)], this.programId);
 	    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable;
 	    const data = encodeData(type, {
 	      recentSlot: BigInt(params.recentSlot),