@solana/web3.js 1.58.0 → 1.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/web3.js",
-  "version": "1.58.0",
+  "version": "1.60.0",
   "description": "Solana Javascript API",
   "keywords": [
     "api",
@@ -69,7 +69,6 @@
     "buffer": "6.0.1",
     "fast-stable-stringify": "^1.0.0",
     "jayson": "^3.4.4",
-    "js-sha3": "^0.8.0",
     "node-fetch": "2",
     "rpc-websockets": "^7.5.0",
     "superstruct": "^0.14.2"

package/src/connection.ts

@@ -1029,6 +1029,8 @@ export type ParsedMessageAccount = {
   signer: boolean;
   /** Indicates if the account is writable for this transaction */
   writable: boolean;
+  /** Indicates if the account key came from the transaction or a lookup table */
+  source?: 'transaction' | 'lookupTable';
 };
 
 /**
@@ -1966,6 +1968,9 @@ const ParsedConfirmedTransactionResult = pick({
         pubkey: PublicKeyFromString,
         signer: boolean(),
         writable: boolean(),
+        source: optional(
+          union([literal('transaction'), literal('lookupTable')]),
+        ),
       }),
     ),
     instructions: array(ParsedOrRawInstruction),

package/src/keypair.ts

@@ -88,6 +88,6 @@ export class Keypair {
    * The raw secret key for this keypair
    */
   get secretKey(): Uint8Array {
-    return this._keypair.secretKey;
+    return new Uint8Array(this._keypair.secretKey);
   }
 }

package/src/layout.ts

@@ -1,6 +1,8 @@
 import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 
+import {VoteAuthorizeWithSeedArgs} from './programs/vote';
+
 /**
  * Layout for a public key
  */
@@ -141,6 +143,23 @@ export const voteInit = (property: string = 'voteInit') => {
   );
 };
 
+/**
+ *  Layout for a VoteAuthorizeWithSeedArgs object
+ */
+export const voteAuthorizeWithSeedArgs = (
+  property: string = 'voteAuthorizeWithSeedArgs',
+) => {
+  return BufferLayout.struct<VoteAuthorizeWithSeedArgs>(
+    [
+      BufferLayout.u32('voteAuthorizationType'),
+      publicKey('currentAuthorityDerivedKeyOwnerPubkey'),
+      rustString('currentAuthorityDerivedKeySeed'),
+      publicKey('newAuthorized'),
+    ],
+    property,
+  );
+};
+
 export function getAlloc(type: any, fields: any): number {
   const getItemAlloc = (item: any): number => {
     if (item.span >= 0) {
@@ -152,6 +171,9 @@ export function getAlloc(type: any, fields: any): number {
       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
     return 0;

package/src/programs/secp256k1.ts

@@ -1,6 +1,6 @@
 import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
-import sha3 from 'js-sha3';
+import {keccak_256} from '@noble/hashes/sha3';
 
 import {PublicKey} from '../publickey';
 import {TransactionInstruction} from '../transaction';
@@ -98,9 +98,9 @@ export class Secp256k1Program {
     );
 
     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}`);
     }
@@ -211,9 +211,7 @@ export class Secp256k1Program {
         privateKey,
         false /* 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({

package/src/programs/vote.ts

@@ -65,6 +65,18 @@ export type AuthorizeVoteParams = {
   voteAuthorizationType: VoteAuthorizationType;
 };
 
+/**
+ * AuthorizeWithSeed instruction params
+ */
+export type AuthorizeVoteWithSeedParams = {
+  currentAuthorityDerivedKeyBasePubkey: PublicKey;
+  currentAuthorityDerivedKeyOwnerPubkey: PublicKey;
+  currentAuthorityDerivedKeySeed: string;
+  newAuthorizedPubkey: PublicKey;
+  voteAuthorizationType: VoteAuthorizationType;
+  votePubkey: PublicKey;
+};
+
 /**
  * Withdraw from vote account transaction params
  */
@@ -160,6 +172,41 @@ export class VoteInstruction {
     };
   }
 
+  /**
+   * Decode an authorize instruction and retrieve the instruction params.
+   */
+  static decodeAuthorizeWithSeed(
+    instruction: TransactionInstruction,
+  ): AuthorizeVoteWithSeedParams {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+
+    const {
+      voteAuthorizeWithSeedArgs: {
+        currentAuthorityDerivedKeyOwnerPubkey,
+        currentAuthorityDerivedKeySeed,
+        newAuthorized,
+        voteAuthorizationType,
+      },
+    } = decodeData(
+      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.
    */
@@ -211,13 +258,23 @@ export type VoteInstructionType =
   // It would be preferable for this type to be `keyof VoteInstructionInputData`
   // but Typedoc does not transpile `keyof` expressions.
   // See https://github.com/TypeStrong/typedoc/issues/1894
-  'Authorize' | 'InitializeAccount' | 'Withdraw';
-
+  'Authorize' | 'AuthorizeWithSeed' | 'InitializeAccount' | 'Withdraw';
+
+/** @internal */
+export type VoteAuthorizeWithSeedArgs = Readonly<{
+  currentAuthorityDerivedKeyOwnerPubkey: Uint8Array;
+  currentAuthorityDerivedKeySeed: string;
+  newAuthorized: Uint8Array;
+  voteAuthorizationType: number;
+}>;
 type VoteInstructionInputData = {
   Authorize: IInstructionInputData & {
     newAuthorized: Uint8Array;
     voteAuthorizationType: number;
   };
+  AuthorizeWithSeed: IInstructionInputData & {
+    voteAuthorizeWithSeedArgs: VoteAuthorizeWithSeedArgs;
+  };
   InitializeAccount: IInstructionInputData & {
     voteInit: Readonly<{
       authorizedVoter: Uint8Array;
@@ -258,6 +315,13 @@ const VOTE_INSTRUCTION_LAYOUTS = Object.freeze<{
       BufferLayout.ns64('lamports'),
     ]),
   },
+  AuthorizeWithSeed: {
+    index: 10,
+    layout: BufferLayout.struct<VoteInstructionInputData['AuthorizeWithSeed']>([
+      BufferLayout.u32('instruction'),
+      Layout.voteAuthorizeWithSeedArgs(),
+    ]),
+  },
 });
 
 /**
@@ -390,6 +454,49 @@ export class VoteProgram {
     });
   }
 
+  /**
+   * 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: AuthorizeVoteWithSeedParams): Transaction {
+    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.
    */

package/src/transaction/message.ts

@@ -1,16 +1,14 @@
-import {
-  AccountKeysFromLookups,
-  MessageAccountKeys,
-} from '../message/account-keys';
+import {AccountKeysFromLookups} from '../message/account-keys';
 import assert from '../utils/assert';
 import {toBuffer} from '../utils/to-buffer';
 import {Blockhash} from '../blockhash';
 import {Message, MessageV0, VersionedMessage} from '../message';
+import {PublicKey} from '../publickey';
 import {AddressLookupTableAccount} from '../programs';
 import {AccountMeta, TransactionInstruction} from './legacy';
 
 export type TransactionMessageArgs = {
-  accountKeys: MessageAccountKeys;
+  payerKey: PublicKey;
   instructions: Array<TransactionInstruction>;
   recentBlockhash: Blockhash;
 };
@@ -24,12 +22,12 @@ export type DecompileArgs =
     };
 
 export class TransactionMessage {
-  accountKeys: MessageAccountKeys;
+  payerKey: PublicKey;
   instructions: Array<TransactionInstruction>;
   recentBlockhash: Blockhash;
 
   constructor(args: TransactionMessageArgs) {
-    this.accountKeys = args.accountKeys;
+    this.payerKey = args.payerKey;
     this.instructions = args.instructions;
     this.recentBlockhash = args.recentBlockhash;
   }
@@ -55,6 +53,13 @@ export class TransactionMessage {
     assert(numWritableUnsignedAccounts >= 0, 'Message header is invalid');
 
     const accountKeys = message.getAccountKeys(args);
+    const payerKey = accountKeys.get(0);
+    if (payerKey === undefined) {
+      throw new Error(
+        'Failed to decompile message because no account keys were found',
+      );
+    }
+
     const instructions: TransactionInstruction[] = [];
     for (const compiledIx of compiledInstructions) {
       const keys: AccountMeta[] = [];
@@ -106,22 +111,15 @@ export class TransactionMessage {
     }
 
     return new TransactionMessage({
-      accountKeys,
+      payerKey,
       instructions,
       recentBlockhash,
     });
   }
 
   compileToLegacyMessage(): Message {
-    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,
+      payerKey: this.payerKey,
       recentBlockhash: this.recentBlockhash,
       instructions: this.instructions,
     });
@@ -130,15 +128,8 @@ export class TransactionMessage {
   compileToV0Message(
     addressLookupTableAccounts?: AddressLookupTableAccount[],
   ): MessageV0 {
-    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,
+      payerKey: this.payerKey,
       recentBlockhash: this.recentBlockhash,
       instructions: this.instructions,
       addressLookupTableAccounts,