@solana/web3.js 1.57.0 → 1.58.0

package/lib/index.native.js

@@ -639,6 +639,129 @@ function encodeLength(bytes, len) {
   }
 }
 
+function assert (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(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(writableSigners.length > 0, 'Expected at least one writable signer key');
+      const [payerAddress] = writableSigners[0];
+      assert(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(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
  */
@@ -676,6 +799,27 @@ class Message {
     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__default["default"].encode(ix.data)
+    }));
+    return new Message({
+      header,
+      accountKeys: staticAccountKeys,
+      recentBlockhash: args.recentBlockhash,
+      instructions
+    });
+  }
+
   isAccountSigner(index) {
     return index < this.header.numRequiredSignatures;
   }
@@ -765,7 +909,7 @@ class Message {
     for (let i = 0; i < accountCount; i++) {
       const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
       byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
-      accountKeys.push(bs58__default["default"].encode(buffer.Buffer.from(account)));
+      accountKeys.push(new PublicKey(buffer.Buffer.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
@@ -804,141 +948,87 @@ class Message {
 
 }
 
-function assert (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(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(writableSigners.length > 0, 'Expected at least one writable signer key');
-      const [payerAddress] = writableSigners[0];
-      assert(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(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) {
@@ -1870,6 +1960,114 @@ class Transaction {
 
 }
 
+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(numWritableSignedAccounts > 0, 'Message header is invalid');
+    const numWritableUnsignedAccounts = message.staticAccountKeys.length - numReadonlyUnsignedAccounts;
+    assert(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
  */
@@ -6173,10 +6371,44 @@ class Connection {
   }
   /**
    * 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 = superstruct.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) {
@@ -6192,6 +6424,12 @@ class Connection {
       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 {
@@ -6272,12 +6510,34 @@ class Connection {
 
     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 {
@@ -9363,6 +9623,7 @@ exports.Transaction = Transaction;
 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;