@solana/web3.js 1.47.4 → 1.50.0

package/lib/index.iife.js

@@ -11478,7 +11478,69 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
-	const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader1111111111111111111111111111111111');
+	var browser$1 = {};
+
+	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}`);
+	    }
+	}
+	var toBigIntLE_1 = 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;
+	    }
+	}
+	var toBufferLE_1 = 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;
 
 	var Layout$1 = {};
 
@@ -13763,16 +13825,6 @@ var solanaWeb3 = (function (exports) {
 	/** Factory for {@link Constant} values. */
 	Layout$1.constant = ((value, property) => new Constant(value, property));
 
-	/**
-	 * Maximum over-the-wire size of a Transaction
-	 *
-	 * 1280 is IPv6 minimum MTU
-	 * 40 bytes is the size of the IPv6 header
-	 * 8 bytes is the size of the fragment header
-	 */
-	const PACKET_DATA_SIZE = 1280 - 40 - 8;
-	const SIGNATURE_LENGTH_IN_BYTES = 64;
-
 	/**
 	 * Layout for a public key
 	 */
@@ -13834,17 +13886,170 @@ var solanaWeb3 = (function (exports) {
 	  return struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), u8('commission')], property);
 	};
 	function getAlloc(type, fields) {
-	  let alloc = 0;
-	  type.layout.fields.forEach(item => {
+	  const getItemAlloc = item => {
 	    if (item.span >= 0) {
-	      alloc += item.span;
+	      return item.span;
 	    } else if (typeof item.alloc === 'function') {
-	      alloc += item.alloc(fields[item.property]);
-	    }
+	      return item.alloc(fields[item.property]);
+	    } else if ('count' in item && 'elementLayout' in item) {
+	      const field = fields[item.property];
+
+	      if (Array.isArray(field)) {
+	        return field.length * getItemAlloc(item.elementLayout);
+	      }
+	    } // Couldn't determine allocated size of layout
+
+
+	    return 0;
+	  };
+
+	  let alloc = 0;
+	  type.layout.fields.forEach(item => {
+	    alloc += getItemAlloc(item);
 	  });
 	  return alloc;
 	}
 
+	const encodeDecode = layout => {
+	  const decode = layout.decode.bind(layout);
+	  const encode = layout.encode.bind(layout);
+	  return {
+	    decode,
+	    encode
+	  };
+	};
+
+	const bigInt = length => property => {
+	  const layout = blob(length, property);
+	  const {
+	    encode,
+	    decode
+	  } = encodeDecode(layout);
+	  const bigIntLayout = layout;
+
+	  bigIntLayout.decode = (buffer$1, offset) => {
+	    const src = decode(buffer$1, offset);
+	    return toBigIntLE_1(buffer.Buffer.from(src));
+	  };
+
+	  bigIntLayout.encode = (bigInt, buffer, offset) => {
+	    const src = toBufferLE_1(bigInt, length);
+	    return encode(src, buffer, offset);
+	  };
+
+	  return bigIntLayout;
+	};
+
+	const u64 = bigInt(8);
+
+	/**
+	 * Populate a buffer of instruction data using an InstructionType
+	 * @internal
+	 */
+	function encodeData(type, fields) {
+	  const allocLength = type.layout.span >= 0 ? type.layout.span : getAlloc(type, fields);
+	  const data = buffer.Buffer.alloc(allocLength);
+	  const layoutFields = Object.assign({
+	    instruction: type.index
+	  }, fields);
+	  type.layout.encode(layoutFields, data);
+	  return data;
+	}
+	/**
+	 * Decode instruction data buffer using an InstructionType
+	 * @internal
+	 */
+
+	function decodeData(type, buffer) {
+	  let data;
+
+	  try {
+	    data = type.layout.decode(buffer);
+	  } catch (err) {
+	    throw new Error('invalid instruction; ' + err);
+	  }
+
+	  if (data.instruction !== type.index) {
+	    throw new Error(`invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`);
+	  }
+
+	  return data;
+	}
+
+	/**
+	 * https://github.com/solana-labs/solana/blob/90bedd7e067b5b8f3ddbb45da00a4e9cabb22c62/sdk/src/fee_calculator.rs#L7-L11
+	 *
+	 * @internal
+	 */
+
+	const FeeCalculatorLayout = nu64('lamportsPerSignature');
+	/**
+	 * Calculator for transaction fees.
+	 */
+
+	/**
+	 * See https://github.com/solana-labs/solana/blob/0ea2843ec9cdc517572b8e62c959f41b55cf4453/sdk/src/nonce_state.rs#L29-L32
+	 *
+	 * @internal
+	 */
+
+	const NonceAccountLayout = struct([u32('version'), u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), struct([FeeCalculatorLayout], 'feeCalculator')]);
+	const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
+
+	/**
+	 * NonceAccount class
+	 */
+	class NonceAccount {
+	  /**
+	   * @internal
+	   */
+	  constructor(args) {
+	    this.authorizedPubkey = void 0;
+	    this.nonce = void 0;
+	    this.feeCalculator = void 0;
+	    this.authorizedPubkey = args.authorizedPubkey;
+	    this.nonce = args.nonce;
+	    this.feeCalculator = args.feeCalculator;
+	  }
+	  /**
+	   * Deserialize NonceAccount from the account data.
+	   *
+	   * @param buffer account data
+	   * @return NonceAccount
+	   */
+
+
+	  static fromAccountData(buffer) {
+	    const nonceAccount = NonceAccountLayout.decode(toBuffer(buffer), 0);
+	    return new NonceAccount({
+	      authorizedPubkey: new PublicKey(nonceAccount.authorizedPubkey),
+	      nonce: new PublicKey(nonceAccount.nonce).toString(),
+	      feeCalculator: nonceAccount.feeCalculator
+	    });
+	  }
+
+	}
+
+	const SYSVAR_CLOCK_PUBKEY = new PublicKey('SysvarC1ock11111111111111111111111111111111');
+	const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey('SysvarEpochSchedu1e111111111111111111111111');
+	const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey('Sysvar1nstructions1111111111111111111111111');
+	const SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new PublicKey('SysvarRecentB1ockHashes11111111111111111111');
+	const SYSVAR_RENT_PUBKEY = new PublicKey('SysvarRent111111111111111111111111111111111');
+	const SYSVAR_REWARDS_PUBKEY = new PublicKey('SysvarRewards111111111111111111111111111111');
+	const SYSVAR_SLOT_HASHES_PUBKEY = new PublicKey('SysvarS1otHashes111111111111111111111111111');
+	const SYSVAR_SLOT_HISTORY_PUBKEY = new PublicKey('SysvarS1otHistory11111111111111111111111111');
+	const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey('SysvarStakeHistory1111111111111111111111111');
+
+	/**
+	 * Maximum over-the-wire size of a Transaction
+	 *
+	 * 1280 is IPv6 minimum MTU
+	 * 40 bytes is the size of the IPv6 header
+	 * 8 bytes is the size of the fragment header
+	 */
+	const PACKET_DATA_SIZE = 1280 - 40 - 8;
+	const SIGNATURE_LENGTH_IN_BYTES = 64;
+
 	function decodeLength(bytes) {
 	  let len = 0;
 	  let size = 0;
@@ -14758,243 +14963,12 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
-	const SYSVAR_CLOCK_PUBKEY = new PublicKey('SysvarC1ock11111111111111111111111111111111');
-	const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey('SysvarEpochSchedu1e111111111111111111111111');
-	const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey('Sysvar1nstructions1111111111111111111111111');
-	const SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new PublicKey('SysvarRecentB1ockHashes11111111111111111111');
-	const SYSVAR_RENT_PUBKEY = new PublicKey('SysvarRent111111111111111111111111111111111');
-	const SYSVAR_REWARDS_PUBKEY = new PublicKey('SysvarRewards111111111111111111111111111111');
-	const SYSVAR_SLOT_HASHES_PUBKEY = new PublicKey('SysvarS1otHashes111111111111111111111111111');
-	const SYSVAR_SLOT_HISTORY_PUBKEY = new PublicKey('SysvarS1otHistory11111111111111111111111111');
-	const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey('SysvarStakeHistory1111111111111111111111111');
+	/**
+	 * Create account system transaction params
+	 */
 
 	/**
-	 * Sign, send and confirm a transaction.
-	 *
-	 * If `commitment` option is not specified, defaults to 'max' commitment.
-	 *
-	 * @param {Connection} connection
-	 * @param {Transaction} transaction
-	 * @param {Array<Signer>} signers
-	 * @param {ConfirmOptions} [options]
-	 * @returns {Promise<TransactionSignature>}
-	 */
-	async function sendAndConfirmTransaction(connection, transaction, signers, options) {
-	  const sendOptions = options && {
-	    skipPreflight: options.skipPreflight,
-	    preflightCommitment: options.preflightCommitment || options.commitment,
-	    maxRetries: options.maxRetries,
-	    minContextSlot: options.minContextSlot
-	  };
-	  const signature = await connection.sendTransaction(transaction, signers, sendOptions);
-	  const status = transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null ? (await connection.confirmTransaction({
-	    signature: signature,
-	    blockhash: transaction.recentBlockhash,
-	    lastValidBlockHeight: transaction.lastValidBlockHeight
-	  }, options && options.commitment)).value : (await connection.confirmTransaction(signature, options && options.commitment)).value;
-
-	  if (status.err) {
-	    throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
-	  }
-
-	  return signature;
-	}
-
-	// zzz
-	function sleep(ms) {
-	  return new Promise(resolve => setTimeout(resolve, ms));
-	}
-
-	/**
-	 * Populate a buffer of instruction data using an InstructionType
-	 * @internal
-	 */
-	function encodeData(type, fields) {
-	  const allocLength = type.layout.span >= 0 ? type.layout.span : getAlloc(type, fields);
-	  const data = buffer.Buffer.alloc(allocLength);
-	  const layoutFields = Object.assign({
-	    instruction: type.index
-	  }, fields);
-	  type.layout.encode(layoutFields, data);
-	  return data;
-	}
-	/**
-	 * Decode instruction data buffer using an InstructionType
-	 * @internal
-	 */
-
-	function decodeData(type, buffer) {
-	  let data;
-
-	  try {
-	    data = type.layout.decode(buffer);
-	  } catch (err) {
-	    throw new Error('invalid instruction; ' + err);
-	  }
-
-	  if (data.instruction !== type.index) {
-	    throw new Error(`invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`);
-	  }
-
-	  return data;
-	}
-
-	/**
-	 * https://github.com/solana-labs/solana/blob/90bedd7e067b5b8f3ddbb45da00a4e9cabb22c62/sdk/src/fee_calculator.rs#L7-L11
-	 *
-	 * @internal
-	 */
-
-	const FeeCalculatorLayout = nu64('lamportsPerSignature');
-	/**
-	 * Calculator for transaction fees.
-	 */
-
-	/**
-	 * See https://github.com/solana-labs/solana/blob/0ea2843ec9cdc517572b8e62c959f41b55cf4453/sdk/src/nonce_state.rs#L29-L32
-	 *
-	 * @internal
-	 */
-
-	const NonceAccountLayout = struct([u32('version'), u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), struct([FeeCalculatorLayout], 'feeCalculator')]);
-	const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
-
-	/**
-	 * NonceAccount class
-	 */
-	class NonceAccount {
-	  /**
-	   * @internal
-	   */
-	  constructor(args) {
-	    this.authorizedPubkey = void 0;
-	    this.nonce = void 0;
-	    this.feeCalculator = void 0;
-	    this.authorizedPubkey = args.authorizedPubkey;
-	    this.nonce = args.nonce;
-	    this.feeCalculator = args.feeCalculator;
-	  }
-	  /**
-	   * Deserialize NonceAccount from the account data.
-	   *
-	   * @param buffer account data
-	   * @return NonceAccount
-	   */
-
-
-	  static fromAccountData(buffer) {
-	    const nonceAccount = NonceAccountLayout.decode(toBuffer(buffer), 0);
-	    return new NonceAccount({
-	      authorizedPubkey: new PublicKey(nonceAccount.authorizedPubkey),
-	      nonce: new PublicKey(nonceAccount.nonce).toString(),
-	      feeCalculator: nonceAccount.feeCalculator
-	    });
-	  }
-
-	}
-
-	var browser$1 = {};
-
-	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}`);
-	    }
-	}
-	var toBigIntLE_1 = 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;
-	    }
-	}
-	var toBufferLE_1 = 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;
-
-	const encodeDecode = layout => {
-	  const decode = layout.decode.bind(layout);
-	  const encode = layout.encode.bind(layout);
-	  return {
-	    decode,
-	    encode
-	  };
-	};
-
-	const bigInt = length => property => {
-	  const layout = blob(length, property);
-	  const {
-	    encode,
-	    decode
-	  } = encodeDecode(layout);
-	  const bigIntLayout = layout;
-
-	  bigIntLayout.decode = (buffer$1, offset) => {
-	    const src = decode(buffer$1, offset);
-	    return toBigIntLE_1(buffer.Buffer.from(src));
-	  };
-
-	  bigIntLayout.encode = (bigInt, buffer, offset) => {
-	    const src = toBufferLE_1(bigInt, length);
-	    return encode(src, buffer, offset);
-	  };
-
-	  return bigIntLayout;
-	};
-
-	const u64 = bigInt(8);
-
-	/**
-	 * Create account system transaction params
-	 */
-
-	/**
-	 * System Instruction class
+	 * System Instruction class
 	 */
 	class SystemInstruction {
 	  /**
@@ -15569,140 +15543,446 @@ var solanaWeb3 = (function (exports) {
 	    return new TransactionInstruction(instructionData);
 	  }
 	  /**
-	   * Generate an instruction to advance the nonce in a Nonce account
+	   * Generate an instruction to advance the nonce in a Nonce account
+	   */
+
+
+	  static nonceAdvance(params) {
+	    const type = SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount;
+	    const data = encodeData(type);
+	    const instructionData = {
+	      keys: [{
+	        pubkey: params.noncePubkey,
+	        isSigner: false,
+	        isWritable: true
+	      }, {
+	        pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
+	        isSigner: false,
+	        isWritable: false
+	      }, {
+	        pubkey: params.authorizedPubkey,
+	        isSigner: true,
+	        isWritable: false
+	      }],
+	      programId: this.programId,
+	      data
+	    };
+	    return new TransactionInstruction(instructionData);
+	  }
+	  /**
+	   * Generate a transaction instruction that withdraws lamports from a Nonce account
+	   */
+
+
+	  static nonceWithdraw(params) {
+	    const type = SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount;
+	    const data = encodeData(type, {
+	      lamports: params.lamports
+	    });
+	    return new TransactionInstruction({
+	      keys: [{
+	        pubkey: params.noncePubkey,
+	        isSigner: false,
+	        isWritable: true
+	      }, {
+	        pubkey: params.toPubkey,
+	        isSigner: false,
+	        isWritable: true
+	      }, {
+	        pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
+	        isSigner: false,
+	        isWritable: false
+	      }, {
+	        pubkey: SYSVAR_RENT_PUBKEY,
+	        isSigner: false,
+	        isWritable: false
+	      }, {
+	        pubkey: params.authorizedPubkey,
+	        isSigner: true,
+	        isWritable: false
+	      }],
+	      programId: this.programId,
+	      data
+	    });
+	  }
+	  /**
+	   * Generate a transaction instruction that authorizes a new PublicKey as the authority
+	   * on a Nonce account.
+	   */
+
+
+	  static nonceAuthorize(params) {
+	    const type = SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount;
+	    const data = encodeData(type, {
+	      authorized: toBuffer(params.newAuthorizedPubkey.toBuffer())
+	    });
+	    return new TransactionInstruction({
+	      keys: [{
+	        pubkey: params.noncePubkey,
+	        isSigner: false,
+	        isWritable: true
+	      }, {
+	        pubkey: params.authorizedPubkey,
+	        isSigner: true,
+	        isWritable: false
+	      }],
+	      programId: this.programId,
+	      data
+	    });
+	  }
+	  /**
+	   * Generate a transaction instruction that allocates space in an account without funding
+	   */
+
+
+	  static allocate(params) {
+	    let data;
+	    let keys;
+
+	    if ('basePubkey' in params) {
+	      const type = SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed;
+	      data = encodeData(type, {
+	        base: toBuffer(params.basePubkey.toBuffer()),
+	        seed: params.seed,
+	        space: params.space,
+	        programId: toBuffer(params.programId.toBuffer())
+	      });
+	      keys = [{
+	        pubkey: params.accountPubkey,
+	        isSigner: false,
+	        isWritable: true
+	      }, {
+	        pubkey: params.basePubkey,
+	        isSigner: true,
+	        isWritable: false
+	      }];
+	    } else {
+	      const type = SYSTEM_INSTRUCTION_LAYOUTS.Allocate;
+	      data = encodeData(type, {
+	        space: params.space
+	      });
+	      keys = [{
+	        pubkey: params.accountPubkey,
+	        isSigner: true,
+	        isWritable: true
+	      }];
+	    }
+
+	    return new TransactionInstruction({
+	      keys,
+	      programId: this.programId,
+	      data
+	    });
+	  }
+
+	}
+	SystemProgram.programId = new PublicKey('11111111111111111111111111111111');
+
+	/**
+	 * An enumeration of valid address lookup table InstructionType's
+	 * @internal
+	 */
+	const LOOKUP_TABLE_INSTRUCTION_LAYOUTS = Object.freeze({
+	  CreateLookupTable: {
+	    index: 0,
+	    layout: struct([u32('instruction'), u64('recentSlot'), u8('bumpSeed')])
+	  },
+	  FreezeLookupTable: {
+	    index: 1,
+	    layout: struct([u32('instruction')])
+	  },
+	  ExtendLookupTable: {
+	    index: 2,
+	    layout: struct([u32('instruction'), u64(), seq(publicKey(), offset(u32(), -8), 'addresses')])
+	  },
+	  DeactivateLookupTable: {
+	    index: 3,
+	    layout: struct([u32('instruction')])
+	  },
+	  CloseLookupTable: {
+	    index: 4,
+	    layout: struct([u32('instruction')])
+	  }
+	});
+	class AddressLookupTableInstruction {
+	  /**
+	   * @internal
+	   */
+	  constructor() {}
+
+	  static decodeInstructionType(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    const instructionTypeLayout = u32('instruction');
+	    const index = instructionTypeLayout.decode(instruction.data);
+	    let type;
+
+	    for (const [layoutType, layout] of Object.entries(LOOKUP_TABLE_INSTRUCTION_LAYOUTS)) {
+	      if (layout.index == index) {
+	        type = layoutType;
+	        break;
+	      }
+	    }
+
+	    if (!type) {
+	      throw new Error('Invalid Instruction. Should be a LookupTable Instruction');
+	    }
+
+	    return type;
+	  }
+
+	  static decodeCreateLookupTable(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    this.checkKeysLength(instruction.keys, 4);
+	    const {
+	      recentSlot
+	    } = decodeData(LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable, instruction.data);
+	    return {
+	      authority: instruction.keys[1].pubkey,
+	      payer: instruction.keys[2].pubkey,
+	      recentSlot: Number(recentSlot)
+	    };
+	  }
+
+	  static decodeExtendLookupTable(instruction) {
+	    this.checkProgramId(instruction.programId);
+
+	    if (instruction.keys.length < 2) {
+	      throw new Error(`invalid instruction; found ${instruction.keys.length} keys, expected at least 2`);
+	    }
+
+	    const {
+	      addresses
+	    } = decodeData(LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable, instruction.data);
+	    return {
+	      lookupTable: instruction.keys[0].pubkey,
+	      authority: instruction.keys[1].pubkey,
+	      payer: instruction.keys.length > 2 ? instruction.keys[2].pubkey : undefined,
+	      addresses: addresses.map(buffer => new PublicKey(buffer))
+	    };
+	  }
+
+	  static decodeCloseLookupTable(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    this.checkKeysLength(instruction.keys, 3);
+	    return {
+	      lookupTable: instruction.keys[0].pubkey,
+	      authority: instruction.keys[1].pubkey,
+	      recipient: instruction.keys[2].pubkey
+	    };
+	  }
+
+	  static decodeFreezeLookupTable(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    this.checkKeysLength(instruction.keys, 2);
+	    return {
+	      lookupTable: instruction.keys[0].pubkey,
+	      authority: instruction.keys[1].pubkey
+	    };
+	  }
+
+	  static decodeDeactivateLookupTable(instruction) {
+	    this.checkProgramId(instruction.programId);
+	    this.checkKeysLength(instruction.keys, 2);
+	    return {
+	      lookupTable: instruction.keys[0].pubkey,
+	      authority: instruction.keys[1].pubkey
+	    };
+	  }
+	  /**
+	   * @internal
+	   */
+
+
+	  static checkProgramId(programId) {
+	    if (!programId.equals(AddressLookupTableProgram.programId)) {
+	      throw new Error('invalid instruction; programId is not AddressLookupTable Program');
+	    }
+	  }
+	  /**
+	   * @internal
 	   */
 
 
-	  static nonceAdvance(params) {
-	    const type = SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount;
-	    const data = encodeData(type);
-	    const instructionData = {
-	      keys: [{
-	        pubkey: params.noncePubkey,
-	        isSigner: false,
-	        isWritable: true
-	      }, {
-	        pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
-	        isSigner: false,
-	        isWritable: false
-	      }, {
-	        pubkey: params.authorizedPubkey,
-	        isSigner: true,
-	        isWritable: false
-	      }],
-	      programId: this.programId,
-	      data
-	    };
-	    return new TransactionInstruction(instructionData);
+	  static checkKeysLength(keys, expectedLength) {
+	    if (keys.length < expectedLength) {
+	      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);
+	    }
 	  }
+
+	}
+	class AddressLookupTableProgram {
 	  /**
-	   * Generate a transaction instruction that withdraws lamports from a Nonce account
+	   * @internal
 	   */
+	  constructor() {}
 
-
-	  static nonceWithdraw(params) {
-	    const type = SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount;
+	  static createLookupTable(params) {
+	    const [lookupTableAddress, bumpSeed] = PublicKey.findProgramAddressSync([params.authority.toBuffer(), toBufferLE_1(BigInt(params.recentSlot), 8)], this.programId);
+	    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable;
 	    const data = encodeData(type, {
-	      lamports: params.lamports
+	      recentSlot: BigInt(params.recentSlot),
+	      bumpSeed: bumpSeed
 	    });
-	    return new TransactionInstruction({
-	      keys: [{
-	        pubkey: params.noncePubkey,
-	        isSigner: false,
-	        isWritable: true
-	      }, {
-	        pubkey: params.toPubkey,
-	        isSigner: false,
-	        isWritable: true
-	      }, {
-	        pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
-	        isSigner: false,
-	        isWritable: false
-	      }, {
-	        pubkey: SYSVAR_RENT_PUBKEY,
-	        isSigner: false,
-	        isWritable: false
-	      }, {
-	        pubkey: params.authorizedPubkey,
-	        isSigner: true,
-	        isWritable: false
-	      }],
+	    const keys = [{
+	      pubkey: lookupTableAddress,
+	      isSigner: false,
+	      isWritable: true
+	    }, {
+	      pubkey: params.authority,
+	      isSigner: true,
+	      isWritable: false
+	    }, {
+	      pubkey: params.payer,
+	      isSigner: true,
+	      isWritable: true
+	    }, {
+	      pubkey: SystemProgram.programId,
+	      isSigner: false,
+	      isWritable: false
+	    }];
+	    return [new TransactionInstruction({
 	      programId: this.programId,
-	      data
-	    });
+	      keys: keys,
+	      data: data
+	    }), lookupTableAddress];
 	  }
-	  /**
-	   * Generate a transaction instruction that authorizes a new PublicKey as the authority
-	   * on a Nonce account.
-	   */
-
 
-	  static nonceAuthorize(params) {
-	    const type = SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount;
-	    const data = encodeData(type, {
-	      authorized: toBuffer(params.newAuthorizedPubkey.toBuffer())
-	    });
+	  static freezeLookupTable(params) {
+	    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.FreezeLookupTable;
+	    const data = encodeData(type);
+	    const keys = [{
+	      pubkey: params.lookupTable,
+	      isSigner: false,
+	      isWritable: true
+	    }, {
+	      pubkey: params.authority,
+	      isSigner: true,
+	      isWritable: false
+	    }];
 	    return new TransactionInstruction({
-	      keys: [{
-	        pubkey: params.noncePubkey,
-	        isSigner: false,
-	        isWritable: true
-	      }, {
-	        pubkey: params.authorizedPubkey,
-	        isSigner: true,
-	        isWritable: false
-	      }],
 	      programId: this.programId,
-	      data
+	      keys: keys,
+	      data: data
 	    });
 	  }
-	  /**
-	   * Generate a transaction instruction that allocates space in an account without funding
-	   */
 
+	  static extendLookupTable(params) {
+	    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable;
+	    const data = encodeData(type, {
+	      addresses: params.addresses.map(addr => addr.toBytes())
+	    });
+	    const keys = [{
+	      pubkey: params.lookupTable,
+	      isSigner: false,
+	      isWritable: true
+	    }, {
+	      pubkey: params.authority,
+	      isSigner: true,
+	      isWritable: false
+	    }];
 
-	  static allocate(params) {
-	    let data;
-	    let keys;
-
-	    if ('basePubkey' in params) {
-	      const type = SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed;
-	      data = encodeData(type, {
-	        base: toBuffer(params.basePubkey.toBuffer()),
-	        seed: params.seed,
-	        space: params.space,
-	        programId: toBuffer(params.programId.toBuffer())
-	      });
-	      keys = [{
-	        pubkey: params.accountPubkey,
-	        isSigner: false,
+	    if (params.payer) {
+	      keys.push({
+	        pubkey: params.payer,
+	        isSigner: true,
 	        isWritable: true
 	      }, {
-	        pubkey: params.basePubkey,
-	        isSigner: true,
+	        pubkey: SystemProgram.programId,
+	        isSigner: false,
 	        isWritable: false
-	      }];
-	    } else {
-	      const type = SYSTEM_INSTRUCTION_LAYOUTS.Allocate;
-	      data = encodeData(type, {
-	        space: params.space
 	      });
-	      keys = [{
-	        pubkey: params.accountPubkey,
-	        isSigner: true,
-	        isWritable: true
-	      }];
 	    }
 
 	    return new TransactionInstruction({
-	      keys,
 	      programId: this.programId,
-	      data
+	      keys: keys,
+	      data: data
+	    });
+	  }
+
+	  static deactivateLookupTable(params) {
+	    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.DeactivateLookupTable;
+	    const data = encodeData(type);
+	    const keys = [{
+	      pubkey: params.lookupTable,
+	      isSigner: false,
+	      isWritable: true
+	    }, {
+	      pubkey: params.authority,
+	      isSigner: true,
+	      isWritable: false
+	    }];
+	    return new TransactionInstruction({
+	      programId: this.programId,
+	      keys: keys,
+	      data: data
+	    });
+	  }
+
+	  static closeLookupTable(params) {
+	    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CloseLookupTable;
+	    const data = encodeData(type);
+	    const keys = [{
+	      pubkey: params.lookupTable,
+	      isSigner: false,
+	      isWritable: true
+	    }, {
+	      pubkey: params.authority,
+	      isSigner: true,
+	      isWritable: false
+	    }, {
+	      pubkey: params.recipient,
+	      isSigner: false,
+	      isWritable: true
+	    }];
+	    return new TransactionInstruction({
+	      programId: this.programId,
+	      keys: keys,
+	      data: data
 	    });
 	  }
 
 	}
-	SystemProgram.programId = new PublicKey('11111111111111111111111111111111');
+	AddressLookupTableProgram.programId = new PublicKey('AddressLookupTab1e1111111111111111111111111');
+
+	const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader1111111111111111111111111111111111');
+
+	/**
+	 * Sign, send and confirm a transaction.
+	 *
+	 * If `commitment` option is not specified, defaults to 'max' commitment.
+	 *
+	 * @param {Connection} connection
+	 * @param {Transaction} transaction
+	 * @param {Array<Signer>} signers
+	 * @param {ConfirmOptions} [options]
+	 * @returns {Promise<TransactionSignature>}
+	 */
+	async function sendAndConfirmTransaction(connection, transaction, signers, options) {
+	  const sendOptions = options && {
+	    skipPreflight: options.skipPreflight,
+	    preflightCommitment: options.preflightCommitment || options.commitment,
+	    maxRetries: options.maxRetries,
+	    minContextSlot: options.minContextSlot
+	  };
+	  const signature = await connection.sendTransaction(transaction, signers, sendOptions);
+	  const status = transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null ? (await connection.confirmTransaction({
+	    signature: signature,
+	    blockhash: transaction.recentBlockhash,
+	    lastValidBlockHeight: transaction.lastValidBlockHeight
+	  }, options && options.commitment)).value : (await connection.confirmTransaction(signature, options && options.commitment)).value;
+
+	  if (status.err) {
+	    throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
+	  }
+
+	  return signature;
+	}
+
+	// zzz
+	function sleep(ms) {
+	  return new Promise(resolve => setTimeout(resolve, ms));
+	}
 
 	// rest of the Transaction fields
 	//
@@ -21556,8 +21836,15 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
-	  async getBlock(slot, opts) {
-	    const args = this._buildArgsAtLeastConfirmed([slot], opts && opts.commitment);
+	  async getBlock(slot, rawConfig) {
+	    const {
+	      commitment,
+	      config
+	    } = extractCommitmentFromConfig(rawConfig);
+
+	    const args = this._buildArgsAtLeastConfirmed([slot], commitment, undefined
+	    /* encoding */
+	    , config);
 
 	    const unsafeRes = await this._rpcRequest('getBlock', args);
 	    const res = create(unsafeRes, GetBlockRpcResult);
@@ -21643,8 +21930,15 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
-	  async getTransaction(signature, opts) {
-	    const args = this._buildArgsAtLeastConfirmed([signature], opts && opts.commitment);
+	  async getTransaction(signature, rawConfig) {
+	    const {
+	      commitment,
+	      config
+	    } = extractCommitmentFromConfig(rawConfig);
+
+	    const args = this._buildArgsAtLeastConfirmed([signature], commitment, undefined
+	    /* encoding */
+	    , config);
 
 	    const unsafeRes = await this._rpcRequest('getTransaction', args);
 	    const res = create(unsafeRes, GetTransactionRpcResult);
@@ -21666,8 +21960,13 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
-	  async getParsedTransaction(signature, commitment) {
-	    const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed');
+	  async getParsedTransaction(signature, commitmentOrConfig) {
+	    const {
+	      commitment,
+	      config
+	    } = extractCommitmentFromConfig(commitmentOrConfig);
+
+	    const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed', config);
 
 	    const unsafeRes = await this._rpcRequest('getTransaction', args);
 	    const res = create(unsafeRes, GetParsedTransactionRpcResult);
@@ -21683,9 +21982,13 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
-	  async getParsedTransactions(signatures, commitment) {
+	  async getParsedTransactions(signatures, commitmentOrConfig) {
+	    const {
+	      commitment,
+	      config
+	    } = extractCommitmentFromConfig(commitmentOrConfig);
 	    const batch = signatures.map(signature => {
-	      const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed');
+	      const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed', config);
 
 	      return {
 	        methodName: 'getTransaction',
@@ -21710,9 +22013,15 @@ var solanaWeb3 = (function (exports) {
 	   */
 
 
-	  async getTransactions(signatures, commitment) {
+	  async getTransactions(signatures, commitmentOrConfig) {
+	    const {
+	      commitment,
+	      config
+	    } = extractCommitmentFromConfig(commitmentOrConfig);
 	    const batch = signatures.map(signature => {
-	      const args = this._buildArgsAtLeastConfirmed([signature], commitment);
+	      const args = this._buildArgsAtLeastConfirmed([signature], commitment, undefined
+	      /* encoding */
+	      , config);
 
 	      return {
 	        methodName: 'getTransaction',
@@ -22154,6 +22463,28 @@ var solanaWeb3 = (function (exports) {
 	      this._pollingBlockhash = false;
 	    }
 	  }
+	  /**
+	   * get the stake minimum delegation
+	   */
+
+
+	  async getStakeMinimumDelegation(config) {
+	    const {
+	      commitment,
+	      config: configArg
+	    } = extractCommitmentFromConfig(config);
+
+	    const args = this._buildArgs([], commitment, 'base64', configArg);
+
+	    const unsafeRes = await this._rpcRequest('getStakeMinimumDelegation', args);
+	    const res = create(unsafeRes, jsonRpcResultAndContext(number()));
+
+	    if ('error' in res) {
+	      throw new SolanaJSONRPCError(res.error, `failed to get stake minimum delegation`);
+	    }
+
+	    return res.result;
+	  }
 	  /**
 	   * Simulate a transaction
 	   */
@@ -30385,6 +30716,8 @@ var solanaWeb3 = (function (exports) {
 	const LAMPORTS_PER_SOL = 1000000000;
 
 	exports.Account = Account;
+	exports.AddressLookupTableInstruction = AddressLookupTableInstruction;
+	exports.AddressLookupTableProgram = AddressLookupTableProgram;
 	exports.Authorized = Authorized;
 	exports.BLOCKHASH_CACHE_TIMEOUT_MS = BLOCKHASH_CACHE_TIMEOUT_MS;
 	exports.BPF_LOADER_DEPRECATED_PROGRAM_ID = BPF_LOADER_DEPRECATED_PROGRAM_ID;
@@ -30400,6 +30733,7 @@ var solanaWeb3 = (function (exports) {
 	exports.FeeCalculatorLayout = FeeCalculatorLayout;
 	exports.Keypair = Keypair;
 	exports.LAMPORTS_PER_SOL = LAMPORTS_PER_SOL;
+	exports.LOOKUP_TABLE_INSTRUCTION_LAYOUTS = LOOKUP_TABLE_INSTRUCTION_LAYOUTS;
 	exports.Loader = Loader;
 	exports.Lockup = Lockup;
 	exports.MAX_SEED_LENGTH = MAX_SEED_LENGTH;