@solana/web3.js 1.91.8 → 1.91.9

package/lib/index.iife.js

@@ -2171,15 +2171,13 @@ var solanaWeb3 = (function (exports) {
 		  if (value > max || value < min) {
 		    const n = typeof min === 'bigint' ? 'n' : '';
 		    let range;
-		    if (byteLength > 3) {
+		    {
 		      if (min === 0 || min === BigInt(0)) {
 		        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
 		      } else {
 		        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +
 		                `${(byteLength + 1) * 8 - 1}${n}`;
 		      }
-		    } else {
-		      range = `>= ${min}${n} and <= ${max}${n}`;
 		    }
 		    throw new errors.ERR_OUT_OF_RANGE('value', range, value)
 		  }
@@ -2195,15 +2193,15 @@ var solanaWeb3 = (function (exports) {
 		function boundsError (value, length, type) {
 		  if (Math.floor(value) !== value) {
 		    validateNumber(value, type);
-		    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)
+		    throw new errors.ERR_OUT_OF_RANGE('offset', 'an integer', value)
 		  }
 
 		  if (length < 0) {
 		    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()
 		  }
 
-		  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',
-		                                    `>= ${type ? 1 : 0} and <= ${length}`,
+		  throw new errors.ERR_OUT_OF_RANGE('offset',
+		                                    `>= ${0} and <= ${length}`,
 		                                    value)
 		}
 
@@ -14636,7 +14634,6 @@ var solanaWeb3 = (function (exports) {
 	/**
 	 * A `StructFailure` represents a single specific failure in validation.
 	 */
-
 	/**
 	 * `StructError` objects are thrown (or returned) when validation fails.
 	 *
@@ -14646,190 +14643,160 @@ var solanaWeb3 = (function (exports) {
 	 * continue validation and receive all the failures in the data.
 	 */
 	class StructError extends TypeError {
-	  constructor(failure, failures) {
-	    let cached;
-	    const {
-	      message,
-	      ...rest
-	    } = failure;
-	    const {
-	      path
-	    } = failure;
-	    const msg = path.length === 0 ? message : "At path: " + path.join('.') + " -- " + message;
-	    super(msg);
-	    Object.assign(this, rest);
-	    this.name = this.constructor.name;
-
-	    this.failures = () => {
-	      var _cached;
-
-	      return (_cached = cached) != null ? _cached : cached = [failure, ...failures()];
-	    };
-	  }
-
+	    constructor(failure, failures) {
+	        let cached;
+	        const { message, explanation, ...rest } = failure;
+	        const { path } = failure;
+	        const msg = path.length === 0 ? message : `At path: ${path.join('.')} -- ${message}`;
+	        super(explanation ?? msg);
+	        if (explanation != null)
+	            this.cause = msg;
+	        Object.assign(this, rest);
+	        this.name = this.constructor.name;
+	        this.failures = () => {
+	            return (cached ?? (cached = [failure, ...failures()]));
+	        };
+	    }
 	}
 
 	/**
 	 * Check if a value is an iterator.
 	 */
 	function isIterable(x) {
-	  return isObject(x) && typeof x[Symbol.iterator] === 'function';
+	    return isObject(x) && typeof x[Symbol.iterator] === 'function';
 	}
 	/**
 	 * Check if a value is a plain object.
 	 */
-
-
 	function isObject(x) {
-	  return typeof x === 'object' && x != null;
+	    return typeof x === 'object' && x != null;
 	}
 	/**
 	 * Return a value as a printable string.
 	 */
-
 	function print(value) {
-	  return typeof value === 'string' ? JSON.stringify(value) : "" + value;
+	    if (typeof value === 'symbol') {
+	        return value.toString();
+	    }
+	    return typeof value === 'string' ? JSON.stringify(value) : `${value}`;
 	}
 	/**
 	 * Shifts (removes and returns) the first value from the `input` iterator.
 	 * Like `Array.prototype.shift()` but for an `Iterator`.
 	 */
-
 	function shiftIterator(input) {
-	  const {
-	    done,
-	    value
-	  } = input.next();
-	  return done ? undefined : value;
+	    const { done, value } = input.next();
+	    return done ? undefined : value;
 	}
 	/**
 	 * Convert a single validation result to a failure.
 	 */
-
 	function toFailure(result, context, struct, value) {
-	  if (result === true) {
-	    return;
-	  } else if (result === false) {
-	    result = {};
-	  } else if (typeof result === 'string') {
-	    result = {
-	      message: result
+	    if (result === true) {
+	        return;
+	    }
+	    else if (result === false) {
+	        result = {};
+	    }
+	    else if (typeof result === 'string') {
+	        result = { message: result };
+	    }
+	    const { path, branch } = context;
+	    const { type } = struct;
+	    const { refinement, message = `Expected a value of type \`${type}\`${refinement ? ` with refinement \`${refinement}\`` : ''}, but received: \`${print(value)}\``, } = result;
+	    return {
+	        value,
+	        type,
+	        refinement,
+	        key: path[path.length - 1],
+	        path,
+	        branch,
+	        ...result,
+	        message,
 	    };
-	  }
-
-	  const {
-	    path,
-	    branch
-	  } = context;
-	  const {
-	    type
-	  } = struct;
-	  const {
-	    refinement,
-	    message = "Expected a value of type `" + type + "`" + (refinement ? " with refinement `" + refinement + "`" : '') + ", but received: `" + print(value) + "`"
-	  } = result;
-	  return {
-	    value,
-	    type,
-	    refinement,
-	    key: path[path.length - 1],
-	    path,
-	    branch,
-	    ...result,
-	    message
-	  };
 	}
 	/**
 	 * Convert a validation result to an iterable of failures.
 	 */
-
 	function* toFailures(result, context, struct, value) {
-	  if (!isIterable(result)) {
-	    result = [result];
-	  }
-
-	  for (const r of result) {
-	    const failure = toFailure(r, context, struct, value);
-
-	    if (failure) {
-	      yield failure;
+	    if (!isIterable(result)) {
+	        result = [result];
+	    }
+	    for (const r of result) {
+	        const failure = toFailure(r, context, struct, value);
+	        if (failure) {
+	            yield failure;
+	        }
 	    }
-	  }
 	}
 	/**
 	 * Check a value against a struct, traversing deeply into nested values, and
 	 * returning an iterator of failures or success.
 	 */
-
 	function* run(value, struct, options = {}) {
-	  const {
-	    path = [],
-	    branch = [value],
-	    coerce = false,
-	    mask = false
-	  } = options;
-	  const ctx = {
-	    path,
-	    branch
-	  };
-
-	  if (coerce) {
-	    value = struct.coercer(value, ctx);
-
-	    if (mask && struct.type !== 'type' && isObject(struct.schema) && isObject(value) && !Array.isArray(value)) {
-	      for (const key in value) {
-	        if (struct.schema[key] === undefined) {
-	          delete value[key];
+	    const { path = [], branch = [value], coerce = false, mask = false } = options;
+	    const ctx = { path, branch };
+	    if (coerce) {
+	        value = struct.coercer(value, ctx);
+	        if (mask &&
+	            struct.type !== 'type' &&
+	            isObject(struct.schema) &&
+	            isObject(value) &&
+	            !Array.isArray(value)) {
+	            for (const key in value) {
+	                if (struct.schema[key] === undefined) {
+	                    delete value[key];
+	                }
+	            }
 	        }
-	      }
 	    }
-	  }
-
-	  let valid = true;
-
-	  for (const failure of struct.validator(value, ctx)) {
-	    valid = false;
-	    yield [failure, undefined];
-	  }
-
-	  for (let [k, v, s] of struct.entries(value, ctx)) {
-	    const ts = run(v, s, {
-	      path: k === undefined ? path : [...path, k],
-	      branch: k === undefined ? branch : [...branch, v],
-	      coerce,
-	      mask
-	    });
-
-	    for (const t of ts) {
-	      if (t[0]) {
-	        valid = false;
-	        yield [t[0], undefined];
-	      } else if (coerce) {
-	        v = t[1];
-
-	        if (k === undefined) {
-	          value = v;
-	        } else if (value instanceof Map) {
-	          value.set(k, v);
-	        } else if (value instanceof Set) {
-	          value.add(v);
-	        } else if (isObject(value)) {
-	          value[k] = v;
+	    let status = 'valid';
+	    for (const failure of struct.validator(value, ctx)) {
+	        failure.explanation = options.message;
+	        status = 'not_valid';
+	        yield [failure, undefined];
+	    }
+	    for (let [k, v, s] of struct.entries(value, ctx)) {
+	        const ts = run(v, s, {
+	            path: k === undefined ? path : [...path, k],
+	            branch: k === undefined ? branch : [...branch, v],
+	            coerce,
+	            mask,
+	            message: options.message,
+	        });
+	        for (const t of ts) {
+	            if (t[0]) {
+	                status = t[0].refinement != null ? 'not_refined' : 'not_valid';
+	                yield [t[0], undefined];
+	            }
+	            else if (coerce) {
+	                v = t[1];
+	                if (k === undefined) {
+	                    value = v;
+	                }
+	                else if (value instanceof Map) {
+	                    value.set(k, v);
+	                }
+	                else if (value instanceof Set) {
+	                    value.add(v);
+	                }
+	                else if (isObject(value)) {
+	                    if (v !== undefined || k in value)
+	                        value[k] = v;
+	                }
+	            }
 	        }
-	      }
 	    }
-	  }
-
-	  if (valid) {
-	    for (const failure of struct.refiner(value, ctx)) {
-	      valid = false;
-	      yield [failure, undefined];
+	    if (status !== 'not_valid') {
+	        for (const failure of struct.refiner(value, ctx)) {
+	            failure.explanation = options.message;
+	            status = 'not_refined';
+	            yield [failure, undefined];
+	        }
+	    }
+	    if (status === 'valid') {
+	        yield [undefined, value];
 	    }
-	  }
-
-	  if (valid) {
-	    yield [undefined, value];
-	  }
 	}
 
 	/**
@@ -14837,269 +14804,227 @@ var solanaWeb3 = (function (exports) {
 	 * values. Once constructed, you use the `assert`, `is` or `validate` helpers to
 	 * validate unknown input data against the struct.
 	 */
-
 	class Struct {
-	  constructor(props) {
-	    const {
-	      type,
-	      schema,
-	      validator,
-	      refiner,
-	      coercer = value => value,
-	      entries = function* () {}
-	    } = props;
-	    this.type = type;
-	    this.schema = schema;
-	    this.entries = entries;
-	    this.coercer = coercer;
-
-	    if (validator) {
-	      this.validator = (value, context) => {
-	        const result = validator(value, context);
-	        return toFailures(result, context, this, value);
-	      };
-	    } else {
-	      this.validator = () => [];
+	    constructor(props) {
+	        const { type, schema, validator, refiner, coercer = (value) => value, entries = function* () { }, } = props;
+	        this.type = type;
+	        this.schema = schema;
+	        this.entries = entries;
+	        this.coercer = coercer;
+	        if (validator) {
+	            this.validator = (value, context) => {
+	                const result = validator(value, context);
+	                return toFailures(result, context, this, value);
+	            };
+	        }
+	        else {
+	            this.validator = () => [];
+	        }
+	        if (refiner) {
+	            this.refiner = (value, context) => {
+	                const result = refiner(value, context);
+	                return toFailures(result, context, this, value);
+	            };
+	        }
+	        else {
+	            this.refiner = () => [];
+	        }
 	    }
-
-	    if (refiner) {
-	      this.refiner = (value, context) => {
-	        const result = refiner(value, context);
-	        return toFailures(result, context, this, value);
-	      };
-	    } else {
-	      this.refiner = () => [];
+	    /**
+	     * Assert that a value passes the struct's validation, throwing if it doesn't.
+	     */
+	    assert(value, message) {
+	        return assert(value, this, message);
+	    }
+	    /**
+	     * Create a value with the struct's coercion logic, then validate it.
+	     */
+	    create(value, message) {
+	        return create(value, this, message);
+	    }
+	    /**
+	     * Check if a value passes the struct's validation.
+	     */
+	    is(value) {
+	        return is(value, this);
+	    }
+	    /**
+	     * Mask a value, coercing and validating it, but returning only the subset of
+	     * properties defined by the struct's schema.
+	     */
+	    mask(value, message) {
+	        return mask(value, this, message);
+	    }
+	    /**
+	     * Validate a value with the struct's validation logic, returning a tuple
+	     * representing the result.
+	     *
+	     * You may optionally pass `true` for the `withCoercion` argument to coerce
+	     * the value before attempting to validate it. If you do, the result will
+	     * contain the coerced result when successful.
+	     */
+	    validate(value, options = {}) {
+	        return validate$1(value, this, options);
 	    }
-	  }
-	  /**
-	   * Assert that a value passes the struct's validation, throwing if it doesn't.
-	   */
-
-
-	  assert(value) {
-	    return assert(value, this);
-	  }
-	  /**
-	   * Create a value with the struct's coercion logic, then validate it.
-	   */
-
-
-	  create(value) {
-	    return create(value, this);
-	  }
-	  /**
-	   * Check if a value passes the struct's validation.
-	   */
-
-
-	  is(value) {
-	    return is(value, this);
-	  }
-	  /**
-	   * Mask a value, coercing and validating it, but returning only the subset of
-	   * properties defined by the struct's schema.
-	   */
-
-
-	  mask(value) {
-	    return mask(value, this);
-	  }
-	  /**
-	   * Validate a value with the struct's validation logic, returning a tuple
-	   * representing the result.
-	   *
-	   * You may optionally pass `true` for the `withCoercion` argument to coerce
-	   * the value before attempting to validate it. If you do, the result will
-	   * contain the coerced result when successful.
-	   */
-
-
-	  validate(value, options = {}) {
-	    return validate$1(value, this, options);
-	  }
-
 	}
 	/**
 	 * Assert that a value passes a struct, throwing if it doesn't.
 	 */
-
-	function assert(value, struct) {
-	  const result = validate$1(value, struct);
-
-	  if (result[0]) {
-	    throw result[0];
-	  }
+	function assert(value, struct, message) {
+	    const result = validate$1(value, struct, { message });
+	    if (result[0]) {
+	        throw result[0];
+	    }
 	}
 	/**
 	 * Create a value with the coercion logic of struct and validate it.
 	 */
-
-	function create(value, struct) {
-	  const result = validate$1(value, struct, {
-	    coerce: true
-	  });
-
-	  if (result[0]) {
-	    throw result[0];
-	  } else {
-	    return result[1];
-	  }
+	function create(value, struct, message) {
+	    const result = validate$1(value, struct, { coerce: true, message });
+	    if (result[0]) {
+	        throw result[0];
+	    }
+	    else {
+	        return result[1];
+	    }
 	}
 	/**
 	 * Mask a value, returning only the subset of properties defined by a struct.
 	 */
-
-	function mask(value, struct) {
-	  const result = validate$1(value, struct, {
-	    coerce: true,
-	    mask: true
-	  });
-
-	  if (result[0]) {
-	    throw result[0];
-	  } else {
-	    return result[1];
-	  }
+	function mask(value, struct, message) {
+	    const result = validate$1(value, struct, { coerce: true, mask: true, message });
+	    if (result[0]) {
+	        throw result[0];
+	    }
+	    else {
+	        return result[1];
+	    }
 	}
 	/**
 	 * Check if a value passes a struct.
 	 */
-
 	function is(value, struct) {
-	  const result = validate$1(value, struct);
-	  return !result[0];
+	    const result = validate$1(value, struct);
+	    return !result[0];
 	}
 	/**
 	 * Validate a value against a struct, returning an error if invalid, or the
 	 * value (with potential coercion) if valid.
 	 */
-
 	function validate$1(value, struct, options = {}) {
-	  const tuples = run(value, struct, options);
-	  const tuple = shiftIterator(tuples);
-
-	  if (tuple[0]) {
-	    const error = new StructError(tuple[0], function* () {
-	      for (const t of tuples) {
-	        if (t[0]) {
-	          yield t[0];
-	        }
-	      }
-	    });
-	    return [error, undefined];
-	  } else {
-	    const v = tuple[1];
-	    return [undefined, v];
-	  }
+	    const tuples = run(value, struct, options);
+	    const tuple = shiftIterator(tuples);
+	    if (tuple[0]) {
+	        const error = new StructError(tuple[0], function* () {
+	            for (const t of tuples) {
+	                if (t[0]) {
+	                    yield t[0];
+	                }
+	            }
+	        });
+	        return [error, undefined];
+	    }
+	    else {
+	        const v = tuple[1];
+	        return [undefined, v];
+	    }
 	}
 	/**
 	 * Define a new struct type with a custom validation function.
 	 */
-
 	function define(name, validator) {
-	  return new Struct({
-	    type: name,
-	    schema: null,
-	    validator
-	  });
+	    return new Struct({ type: name, schema: null, validator });
 	}
 
 	/**
 	 * Ensure that any value passes validation.
 	 */
-
 	function any() {
-	  return define('any', () => true);
+	    return define('any', () => true);
 	}
 	function array(Element) {
-	  return new Struct({
-	    type: 'array',
-	    schema: Element,
-
-	    *entries(value) {
-	      if (Element && Array.isArray(value)) {
-	        for (const [i, v] of value.entries()) {
-	          yield [i, v, Element];
-	        }
-	      }
-	    },
-
-	    coercer(value) {
-	      return Array.isArray(value) ? value.slice() : value;
-	    },
-
-	    validator(value) {
-	      return Array.isArray(value) || "Expected an array value, but received: " + print(value);
-	    }
-
-	  });
+	    return new Struct({
+	        type: 'array',
+	        schema: Element,
+	        *entries(value) {
+	            if (Element && Array.isArray(value)) {
+	                for (const [i, v] of value.entries()) {
+	                    yield [i, v, Element];
+	                }
+	            }
+	        },
+	        coercer(value) {
+	            return Array.isArray(value) ? value.slice() : value;
+	        },
+	        validator(value) {
+	            return (Array.isArray(value) ||
+	                `Expected an array value, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that a value is a boolean.
 	 */
-
 	function boolean() {
-	  return define('boolean', value => {
-	    return typeof value === 'boolean';
-	  });
+	    return define('boolean', (value) => {
+	        return typeof value === 'boolean';
+	    });
 	}
 	/**
 	 * Ensure that a value is an instance of a specific class.
 	 */
-
 	function instance(Class) {
-	  return define('instance', value => {
-	    return value instanceof Class || "Expected a `" + Class.name + "` instance, but received: " + print(value);
-	  });
+	    return define('instance', (value) => {
+	        return (value instanceof Class ||
+	            `Expected a \`${Class.name}\` instance, but received: ${print(value)}`);
+	    });
 	}
 	function literal(constant) {
-	  const description = print(constant);
-	  const t = typeof constant;
-	  return new Struct({
-	    type: 'literal',
-	    schema: t === 'string' || t === 'number' || t === 'boolean' ? constant : null,
-
-	    validator(value) {
-	      return value === constant || "Expected the literal `" + description + "`, but received: " + print(value);
-	    }
-
-	  });
+	    const description = print(constant);
+	    const t = typeof constant;
+	    return new Struct({
+	        type: 'literal',
+	        schema: t === 'string' || t === 'number' || t === 'boolean' ? constant : null,
+	        validator(value) {
+	            return (value === constant ||
+	                `Expected the literal \`${description}\`, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that no value ever passes validation.
 	 */
-
 	function never() {
-	  return define('never', () => false);
+	    return define('never', () => false);
 	}
 	/**
 	 * Augment an existing struct to allow `null` values.
 	 */
-
 	function nullable(struct) {
-	  return new Struct({ ...struct,
-	    validator: (value, ctx) => value === null || struct.validator(value, ctx),
-	    refiner: (value, ctx) => value === null || struct.refiner(value, ctx)
-	  });
+	    return new Struct({
+	        ...struct,
+	        validator: (value, ctx) => value === null || struct.validator(value, ctx),
+	        refiner: (value, ctx) => value === null || struct.refiner(value, ctx),
+	    });
 	}
 	/**
 	 * Ensure that a value is a number.
 	 */
-
 	function number() {
-	  return define('number', value => {
-	    return typeof value === 'number' && !isNaN(value) || "Expected a number, but received: " + print(value);
-	  });
+	    return define('number', (value) => {
+	        return ((typeof value === 'number' && !isNaN(value)) ||
+	            `Expected a number, but received: ${print(value)}`);
+	    });
 	}
 	/**
 	 * Augment a struct to allow `undefined` values.
 	 */
-
 	function optional(struct) {
-	  return new Struct({ ...struct,
-	    validator: (value, ctx) => value === undefined || struct.validator(value, ctx),
-	    refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx)
-	  });
+	    return new Struct({
+	        ...struct,
+	        validator: (value, ctx) => value === undefined || struct.validator(value, ctx),
+	        refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx),
+	    });
 	}
 	/**
 	 * Ensure that a value is an object with keys and values of specific types, but
@@ -15107,58 +15032,55 @@ var solanaWeb3 = (function (exports) {
 	 *
 	 * Like TypeScript's `Record` utility.
 	 */
-
 	function record(Key, Value) {
-	  return new Struct({
-	    type: 'record',
-	    schema: null,
-
-	    *entries(value) {
-	      if (isObject(value)) {
-	        for (const k in value) {
-	          const v = value[k];
-	          yield [k, k, Key];
-	          yield [k, v, Value];
-	        }
-	      }
-	    },
-
-	    validator(value) {
-	      return isObject(value) || "Expected an object, but received: " + print(value);
-	    }
-
-	  });
+	    return new Struct({
+	        type: 'record',
+	        schema: null,
+	        *entries(value) {
+	            if (isObject(value)) {
+	                for (const k in value) {
+	                    const v = value[k];
+	                    yield [k, k, Key];
+	                    yield [k, v, Value];
+	                }
+	            }
+	        },
+	        validator(value) {
+	            return (isObject(value) || `Expected an object, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that a value is a string.
 	 */
-
 	function string() {
-	  return define('string', value => {
-	    return typeof value === 'string' || "Expected a string, but received: " + print(value);
-	  });
+	    return define('string', (value) => {
+	        return (typeof value === 'string' ||
+	            `Expected a string, but received: ${print(value)}`);
+	    });
 	}
-	function tuple(Elements) {
-	  const Never = never();
-	  return new Struct({
-	    type: 'tuple',
-	    schema: null,
-
-	    *entries(value) {
-	      if (Array.isArray(value)) {
-	        const length = Math.max(Elements.length, value.length);
-
-	        for (let i = 0; i < length; i++) {
-	          yield [i, value[i], Elements[i] || Never];
-	        }
-	      }
-	    },
-
-	    validator(value) {
-	      return Array.isArray(value) || "Expected an array, but received: " + print(value);
-	    }
-
-	  });
+	/**
+	 * Ensure that a value is a tuple of a specific length, and that each of its
+	 * elements is of a specific type.
+	 */
+	function tuple(Structs) {
+	    const Never = never();
+	    return new Struct({
+	        type: 'tuple',
+	        schema: null,
+	        *entries(value) {
+	            if (Array.isArray(value)) {
+	                const length = Math.max(Structs.length, value.length);
+	                for (let i = 0; i < length; i++) {
+	                    yield [i, value[i], Structs[i] || Never];
+	                }
+	            }
+	        },
+	        validator(value) {
+	            return (Array.isArray(value) ||
+	                `Expected an array, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that a value has a set of known properties of specific types.
@@ -15166,62 +15088,71 @@ var solanaWeb3 = (function (exports) {
 	 * Note: Unrecognized properties are allowed and untouched. This is similar to
 	 * how TypeScript's structural typing works.
 	 */
-
 	function type(schema) {
-	  const keys = Object.keys(schema);
-	  return new Struct({
-	    type: 'type',
-	    schema,
-
-	    *entries(value) {
-	      if (isObject(value)) {
-	        for (const k of keys) {
-	          yield [k, value[k], schema[k]];
-	        }
-	      }
-	    },
-
-	    validator(value) {
-	      return isObject(value) || "Expected an object, but received: " + print(value);
-	    }
-
-	  });
+	    const keys = Object.keys(schema);
+	    return new Struct({
+	        type: 'type',
+	        schema,
+	        *entries(value) {
+	            if (isObject(value)) {
+	                for (const k of keys) {
+	                    yield [k, value[k], schema[k]];
+	                }
+	            }
+	        },
+	        validator(value) {
+	            return (isObject(value) || `Expected an object, but received: ${print(value)}`);
+	        },
+	        coercer(value) {
+	            return isObject(value) ? { ...value } : value;
+	        },
+	    });
 	}
+	/**
+	 * Ensure that a value matches one of a set of types.
+	 */
 	function union(Structs) {
-	  const description = Structs.map(s => s.type).join(' | ');
-	  return new Struct({
-	    type: 'union',
-	    schema: null,
-
-	    validator(value, ctx) {
-	      const failures = [];
-
-	      for (const S of Structs) {
-	        const [...tuples] = run(value, S, ctx);
-	        const [first] = tuples;
-
-	        if (!first[0]) {
-	          return [];
-	        } else {
-	          for (const [failure] of tuples) {
-	            if (failure) {
-	              failures.push(failure);
+	    const description = Structs.map((s) => s.type).join(' | ');
+	    return new Struct({
+	        type: 'union',
+	        schema: null,
+	        coercer(value) {
+	            for (const S of Structs) {
+	                const [error, coerced] = S.validate(value, { coerce: true });
+	                if (!error) {
+	                    return coerced;
+	                }
 	            }
-	          }
-	        }
-	      }
-
-	      return ["Expected the value to satisfy a union of `" + description + "`, but received: " + print(value), ...failures];
-	    }
-
-	  });
+	            return value;
+	        },
+	        validator(value, ctx) {
+	            const failures = [];
+	            for (const S of Structs) {
+	                const [...tuples] = run(value, S, ctx);
+	                const [first] = tuples;
+	                if (!first[0]) {
+	                    return [];
+	                }
+	                else {
+	                    for (const [failure] of tuples) {
+	                        if (failure) {
+	                            failures.push(failure);
+	                        }
+	                    }
+	                }
+	            }
+	            return [
+	                `Expected the value to satisfy a union of \`${description}\`, but received: ${print(value)}`,
+	                ...failures,
+	            ];
+	        },
+	    });
 	}
 	/**
 	 * Ensure that any value passes validation, without widening its type to `any`.
 	 */
-
 	function unknown() {
-	  return define('unknown', () => true);
+	    return define('unknown', () => true);
 	}
 
 	/**
@@ -15234,13 +15165,15 @@ var solanaWeb3 = (function (exports) {
 	 * Note: You must use `create(value, Struct)` on the value to have the coercion
 	 * take effect! Using simply `assert()` or `is()` will not use coercion.
 	 */
-
 	function coerce(struct, condition, coercer) {
-	  return new Struct({ ...struct,
-	    coercer: (value, ctx) => {
-	      return is(value, condition) ? struct.coercer(coercer(value, ctx), ctx) : struct.coercer(value, ctx);
-	    }
-	  });
+	    return new Struct({
+	        ...struct,
+	        coercer: (value, ctx) => {
+	            return is(value, condition)
+	                ? struct.coercer(coercer(value, ctx), ctx)
+	                : struct.coercer(value, ctx);
+	        },
+	    });
 	}
 
 	// Unique ID creation requires a high quality random # generator. In the browser we therefore
@@ -16591,7 +16524,7 @@ var solanaWeb3 = (function (exports) {
 	Object.defineProperty(client, "__esModule", { value: true });
 	// @ts-ignore
 	const eventemitter3_1$1 = eventemitter3Exports;
-	const utils_1 = utils;
+	const utils_cjs_1 = utils;
 	class CommonClient extends eventemitter3_1$1.EventEmitter {
 	    address;
 	    rpc_id;
@@ -16635,7 +16568,7 @@ var solanaWeb3 = (function (exports) {
 	        this.current_reconnects = 0;
 	        this.generate_request_id = generate_request_id || (() => ++this.rpc_id);
 	        if (!dataPack)
-	            this.dataPack = new utils_1.DefaultDataPack();
+	            this.dataPack = new utils_cjs_1.DefaultDataPack();
 	        else
 	            this.dataPack = dataPack;
 	        if (this.autoconnect)
@@ -17070,7 +17003,7 @@ var solanaWeb3 = (function (exports) {
 	  const websocketPort =
 	  // Only shift the port by +1 as a convention for ws(s) only if given endpoint
 	  // is explicitly specifying the endpoint port (HTTP-based RPC), assuming
-	  // we're directly trying to connect to solana-validator's ws listening port.
+	  // we're directly trying to connect to agave-validator's ws listening port.
 	  // When the endpoint omits the port, we're connecting to the protocol
 	  // default ports: http(80) or https(443) and it's assumed we're behind a reverse
 	  // proxy which manages WebSocket upgrade and backend port redirection.