@solana/web3.js 1.56.2 → 1.59.0

package/lib/index.browser.esm.js

@@ -11,7 +11,7 @@ import { toBigIntLE, toBufferLE } from 'bigint-buffer';
 import { coerce, instance, string, tuple, literal, unknown, union, type, optional, any, number, array, nullable, create, boolean, record, assert as assert$1 } from 'superstruct';
 import { Client } from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
-import sha3 from 'js-sha3';
+import { keccak_256 } from '@noble/hashes/sha3';
 import { hmac } from '@noble/hashes/hmac';
 import * as secp256k1 from '@noble/secp256k1';
 
@@ -112,12 +112,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 */
 
@@ -150,6 +152,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)
    */
@@ -406,10 +418,74 @@ 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
  */
-
 const publicKey = (property = 'publicKey') => {
   return BufferLayout.blob(32, property);
 };
@@ -473,6 +549,13 @@ const lockup = (property = 'lockup') => {
 const voteInit = (property = 'voteInit') => {
   return BufferLayout.struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), BufferLayout.u8('commission')], property);
 };
+/**
+ *  Layout for a VoteAuthorizeWithSeedArgs object
+ */
+
+const voteAuthorizeWithSeedArgs = (property = 'voteAuthorizeWithSeedArgs') => {
+  return BufferLayout.struct([BufferLayout.u32('voteAuthorizationType'), publicKey('currentAuthorityDerivedKeyOwnerPubkey'), rustString('currentAuthorityDerivedKeySeed'), publicKey('newAuthorized')], property);
+};
 function getAlloc(type, fields) {
   const getItemAlloc = item => {
     if (item.span >= 0) {
@@ -485,6 +568,11 @@ function getAlloc(type, fields) {
       if (Array.isArray(field)) {
         return field.length * getItemAlloc(item.elementLayout);
       }
+    } else if ('fields' in item) {
+      // This is a `Structure` whose size needs to be recursively measured.
+      return getAlloc({
+        layout: item
+      }, fields[item.property]);
     } // Couldn't determine allocated size of layout
 
 
@@ -531,6 +619,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
  */
@@ -568,6 +779,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.encode(ix.data)
+    }));
+    return new Message({
+      header,
+      accountKeys: staticAccountKeys,
+      recentBlockhash: args.recentBlockhash,
+      instructions
+    });
+  }
+
   isAccountSigner(index) {
     return index < this.header.numRequiredSignatures;
   }
@@ -657,7 +889,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.encode(Buffer.from(account)));
+      accountKeys.push(new PublicKey(Buffer.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
@@ -696,12 +928,6 @@ class Message {
 
 }
 
-function assert (condition, message) {
-  if (!condition) {
-    throw new Error(message || 'Assertion failed');
-  }
-}
-
 /**
  * Message constructor arguments
  */
@@ -724,6 +950,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);
@@ -1618,6 +1940,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
  */
@@ -5921,10 +6351,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.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) {
@@ -5940,6 +6404,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 {
@@ -6022,10 +6492,32 @@ class Connection {
   }
   /**
    * Sign and send a transaction
+   *
+   * @deprecated Instead, call {@link sendTransaction} with a {@link
+   * VersionedTransaction}
    */
 
 
-  async sendTransaction(transaction, signers, options) {
+  /**
+   * 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;
+
     if (transaction.nonceInfo) {
       transaction.sign(...signers);
     } else {
@@ -7552,7 +8044,7 @@ class Secp256k1Program {
     assert(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
 
     try {
-      return Buffer.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
+      return Buffer.from(keccak_256(toBuffer(publicKey))).slice(-ETHEREUM_ADDRESS_BYTES);
     } catch (error) {
       throw new Error(`Error constructing Ethereum address: ${error}`);
     }
@@ -7652,7 +8144,7 @@ class Secp256k1Program {
       /* isCompressed */
       ).slice(1); // throw away leading byte
 
-      const messageHash = Buffer.from(sha3.keccak_256.update(toBuffer(message)).digest());
+      const messageHash = Buffer.from(keccak_256(toBuffer(message)));
       const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);
       return this.createInstructionWithPublicKey({
         publicKey,
@@ -8546,6 +9038,33 @@ class VoteInstruction {
       }
     };
   }
+  /**
+   * Decode an authorize instruction and retrieve the instruction params.
+   */
+
+
+  static decodeAuthorizeWithSeed(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+    const {
+      voteAuthorizeWithSeedArgs: {
+        currentAuthorityDerivedKeyOwnerPubkey,
+        currentAuthorityDerivedKeySeed,
+        newAuthorized,
+        voteAuthorizationType
+      }
+    } = decodeData$1(VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed, instruction.data);
+    return {
+      currentAuthorityDerivedKeyBasePubkey: instruction.keys[2].pubkey,
+      currentAuthorityDerivedKeyOwnerPubkey: new PublicKey(currentAuthorityDerivedKeyOwnerPubkey),
+      currentAuthorityDerivedKeySeed: currentAuthorityDerivedKeySeed,
+      newAuthorizedPubkey: new PublicKey(newAuthorized),
+      voteAuthorizationType: {
+        index: voteAuthorizationType
+      },
+      votePubkey: instruction.keys[0].pubkey
+    };
+  }
   /**
    * Decode a withdraw instruction and retrieve the instruction params.
    */
@@ -8602,6 +9121,10 @@ const VOTE_INSTRUCTION_LAYOUTS = Object.freeze({
   Withdraw: {
     index: 3,
     layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+  },
+  AuthorizeWithSeed: {
+    index: 10,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), voteAuthorizeWithSeedArgs()])
   }
 });
 /**
@@ -8730,6 +9253,49 @@ class VoteProgram {
       data
     });
   }
+  /**
+   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account
+   * where the current Voter or Withdrawer authority is a derived key.
+   */
+
+
+  static authorizeWithSeed(params) {
+    const {
+      currentAuthorityDerivedKeyBasePubkey,
+      currentAuthorityDerivedKeyOwnerPubkey,
+      currentAuthorityDerivedKeySeed,
+      newAuthorizedPubkey,
+      voteAuthorizationType,
+      votePubkey
+    } = params;
+    const type = VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;
+    const data = encodeData(type, {
+      voteAuthorizeWithSeedArgs: {
+        currentAuthorityDerivedKeyOwnerPubkey: toBuffer(currentAuthorityDerivedKeyOwnerPubkey.toBuffer()),
+        currentAuthorityDerivedKeySeed: currentAuthorityDerivedKeySeed,
+        newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
+        voteAuthorizationType: voteAuthorizationType.index
+      }
+    });
+    const keys = [{
+      pubkey: votePubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: SYSVAR_CLOCK_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    }, {
+      pubkey: currentAuthorityDerivedKeyBasePubkey,
+      isSigner: true,
+      isWritable: false
+    }];
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
+  }
   /**
    * Generate a transaction to withdraw from a Vote account.
    */
@@ -9052,5 +9618,5 @@ async function sendAndConfirmRawTransaction(connection, rawTransaction, confirma
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, AddressLookupTableAccount, AddressLookupTableInstruction, AddressLookupTableProgram, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, LOOKUP_TABLE_INSTRUCTION_LAYOUTS, Loader, Lockup, MAX_SEED_LENGTH, Message, MessageV0, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PUBLIC_KEY_LENGTH, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, SolanaJSONRPCError, SolanaJSONRPCErrorCode, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionExpiredBlockheightExceededError, TransactionExpiredTimeoutError, TransactionInstruction, TransactionStatus, VALIDATOR_INFO_KEY, VERSION_PREFIX_MASK, VOTE_PROGRAM_ID, ValidatorInfo, VersionedMessage, VersionedTransaction, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, AddressLookupTableAccount, AddressLookupTableInstruction, AddressLookupTableProgram, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, LOOKUP_TABLE_INSTRUCTION_LAYOUTS, Loader, Lockup, MAX_SEED_LENGTH, Message, MessageAccountKeys, MessageV0, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PUBLIC_KEY_LENGTH, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, SolanaJSONRPCError, SolanaJSONRPCErrorCode, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionExpiredBlockheightExceededError, TransactionExpiredTimeoutError, TransactionInstruction, TransactionMessage, TransactionStatus, VALIDATOR_INFO_KEY, VERSION_PREFIX_MASK, VOTE_PROGRAM_ID, ValidatorInfo, VersionedMessage, VersionedTransaction, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.browser.esm.js.map