@solana/web3.js 1.47.4 → 1.50.0

package/lib/index.browser.cjs.js

@@ -7,8 +7,8 @@ var buffer = require('buffer');
 var BN = require('bn.js');
 var bs58 = require('bs58');
 var borsh = require('borsh');
-var BufferLayout = require('@solana/buffer-layout');
 var bigintBuffer = require('bigint-buffer');
+var BufferLayout = require('@solana/buffer-layout');
 var superstruct = require('superstruct');
 var rpcWebsockets = require('rpc-websockets');
 var RpcClient = require('jayson/lib/client/browser');
@@ -2101,18 +2101,6 @@ class Account {
 
 }
 
-const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader1111111111111111111111111111111111');
-
-/**
- * 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
  */
@@ -2174,17 +2162,170 @@ const voteInit = (property = 'voteInit') => {
   return BufferLayout__namespace.struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), BufferLayout__namespace.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 = BufferLayout.blob(length, property);
+  const {
+    encode,
+    decode
+  } = encodeDecode(layout);
+  const bigIntLayout = layout;
+
+  bigIntLayout.decode = (buffer$1, offset) => {
+    const src = decode(buffer$1, offset);
+    return bigintBuffer.toBigIntLE(buffer.Buffer.from(src));
+  };
+
+  bigIntLayout.encode = (bigInt, buffer, offset) => {
+    const src = bigintBuffer.toBufferLE(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 = BufferLayout__namespace.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 = BufferLayout__namespace.struct([BufferLayout__namespace.u32('version'), BufferLayout__namespace.u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), BufferLayout__namespace.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;
@@ -3098,202 +3239,35 @@ class Transaction {
 
 }
 
-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');
-
 /**
- * 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>}
+ * Create account system transaction params
  */
-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
+ * System Instruction class
  */
+class SystemInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+  /**
+   * Decode a system instruction and retrieve the instruction type.
+   */
 
-function decodeData(type, buffer) {
-  let data;
 
-  try {
-    data = type.layout.decode(buffer);
-  } catch (err) {
-    throw new Error('invalid instruction; ' + err);
-  }
+  static decodeInstructionType(instruction) {
+    this.checkProgramId(instruction.programId);
+    const instructionTypeLayout = BufferLayout__namespace.u32('instruction');
+    const typeIndex = instructionTypeLayout.decode(instruction.data);
+    let type;
 
-  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 = BufferLayout__namespace.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 = BufferLayout__namespace.struct([BufferLayout__namespace.u32('version'), BufferLayout__namespace.u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), BufferLayout__namespace.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 encodeDecode = layout => {
-  const decode = layout.decode.bind(layout);
-  const encode = layout.encode.bind(layout);
-  return {
-    decode,
-    encode
-  };
-};
-
-const bigInt = length => property => {
-  const layout = BufferLayout.blob(length, property);
-  const {
-    encode,
-    decode
-  } = encodeDecode(layout);
-  const bigIntLayout = layout;
-
-  bigIntLayout.decode = (buffer$1, offset) => {
-    const src = decode(buffer$1, offset);
-    return bigintBuffer.toBigIntLE(buffer.Buffer.from(src));
-  };
-
-  bigIntLayout.encode = (bigInt, buffer, offset) => {
-    const src = bigintBuffer.toBufferLE(bigInt, length);
-    return encode(src, buffer, offset);
-  };
-
-  return bigIntLayout;
-};
-
-const u64 = bigInt(8);
-
-/**
- * Create account system transaction params
- */
-
-/**
- * System Instruction class
- */
-class SystemInstruction {
-  /**
-   * @internal
-   */
-  constructor() {}
-  /**
-   * Decode a system instruction and retrieve the instruction type.
-   */
-
-
-  static decodeInstructionType(instruction) {
-    this.checkProgramId(instruction.programId);
-    const instructionTypeLayout = BufferLayout__namespace.u32('instruction');
-    const typeIndex = instructionTypeLayout.decode(instruction.data);
-    let type;
-
-    for (const [ixType, layout] of Object.entries(SYSTEM_INSTRUCTION_LAYOUTS)) {
-      if (layout.index == typeIndex) {
-        type = ixType;
-        break;
-      }
-    }
+    for (const [ixType, layout] of Object.entries(SYSTEM_INSTRUCTION_LAYOUTS)) {
+      if (layout.index == typeIndex) {
+        type = ixType;
+        break;
+      }
+    }
 
     if (!type) {
       throw new Error('Instruction type incorrect; not a SystemInstruction');
@@ -3845,140 +3819,446 @@ class SystemProgram {
     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: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), u64('recentSlot'), BufferLayout__namespace.u8('bumpSeed')])
+  },
+  FreezeLookupTable: {
+    index: 1,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction')])
+  },
+  ExtendLookupTable: {
+    index: 2,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), u64(), BufferLayout__namespace.seq(publicKey(), BufferLayout__namespace.offset(BufferLayout__namespace.u32(), -8), 'addresses')])
+  },
+  DeactivateLookupTable: {
+    index: 3,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction')])
+  },
+  CloseLookupTable: {
+    index: 4,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction')])
+  }
+});
+class AddressLookupTableInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  static decodeInstructionType(instruction) {
+    this.checkProgramId(instruction.programId);
+    const instructionTypeLayout = BufferLayout__namespace.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(), bigintBuffer.toBufferLE(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
 //
@@ -6731,8 +7011,15 @@ class Connection {
    */
 
 
-  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 = superstruct.create(unsafeRes, GetBlockRpcResult);
@@ -6818,8 +7105,15 @@ class Connection {
    */
 
 
-  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 = superstruct.create(unsafeRes, GetTransactionRpcResult);
@@ -6841,8 +7135,13 @@ class Connection {
    */
 
 
-  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 = superstruct.create(unsafeRes, GetParsedTransactionRpcResult);
@@ -6858,9 +7157,13 @@ class Connection {
    */
 
 
-  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',
@@ -6885,9 +7188,15 @@ class Connection {
    */
 
 
-  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',
@@ -7329,6 +7638,28 @@ class Connection {
       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 = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.number()));
+
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(res.error, `failed to get stake minimum delegation`);
+    }
+
+    return res.result;
+  }
   /**
    * Simulate a transaction
    */
@@ -9967,6 +10298,8 @@ function clusterApiUrl(cluster, tls) {
 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;
@@ -9982,6 +10315,7 @@ exports.EpochSchedule = EpochSchedule;
 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;