@solana/web3.js 1.56.1 → 1.58.0

package/lib/index.iife.js

@@ -8308,12 +8308,14 @@ var solanaWeb3 = (function (exports) {
 
 	function isPublicKeyData(value) {
 	  return value._bn !== undefined;
-	}
+	} // local counter used by PublicKey.unique()
+
+
+	let uniquePublicKeyCounter = 1;
 	/**
 	 * A public key
 	 */
 
-
 	class PublicKey extends Struct$1 {
 	  /** @internal */
 
@@ -8346,6 +8348,16 @@ var solanaWeb3 = (function (exports) {
 	      }
 	    }
 	  }
+	  /**
+	   * Returns a unique PublicKey for tests and benchmarks using acounter
+	   */
+
+
+	  static unique() {
+	    const key = new PublicKey(uniquePublicKeyCounter);
+	    uniquePublicKeyCounter += 1;
+	    return new PublicKey(key.toBuffer());
+	  }
 	  /**
 	   * Default public key value. (All zeros)
 	   */
@@ -10885,6 +10897,71 @@ var solanaWeb3 = (function (exports) {
 	  value: 'TransactionExpiredTimeoutError'
 	});
 
+	class MessageAccountKeys {
+	  constructor(staticAccountKeys, accountKeysFromLookups) {
+	    this.staticAccountKeys = void 0;
+	    this.accountKeysFromLookups = void 0;
+	    this.staticAccountKeys = staticAccountKeys;
+	    this.accountKeysFromLookups = accountKeysFromLookups;
+	  }
+
+	  keySegments() {
+	    const keySegments = [this.staticAccountKeys];
+
+	    if (this.accountKeysFromLookups) {
+	      keySegments.push(this.accountKeysFromLookups.writable);
+	      keySegments.push(this.accountKeysFromLookups.readonly);
+	    }
+
+	    return keySegments;
+	  }
+
+	  get(index) {
+	    for (const keySegment of this.keySegments()) {
+	      if (index < keySegment.length) {
+	        return keySegment[index];
+	      } else {
+	        index -= keySegment.length;
+	      }
+	    }
+
+	    return;
+	  }
+
+	  get length() {
+	    return this.keySegments().flat().length;
+	  }
+
+	  compileInstructions(instructions) {
+	    // Bail early if any account indexes would overflow a u8
+	    const U8_MAX = 255;
+
+	    if (this.length > U8_MAX + 1) {
+	      throw new Error('Account index overflow encountered during compilation');
+	    }
+
+	    const keyIndexMap = new Map();
+	    this.keySegments().flat().forEach((key, index) => {
+	      keyIndexMap.set(key.toBase58(), index);
+	    });
+
+	    const findKeyIndex = key => {
+	      const keyIndex = keyIndexMap.get(key.toBase58());
+	      if (keyIndex === undefined) throw new Error('Encountered an unknown instruction account key during compilation');
+	      return keyIndex;
+	    };
+
+	    return instructions.map(instruction => {
+	      return {
+	        programIdIndex: findKeyIndex(instruction.programId),
+	        accountKeyIndexes: instruction.keys.map(meta => findKeyIndex(meta.pubkey)),
+	        data: instruction.data
+	      };
+	    });
+	  }
+
+	}
+
 	/**
 	 * Layout for a public key
 	 */
@@ -11010,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
 	 */
@@ -11047,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;
 	  }
@@ -11136,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);
@@ -11175,12 +11396,6 @@ var solanaWeb3 = (function (exports) {
 
 	}
 
-	function assert$1 (condition, message) {
-	  if (!condition) {
-	    throw new Error(message || 'Assertion failed');
-	  }
-	}
-
 	/**
 	 * Message constructor arguments
 	 */
@@ -11203,6 +11418,102 @@ var solanaWeb3 = (function (exports) {
 	    return 0;
 	  }
 
+	  get numAccountKeysFromLookups() {
+	    let count = 0;
+
+	    for (const lookup of this.addressTableLookups) {
+	      count += lookup.readonlyIndexes.length + lookup.writableIndexes.length;
+	    }
+
+	    return count;
+	  }
+
+	  getAccountKeys(args) {
+	    let accountKeysFromLookups;
+
+	    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');
+	      }
+
+	      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 new MessageAccountKeys(this.staticAccountKeys, accountKeysFromLookups);
+	  }
+
+	  resolveAddressTableLookups(addressLookupTableAccounts) {
+	    const accountKeysFromLookups = {
+	      writable: [],
+	      readonly: []
+	    };
+
+	    for (const tableLookup of this.addressTableLookups) {
+	      const tableAccount = addressLookupTableAccounts.find(account => account.key.equals(tableLookup.accountKey));
+
+	      if (!tableAccount) {
+	        throw new Error(`Failed to find address lookup table account for table key ${tableLookup.accountKey.toBase58()}`);
+	      }
+
+	      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()}`);
+	        }
+	      }
+
+	      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()}`);
+	        }
+	      }
+	    }
+
+	    return accountKeysFromLookups;
+	  }
+
+	  static compile(args) {
+	    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
+	    const addressTableLookups = new Array();
+	    const accountKeysFromLookups = {
+	      writable: new Array(),
+	      readonly: new Array()
+	    };
+	    const lookupTableAccounts = args.addressLookupTableAccounts || [];
+
+	    for (const lookupTable of lookupTableAccounts) {
+	      const extractResult = compiledKeys.extractTableLookup(lookupTable);
+
+	      if (extractResult !== undefined) {
+	        const [addressTableLookup, {
+	          writable,
+	          readonly
+	        }] = extractResult;
+	        addressTableLookups.push(addressTableLookup);
+	        accountKeysFromLookups.writable.push(...writable);
+	        accountKeysFromLookups.readonly.push(...readonly);
+	      }
+	    }
+
+	    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+	    const accountKeys = new MessageAccountKeys(staticAccountKeys, accountKeysFromLookups);
+	    const compiledInstructions = accountKeys.compileInstructions(args.instructions);
+	    return new MessageV0({
+	      header,
+	      staticAccountKeys,
+	      recentBlockhash: args.recentBlockhash,
+	      compiledInstructions,
+	      addressTableLookups
+	    });
+	  }
+
 	  serialize() {
 	    const encodedStaticAccountKeysLength = Array();
 	    encodeLength(encodedStaticAccountKeysLength, this.staticAccountKeys.length);
@@ -12097,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
 	 */
@@ -17526,7 +17945,8 @@ var solanaWeb3 = (function (exports) {
 	  logMessages: optional(nullable(array(string()))),
 	  preTokenBalances: optional(nullable(array(TokenBalanceResult))),
 	  postTokenBalances: optional(nullable(array(TokenBalanceResult))),
-	  loadedAddresses: optional(LoadedAddressesResult)
+	  loadedAddresses: optional(LoadedAddressesResult),
+	  computeUnitsConsumed: optional(number())
 	});
 	/**
 	 * @internal
@@ -17544,7 +17964,8 @@ var solanaWeb3 = (function (exports) {
 	  logMessages: optional(nullable(array(string()))),
 	  preTokenBalances: optional(nullable(array(TokenBalanceResult))),
 	  postTokenBalances: optional(nullable(array(TokenBalanceResult))),
-	  loadedAddresses: optional(LoadedAddressesResult)
+	  loadedAddresses: optional(LoadedAddressesResult),
+	  computeUnitsConsumed: optional(number())
 	});
 	const TransactionVersionStruct = union([literal(0), literal('legacy')]);
 	/**
@@ -19563,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) {
@@ -19582,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 {
@@ -19662,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 {
@@ -24390,6 +24873,7 @@ var solanaWeb3 = (function (exports) {
 	exports.Lockup = Lockup;
 	exports.MAX_SEED_LENGTH = MAX_SEED_LENGTH;
 	exports.Message = Message;
+	exports.MessageAccountKeys = MessageAccountKeys;
 	exports.MessageV0 = MessageV0;
 	exports.NONCE_ACCOUNT_LENGTH = NONCE_ACCOUNT_LENGTH;
 	exports.NonceAccount = NonceAccount;
@@ -24424,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;