@solana/web3.js 1.57.0 → 1.58.0

package/lib/index.iife.js

@@ -11087,6 +11087,129 @@ var solanaWeb3 = (function (exports) {
 	  }
 	}
 
+	function assert$1 (condition, message) {
+	  if (!condition) {
+	    throw new Error(message || 'Assertion failed');
+	  }
+	}
+
+	class CompiledKeys {
+	  constructor(payer, keyMetaMap) {
+	    this.payer = void 0;
+	    this.keyMetaMap = void 0;
+	    this.payer = payer;
+	    this.keyMetaMap = keyMetaMap;
+	  }
+
+	  static compile(instructions, payer) {
+	    const keyMetaMap = new Map();
+
+	    const getOrInsertDefault = pubkey => {
+	      const address = pubkey.toBase58();
+	      let keyMeta = keyMetaMap.get(address);
+
+	      if (keyMeta === undefined) {
+	        keyMeta = {
+	          isSigner: false,
+	          isWritable: false,
+	          isInvoked: false
+	        };
+	        keyMetaMap.set(address, keyMeta);
+	      }
+
+	      return keyMeta;
+	    };
+
+	    const payerKeyMeta = getOrInsertDefault(payer);
+	    payerKeyMeta.isSigner = true;
+	    payerKeyMeta.isWritable = true;
+
+	    for (const ix of instructions) {
+	      getOrInsertDefault(ix.programId).isInvoked = true;
+
+	      for (const accountMeta of ix.keys) {
+	        const keyMeta = getOrInsertDefault(accountMeta.pubkey);
+	        keyMeta.isSigner || (keyMeta.isSigner = accountMeta.isSigner);
+	        keyMeta.isWritable || (keyMeta.isWritable = accountMeta.isWritable);
+	      }
+	    }
+
+	    return new CompiledKeys(payer, keyMetaMap);
+	  }
+
+	  getMessageComponents() {
+	    const mapEntries = [...this.keyMetaMap.entries()];
+	    assert$1(mapEntries.length <= 256, 'Max static account keys length exceeded');
+	    const writableSigners = mapEntries.filter(([, meta]) => meta.isSigner && meta.isWritable);
+	    const readonlySigners = mapEntries.filter(([, meta]) => meta.isSigner && !meta.isWritable);
+	    const writableNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && meta.isWritable);
+	    const readonlyNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && !meta.isWritable);
+	    const header = {
+	      numRequiredSignatures: writableSigners.length + readonlySigners.length,
+	      numReadonlySignedAccounts: readonlySigners.length,
+	      numReadonlyUnsignedAccounts: readonlyNonSigners.length
+	    }; // sanity checks
+
+	    {
+	      assert$1(writableSigners.length > 0, 'Expected at least one writable signer key');
+	      const [payerAddress] = writableSigners[0];
+	      assert$1(payerAddress === this.payer.toBase58(), 'Expected first writable signer key to be the fee payer');
+	    }
+	    const staticAccountKeys = [...writableSigners.map(([address]) => new PublicKey(address)), ...readonlySigners.map(([address]) => new PublicKey(address)), ...writableNonSigners.map(([address]) => new PublicKey(address)), ...readonlyNonSigners.map(([address]) => new PublicKey(address))];
+	    return [header, staticAccountKeys];
+	  }
+
+	  extractTableLookup(lookupTable) {
+	    const [writableIndexes, drainedWritableKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable);
+	    const [readonlyIndexes, drainedReadonlyKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable); // Don't extract lookup if no keys were found
+
+	    if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {
+	      return;
+	    }
+
+	    return [{
+	      accountKey: lookupTable.key,
+	      writableIndexes,
+	      readonlyIndexes
+	    }, {
+	      writable: drainedWritableKeys,
+	      readonly: drainedReadonlyKeys
+	    }];
+	  }
+	  /** @internal */
+
+
+	  drainKeysFoundInLookupTable(lookupTableEntries, keyMetaFilter) {
+	    const lookupTableIndexes = new Array();
+	    const drainedKeys = new Array();
+
+	    for (const [address, keyMeta] of this.keyMetaMap.entries()) {
+	      if (keyMetaFilter(keyMeta)) {
+	        const key = new PublicKey(address);
+	        const lookupTableIndex = lookupTableEntries.findIndex(entry => entry.equals(key));
+
+	        if (lookupTableIndex >= 0) {
+	          assert$1(lookupTableIndex < 256, 'Max lookup table index exceeded');
+	          lookupTableIndexes.push(lookupTableIndex);
+	          drainedKeys.push(key);
+	          this.keyMetaMap.delete(address);
+	        }
+	      }
+	    }
+
+	    return [lookupTableIndexes, drainedKeys];
+	  }
+
+	}
+
+	/**
+	 * An instruction to execute by a program
+	 *
+	 * @property {number} programIdIndex
+	 * @property {number[]} accounts
+	 * @property {string} data
+	 */
+
 	/**
 	 * List of instructions to be processed atomically
 	 */
@@ -11124,6 +11247,27 @@ var solanaWeb3 = (function (exports) {
 	    return [];
 	  }
 
+	  getAccountKeys() {
+	    return new MessageAccountKeys(this.staticAccountKeys);
+	  }
+
+	  static compile(args) {
+	    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
+	    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+	    const accountKeys = new MessageAccountKeys(staticAccountKeys);
+	    const instructions = accountKeys.compileInstructions(args.instructions).map(ix => ({
+	      programIdIndex: ix.programIdIndex,
+	      accounts: ix.accountKeyIndexes,
+	      data: bs58$1.encode(ix.data)
+	    }));
+	    return new Message({
+	      header,
+	      accountKeys: staticAccountKeys,
+	      recentBlockhash: args.recentBlockhash,
+	      instructions
+	    });
+	  }
+
 	  isAccountSigner(index) {
 	    return index < this.header.numRequiredSignatures;
 	  }
@@ -11213,7 +11357,7 @@ var solanaWeb3 = (function (exports) {
 	    for (let i = 0; i < accountCount; i++) {
 	      const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
 	      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
-	      accountKeys.push(bs58$1.encode(buffer.Buffer.from(account)));
+	      accountKeys.push(new PublicKey(buffer.Buffer.from(account)));
 	    }
 
 	    const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
@@ -11252,141 +11396,87 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
-	function assert$1 (condition, message) {
-	  if (!condition) {
-	    throw new Error(message || 'Assertion failed');
-	  }
-	}
+	/**
+	 * Message constructor arguments
+	 */
 
-	class CompiledKeys {
-	  constructor(payer, keyMetaMap) {
-	    this.payer = void 0;
-	    this.keyMetaMap = void 0;
-	    this.payer = payer;
-	    this.keyMetaMap = keyMetaMap;
+	class MessageV0 {
+	  constructor(args) {
+	    this.header = void 0;
+	    this.staticAccountKeys = void 0;
+	    this.recentBlockhash = void 0;
+	    this.compiledInstructions = void 0;
+	    this.addressTableLookups = void 0;
+	    this.header = args.header;
+	    this.staticAccountKeys = args.staticAccountKeys;
+	    this.recentBlockhash = args.recentBlockhash;
+	    this.compiledInstructions = args.compiledInstructions;
+	    this.addressTableLookups = args.addressTableLookups;
 	  }
 
-	  static compile(instructions, payer) {
-	    const keyMetaMap = new Map();
-
-	    const getOrInsertDefault = pubkey => {
-	      const address = pubkey.toBase58();
-	      let keyMeta = keyMetaMap.get(address);
-
-	      if (keyMeta === undefined) {
-	        keyMeta = {
-	          isSigner: false,
-	          isWritable: false,
-	          isInvoked: false
-	        };
-	        keyMetaMap.set(address, keyMeta);
-	      }
-
-	      return keyMeta;
-	    };
-
-	    const payerKeyMeta = getOrInsertDefault(payer);
-	    payerKeyMeta.isSigner = true;
-	    payerKeyMeta.isWritable = true;
+	  get version() {
+	    return 0;
+	  }
 
-	    for (const ix of instructions) {
-	      getOrInsertDefault(ix.programId).isInvoked = true;
+	  get numAccountKeysFromLookups() {
+	    let count = 0;
 
-	      for (const accountMeta of ix.keys) {
-	        const keyMeta = getOrInsertDefault(accountMeta.pubkey);
-	        keyMeta.isSigner || (keyMeta.isSigner = accountMeta.isSigner);
-	        keyMeta.isWritable || (keyMeta.isWritable = accountMeta.isWritable);
-	      }
+	    for (const lookup of this.addressTableLookups) {
+	      count += lookup.readonlyIndexes.length + lookup.writableIndexes.length;
 	    }
 
-	    return new CompiledKeys(payer, keyMetaMap);
+	    return count;
 	  }
 
-	  getMessageComponents() {
-	    const mapEntries = [...this.keyMetaMap.entries()];
-	    assert$1(mapEntries.length <= 256, 'Max static account keys length exceeded');
-	    const writableSigners = mapEntries.filter(([, meta]) => meta.isSigner && meta.isWritable);
-	    const readonlySigners = mapEntries.filter(([, meta]) => meta.isSigner && !meta.isWritable);
-	    const writableNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && meta.isWritable);
-	    const readonlyNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && !meta.isWritable);
-	    const header = {
-	      numRequiredSignatures: writableSigners.length + readonlySigners.length,
-	      numReadonlySignedAccounts: readonlySigners.length,
-	      numReadonlyUnsignedAccounts: readonlyNonSigners.length
-	    }; // sanity checks
-
-	    {
-	      assert$1(writableSigners.length > 0, 'Expected at least one writable signer key');
-	      const [payerAddress] = writableSigners[0];
-	      assert$1(payerAddress === this.payer.toBase58(), 'Expected first writable signer key to be the fee payer');
-	    }
-	    const staticAccountKeys = [...writableSigners.map(([address]) => new PublicKey(address)), ...readonlySigners.map(([address]) => new PublicKey(address)), ...writableNonSigners.map(([address]) => new PublicKey(address)), ...readonlyNonSigners.map(([address]) => new PublicKey(address))];
-	    return [header, staticAccountKeys];
-	  }
+	  getAccountKeys(args) {
+	    let accountKeysFromLookups;
 
-	  extractTableLookup(lookupTable) {
-	    const [writableIndexes, drainedWritableKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable);
-	    const [readonlyIndexes, drainedReadonlyKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable); // Don't extract lookup if no keys were found
+	    if (args && 'accountKeysFromLookups' in args) {
+	      if (this.numAccountKeysFromLookups != args.accountKeysFromLookups.writable.length + args.accountKeysFromLookups.readonly.length) {
+	        throw new Error('Failed to get account keys because of a mismatch in the number of account keys from lookups');
+	      }
 
-	    if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {
-	      return;
+	      accountKeysFromLookups = args.accountKeysFromLookups;
+	    } else if (args && 'addressLookupTableAccounts' in args) {
+	      accountKeysFromLookups = this.resolveAddressTableLookups(args.addressLookupTableAccounts);
+	    } else if (this.addressTableLookups.length > 0) {
+	      throw new Error('Failed to get account keys because address table lookups were not resolved');
 	    }
 
-	    return [{
-	      accountKey: lookupTable.key,
-	      writableIndexes,
-	      readonlyIndexes
-	    }, {
-	      writable: drainedWritableKeys,
-	      readonly: drainedReadonlyKeys
-	    }];
+	    return new MessageAccountKeys(this.staticAccountKeys, accountKeysFromLookups);
 	  }
-	  /** @internal */
 
+	  resolveAddressTableLookups(addressLookupTableAccounts) {
+	    const accountKeysFromLookups = {
+	      writable: [],
+	      readonly: []
+	    };
 
-	  drainKeysFoundInLookupTable(lookupTableEntries, keyMetaFilter) {
-	    const lookupTableIndexes = new Array();
-	    const drainedKeys = new Array();
+	    for (const tableLookup of this.addressTableLookups) {
+	      const tableAccount = addressLookupTableAccounts.find(account => account.key.equals(tableLookup.accountKey));
 
-	    for (const [address, keyMeta] of this.keyMetaMap.entries()) {
-	      if (keyMetaFilter(keyMeta)) {
-	        const key = new PublicKey(address);
-	        const lookupTableIndex = lookupTableEntries.findIndex(entry => entry.equals(key));
+	      if (!tableAccount) {
+	        throw new Error(`Failed to find address lookup table account for table key ${tableLookup.accountKey.toBase58()}`);
+	      }
 
-	        if (lookupTableIndex >= 0) {
-	          assert$1(lookupTableIndex < 256, 'Max lookup table index exceeded');
-	          lookupTableIndexes.push(lookupTableIndex);
-	          drainedKeys.push(key);
-	          this.keyMetaMap.delete(address);
+	      for (const index of tableLookup.writableIndexes) {
+	        if (index < tableAccount.state.addresses.length) {
+	          accountKeysFromLookups.writable.push(tableAccount.state.addresses[index]);
+	        } else {
+	          throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);
 	        }
 	      }
-	    }
-
-	    return [lookupTableIndexes, drainedKeys];
-	  }
-
-	}
-
-	/**
-	 * Message constructor arguments
-	 */
 
-	class MessageV0 {
-	  constructor(args) {
-	    this.header = void 0;
-	    this.staticAccountKeys = void 0;
-	    this.recentBlockhash = void 0;
-	    this.compiledInstructions = void 0;
-	    this.addressTableLookups = void 0;
-	    this.header = args.header;
-	    this.staticAccountKeys = args.staticAccountKeys;
-	    this.recentBlockhash = args.recentBlockhash;
-	    this.compiledInstructions = args.compiledInstructions;
-	    this.addressTableLookups = args.addressTableLookups;
-	  }
+	      for (const index of tableLookup.readonlyIndexes) {
+	        if (index < tableAccount.state.addresses.length) {
+	          accountKeysFromLookups.readonly.push(tableAccount.state.addresses[index]);
+	        } else {
+	          throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);
+	        }
+	      }
+	    }
 
-	  get version() {
-	    return 0;
+	    return accountKeysFromLookups;
 	  }
 
 	  static compile(args) {
@@ -12318,6 +12408,114 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
+	class TransactionMessage {
+	  constructor(args) {
+	    this.accountKeys = void 0;
+	    this.instructions = void 0;
+	    this.recentBlockhash = void 0;
+	    this.accountKeys = args.accountKeys;
+	    this.instructions = args.instructions;
+	    this.recentBlockhash = args.recentBlockhash;
+	  }
+
+	  static decompile(message, args) {
+	    const {
+	      header,
+	      compiledInstructions,
+	      recentBlockhash
+	    } = message;
+	    const {
+	      numRequiredSignatures,
+	      numReadonlySignedAccounts,
+	      numReadonlyUnsignedAccounts
+	    } = header;
+	    const numWritableSignedAccounts = numRequiredSignatures - numReadonlySignedAccounts;
+	    assert$1(numWritableSignedAccounts > 0, 'Message header is invalid');
+	    const numWritableUnsignedAccounts = message.staticAccountKeys.length - numReadonlyUnsignedAccounts;
+	    assert$1(numWritableUnsignedAccounts >= 0, 'Message header is invalid');
+	    const accountKeys = message.getAccountKeys(args);
+	    const instructions = [];
+
+	    for (const compiledIx of compiledInstructions) {
+	      const keys = [];
+
+	      for (const keyIndex of compiledIx.accountKeyIndexes) {
+	        const pubkey = accountKeys.get(keyIndex);
+
+	        if (pubkey === undefined) {
+	          throw new Error(`Failed to find key for account key index ${keyIndex}`);
+	        }
+
+	        const isSigner = keyIndex < numRequiredSignatures;
+	        let isWritable;
+
+	        if (isSigner) {
+	          isWritable = keyIndex < numWritableSignedAccounts;
+	        } else if (keyIndex < accountKeys.staticAccountKeys.length) {
+	          isWritable = keyIndex - numRequiredSignatures < numWritableUnsignedAccounts;
+	        } else {
+	          isWritable = keyIndex - accountKeys.staticAccountKeys.length < // accountKeysFromLookups cannot be undefined because we already found a pubkey for this index above
+	          accountKeys.accountKeysFromLookups.writable.length;
+	        }
+
+	        keys.push({
+	          pubkey,
+	          isSigner: keyIndex < header.numRequiredSignatures,
+	          isWritable
+	        });
+	      }
+
+	      const programId = accountKeys.get(compiledIx.programIdIndex);
+
+	      if (programId === undefined) {
+	        throw new Error(`Failed to find program id for program id index ${compiledIx.programIdIndex}`);
+	      }
+
+	      instructions.push(new TransactionInstruction({
+	        programId,
+	        data: toBuffer(compiledIx.data),
+	        keys
+	      }));
+	    }
+
+	    return new TransactionMessage({
+	      accountKeys,
+	      instructions,
+	      recentBlockhash
+	    });
+	  }
+
+	  compileToLegacyMessage() {
+	    const payerKey = this.accountKeys.get(0);
+
+	    if (payerKey === undefined) {
+	      throw new Error('Failed to compile message because no account keys were found');
+	    }
+
+	    return Message.compile({
+	      payerKey,
+	      recentBlockhash: this.recentBlockhash,
+	      instructions: this.instructions
+	    });
+	  }
+
+	  compileToV0Message(addressLookupTableAccounts) {
+	    const payerKey = this.accountKeys.get(0);
+
+	    if (payerKey === undefined) {
+	      throw new Error('Failed to compile message because no account keys were found');
+	    }
+
+	    return MessageV0.compile({
+	      payerKey,
+	      recentBlockhash: this.recentBlockhash,
+	      instructions: this.instructions,
+	      addressLookupTableAccounts
+	    });
+	  }
+
+	}
+
 	/**
 	 * Versioned transaction class
 	 */
@@ -19786,10 +19984,44 @@ var solanaWeb3 = (function (exports) {
 	  }
 	  /**
 	   * Simulate a transaction
+	   *
+	   * @deprecated Instead, call {@link simulateTransaction} with {@link
+	   * VersionedTransaction} and {@link SimulateTransactionConfig} parameters
 	   */
 
 
-	  async simulateTransaction(transactionOrMessage, signers, includeAccounts) {
+	  /**
+	   * Simulate a transaction
+	   */
+	  // eslint-disable-next-line no-dupe-class-members
+	  async simulateTransaction(transactionOrMessage, configOrSigners, includeAccounts) {
+	    if ('message' in transactionOrMessage) {
+	      const versionedTx = transactionOrMessage;
+	      const wireTransaction = versionedTx.serialize();
+	      const encodedTransaction = buffer.Buffer.from(wireTransaction).toString('base64');
+
+	      if (Array.isArray(configOrSigners) || includeAccounts !== undefined) {
+	        throw new Error('Invalid arguments');
+	      }
+
+	      const config = configOrSigners || {};
+	      config.encoding = 'base64';
+
+	      if (!('commitment' in config)) {
+	        config.commitment = this.commitment;
+	      }
+
+	      const args = [encodedTransaction, config];
+	      const unsafeRes = await this._rpcRequest('simulateTransaction', args);
+	      const res = create(unsafeRes, SimulatedTransactionResponseStruct);
+
+	      if ('error' in res) {
+	        throw new Error('failed to simulate transaction: ' + res.error.message);
+	      }
+
+	      return res.result;
+	    }
+
 	    let transaction;
 
 	    if (transactionOrMessage instanceof Transaction) {
@@ -19805,6 +20037,12 @@ var solanaWeb3 = (function (exports) {
 	      transaction._message = transaction._json = undefined;
 	    }
 
+	    if (configOrSigners !== undefined && !Array.isArray(configOrSigners)) {
+	      throw new Error('Invalid arguments');
+	    }
+
+	    const signers = configOrSigners;
+
 	    if (transaction.nonceInfo && signers) {
 	      transaction.sign(...signers);
 	    } else {
@@ -19885,12 +20123,34 @@ var solanaWeb3 = (function (exports) {
 
 	    return res.result;
 	  }
+	  /**
+	   * Sign and send a transaction
+	   *
+	   * @deprecated Instead, call {@link sendTransaction} with a {@link
+	   * VersionedTransaction}
+	   */
+
+
 	  /**
 	   * Sign and send a transaction
 	   */
+	  // eslint-disable-next-line no-dupe-class-members
+	  async sendTransaction(transaction, signersOrOptions, options) {
+	    if ('message' in transaction) {
+	      if (signersOrOptions && Array.isArray(signersOrOptions)) {
+	        throw new Error('Invalid arguments');
+	      }
+
+	      const wireTransaction = transaction.serialize();
+	      return await this.sendRawTransaction(wireTransaction, options);
+	    }
+
+	    if (signersOrOptions === undefined || !Array.isArray(signersOrOptions)) {
+	      throw new Error('Invalid arguments');
+	    }
 
+	    const signers = signersOrOptions;
 
-	  async sendTransaction(transaction, signers, options) {
 	    if (transaction.nonceInfo) {
 	      transaction.sign(...signers);
 	    } else {
@@ -24648,6 +24908,7 @@ var solanaWeb3 = (function (exports) {
 	exports.TransactionExpiredBlockheightExceededError = TransactionExpiredBlockheightExceededError;
 	exports.TransactionExpiredTimeoutError = TransactionExpiredTimeoutError;
 	exports.TransactionInstruction = TransactionInstruction;
+	exports.TransactionMessage = TransactionMessage;
 	exports.VALIDATOR_INFO_KEY = VALIDATOR_INFO_KEY;
 	exports.VERSION_PREFIX_MASK = VERSION_PREFIX_MASK;
 	exports.VOTE_PROGRAM_ID = VOTE_PROGRAM_ID;