@solana/web3.js 1.56.2 → 1.57.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
 	 */
@@ -11181,6 +11258,115 @@ var solanaWeb3 = (function (exports) {
 	  }
 	}
 
+	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];
+	  }
+
+	}
+
 	/**
 	 * Message constructor arguments
 	 */
@@ -11203,6 +11389,41 @@ var solanaWeb3 = (function (exports) {
 	    return 0;
 	  }
 
+	  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);
@@ -24392,6 +24613,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;