@solana/web3.js 1.56.1 → 1.58.0

package/lib/index.cjs.js

@@ -149,12 +149,14 @@ const PUBLIC_KEY_LENGTH = 32;
 
 function isPublicKeyData(value) {
   return value._bn !== undefined;
-}
+} // local counter used by PublicKey.unique()
+
+
+let uniquePublicKeyCounter = 1;
 /**
  * A public key
  */
 
-
 class PublicKey extends Struct {
   /** @internal */
 
@@ -187,6 +189,16 @@ class PublicKey extends Struct {
       }
     }
   }
+  /**
+   * 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)
    */
@@ -443,6 +455,71 @@ Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
   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
  */
@@ -568,6 +645,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
  */
@@ -605,6 +805,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;
   }
@@ -694,7 +915,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);
@@ -733,12 +954,6 @@ class Message {
 
 }
 
-function assert (condition, message) {
-  if (!condition) {
-    throw new Error(message || 'Assertion failed');
-  }
-}
-
 /**
  * Message constructor arguments
  */
@@ -761,6 +976,102 @@ class MessageV0 {
     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);
@@ -1655,6 +1966,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
  */
@@ -3979,7 +4398,8 @@ const ConfirmedTransactionMetaResult = superstruct.type({
   logMessages: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.string()))),
   preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
-  loadedAddresses: superstruct.optional(LoadedAddressesResult)
+  loadedAddresses: superstruct.optional(LoadedAddressesResult),
+  computeUnitsConsumed: superstruct.optional(superstruct.number())
 });
 /**
  * @internal
@@ -3997,7 +4417,8 @@ const ParsedConfirmedTransactionMetaResult = superstruct.type({
   logMessages: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.string()))),
   preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
-  loadedAddresses: superstruct.optional(LoadedAddressesResult)
+  loadedAddresses: superstruct.optional(LoadedAddressesResult),
+  computeUnitsConsumed: superstruct.optional(superstruct.number())
 });
 const TransactionVersionStruct = superstruct.union([superstruct.literal(0), superstruct.literal('legacy')]);
 /**
@@ -6016,10 +6437,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) {
@@ -6035,6 +6490,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 {
@@ -6115,12 +6576,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 {
@@ -9171,6 +9654,7 @@ exports.Loader = Loader;
 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;
@@ -9205,6 +9689,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;