@solana/web3.js 1.47.3 → 1.49.0

package/lib/index.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');
@@ -2128,18 +2128,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
  */
@@ -2201,17 +2189,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;
@@ -3096,201 +3237,34 @@ class Transaction {
       transaction.feePayer = message.accountKeys[0];
     }
 
-    signatures.forEach((signature, index) => {
-      const sigPubkeyPair = {
-        signature: signature == bs58__default["default"].encode(DEFAULT_SIGNATURE) ? null : bs58__default["default"].decode(signature),
-        publicKey: message.accountKeys[index]
-      };
-      transaction.signatures.push(sigPubkeyPair);
-    });
-    message.instructions.forEach(instruction => {
-      const keys = instruction.accounts.map(account => {
-        const pubkey = message.accountKeys[account];
-        return {
-          pubkey,
-          isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()) || message.isAccountSigner(account),
-          isWritable: message.isAccountWritable(account)
-        };
-      });
-      transaction.instructions.push(new TransactionInstruction({
-        keys,
-        programId: message.accountKeys[instruction.programIdIndex],
-        data: bs58__default["default"].decode(instruction.data)
-      }));
-    });
-    transaction._message = message;
-    transaction._json = transaction.toJSON();
-    return 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>}
- */
-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 = 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;
-};
+    signatures.forEach((signature, index) => {
+      const sigPubkeyPair = {
+        signature: signature == bs58__default["default"].encode(DEFAULT_SIGNATURE) ? null : bs58__default["default"].decode(signature),
+        publicKey: message.accountKeys[index]
+      };
+      transaction.signatures.push(sigPubkeyPair);
+    });
+    message.instructions.forEach(instruction => {
+      const keys = instruction.accounts.map(account => {
+        const pubkey = message.accountKeys[account];
+        return {
+          pubkey,
+          isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()) || message.isAccountSigner(account),
+          isWritable: message.isAccountWritable(account)
+        };
+      });
+      transaction.instructions.push(new TransactionInstruction({
+        keys,
+        programId: message.accountKeys[instruction.programIdIndex],
+        data: bs58__default["default"].decode(instruction.data)
+      }));
+    });
+    transaction._message = message;
+    transaction._json = transaction.toJSON();
+    return transaction;
+  }
 
-const u64 = bigInt(8);
+}
 
 /**
  * Create account system transaction params
@@ -4007,6 +3981,312 @@ class SystemProgram {
 }
 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 checkKeysLength(keys, expectedLength) {
+    if (keys.length < expectedLength) {
+      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);
+    }
+  }
+
+}
+class AddressLookupTableProgram {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  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, {
+      recentSlot: BigInt(params.recentSlot),
+      bumpSeed: bumpSeed
+    });
+    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,
+      keys: keys,
+      data: data
+    }), lookupTableAddress];
+  }
+
+  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({
+      programId: this.programId,
+      keys: keys,
+      data: data
+    });
+  }
+
+  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
+    }];
+
+    if (params.payer) {
+      keys.push({
+        pubkey: params.payer,
+        isSigner: true,
+        isWritable: true
+      }, {
+        pubkey: SystemProgram.programId,
+        isSigner: false,
+        isWritable: false
+      });
+    }
+
+    return new TransactionInstruction({
+      programId: this.programId,
+      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
+    });
+  }
+
+}
+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
 //
 // TODO: replace 300 with a proper constant for the size of the other
@@ -4475,6 +4755,8 @@ var fastStableStringify = function(val) {
 
 var fastStableStringify$1 = fastStableStringify;
 
+const URL = globalThis.URL;
+
 const DESTROY_TIMEOUT_MS = 5000;
 class AgentManager {
   static _newAgent(useHttps) {
@@ -4924,7 +5206,11 @@ const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(superstruct.t
     data: superstruct.array(superstruct.string()),
     rentEpoch: superstruct.optional(superstruct.number())
   }))))),
-  unitsConsumed: superstruct.optional(superstruct.number())
+  unitsConsumed: superstruct.optional(superstruct.number()),
+  returnData: superstruct.optional(superstruct.nullable(superstruct.type({
+    programId: superstruct.string(),
+    data: superstruct.tuple([superstruct.string(), superstruct.literal('base64')])
+  })))
 }));
 
 /**
@@ -6810,8 +7096,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);
@@ -6897,8 +7190,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);
@@ -10046,6 +10346,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;
@@ -10061,6 +10363,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;