@solana/web3.js 1.31.0 → 1.33.0

package/src/sysvar.ts

@@ -4,6 +4,14 @@ export const SYSVAR_CLOCK_PUBKEY = new PublicKey(
   'SysvarC1ock11111111111111111111111111111111',
 );
 
+export const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey(
+  'SysvarEpochSchedu1e111111111111111111111111',
+);
+
+export const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey(
+  'Sysvar1nstructions1111111111111111111111111',
+);
+
 export const SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new PublicKey(
   'SysvarRecentB1ockHashes11111111111111111111',
 );
@@ -16,10 +24,14 @@ export const SYSVAR_REWARDS_PUBKEY = new PublicKey(
   'SysvarRewards111111111111111111111111111111',
 );
 
-export const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey(
-  'SysvarStakeHistory1111111111111111111111111',
+export const SYSVAR_SLOT_HASHES_PUBKEY = new PublicKey(
+  'SysvarS1otHashes111111111111111111111111111',
 );
 
-export const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey(
-  'Sysvar1nstructions1111111111111111111111111',
+export const SYSVAR_SLOT_HISTORY_PUBKEY = new PublicKey(
+  'SysvarS1otHistory11111111111111111111111111',
+);
+
+export const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey(
+  'SysvarStakeHistory1111111111111111111111111',
 );

package/src/transaction.ts

@@ -259,9 +259,12 @@ export class Transaction {
 
     // Sort. Prioritizing first by signer, then by writable
     accountMetas.sort(function (x, y) {
+      const pubkeySorting = x.pubkey
+        .toBase58()
+        .localeCompare(y.pubkey.toBase58());
       const checkSigner = x.isSigner === y.isSigner ? 0 : x.isSigner ? -1 : 1;
       const checkWritable =
-        x.isWritable === y.isWritable ? 0 : x.isWritable ? -1 : 1;
+        x.isWritable === y.isWritable ? pubkeySorting : x.isWritable ? -1 : 1;
       return checkSigner || checkWritable;
     });
 

package/src/util/cluster.ts

@@ -2,12 +2,12 @@ const endpoint = {
   http: {
     devnet: 'http://api.devnet.solana.com',
     testnet: 'http://api.testnet.solana.com',
-    'mainnet-beta': 'http://api.mainnet-beta.solana.com',
+    'mainnet-beta': 'http://api.mainnet-beta.solana.com/',
   },
   https: {
     devnet: 'https://api.devnet.solana.com',
     testnet: 'https://api.testnet.solana.com',
-    'mainnet-beta': 'https://api.mainnet-beta.solana.com',
+    'mainnet-beta': 'https://api.mainnet-beta.solana.com/',
   },
 };
 

package/src/util/send-and-confirm-transaction.ts

@@ -24,6 +24,7 @@ export async function sendAndConfirmTransaction(
   const sendOptions = options && {
     skipPreflight: options.skipPreflight,
     preflightCommitment: options.preflightCommitment || options.commitment,
+    maxRetries: options.maxRetries,
   };
 
   const signature = await connection.sendTransaction(

package/src/vote-account.ts

@@ -23,6 +23,22 @@ export type EpochCredits = {
   prevCredits: number;
 };
 
+export type AuthorizedVoter = {
+  epoch: number;
+  authorizedVoter: PublicKey;
+};
+
+export type PriorVoter = {
+  authorizedPubkey: PublicKey;
+  epochOfLastAuthorizedSwitch: number;
+  targetEpoch: number;
+};
+
+export type BlockTimestamp = {
+  slot: number;
+  timetamp: number;
+};
+
 /**
  * See https://github.com/solana-labs/solana/blob/8a12ed029cfa38d4a45400916c2463fb82bbec8c/programs/vote_api/src/vote_state.rs#L68-L88
  *
@@ -30,8 +46,7 @@ export type EpochCredits = {
  */
 const VoteAccountLayout = BufferLayout.struct([
   Layout.publicKey('nodePubkey'),
-  Layout.publicKey('authorizedVoterPubkey'),
-  Layout.publicKey('authorizedWithdrawerPubkey'),
+  Layout.publicKey('authorizedWithdrawer'),
   BufferLayout.u8('commission'),
   BufferLayout.nu64(), // votes.length
   BufferLayout.seq(
@@ -44,9 +59,31 @@ const VoteAccountLayout = BufferLayout.struct([
   ),
   BufferLayout.u8('rootSlotValid'),
   BufferLayout.nu64('rootSlot'),
-  BufferLayout.nu64('epoch'),
-  BufferLayout.nu64('credits'),
-  BufferLayout.nu64('lastEpochCredits'),
+  BufferLayout.nu64(), // authorizedVoters.length
+  BufferLayout.seq(
+    BufferLayout.struct([
+      BufferLayout.nu64('epoch'),
+      Layout.publicKey('authorizedVoter'),
+    ]),
+    BufferLayout.offset(BufferLayout.u32(), -8),
+    'authorizedVoters',
+  ),
+  BufferLayout.struct(
+    [
+      BufferLayout.seq(
+        BufferLayout.struct([
+          Layout.publicKey('authorizedPubkey'),
+          BufferLayout.nu64('epochOfLastAuthorizedSwitch'),
+          BufferLayout.nu64('targetEpoch'),
+        ]),
+        32,
+        'buf',
+      ),
+      BufferLayout.nu64('idx'),
+      BufferLayout.u8('isEmpty'),
+    ],
+    'priorVoters',
+  ),
   BufferLayout.nu64(), // epochCredits.length
   BufferLayout.seq(
     BufferLayout.struct([
@@ -57,19 +94,22 @@ const VoteAccountLayout = BufferLayout.struct([
     BufferLayout.offset(BufferLayout.u32(), -8),
     'epochCredits',
   ),
+  BufferLayout.struct(
+    [BufferLayout.nu64('slot'), BufferLayout.nu64('timestamp')],
+    'lastTimestamp',
+  ),
 ]);
 
 type VoteAccountArgs = {
   nodePubkey: PublicKey;
-  authorizedVoterPubkey: PublicKey;
-  authorizedWithdrawerPubkey: PublicKey;
+  authorizedWithdrawer: PublicKey;
   commission: number;
-  votes: Array<Lockout>;
   rootSlot: number | null;
-  epoch: number;
-  credits: number;
-  lastEpochCredits: number;
-  epochCredits: Array<EpochCredits>;
+  votes: Lockout[];
+  authorizedVoters: AuthorizedVoter[];
+  priorVoters: PriorVoter[];
+  epochCredits: EpochCredits[];
+  lastTimestamp: BlockTimestamp;
 };
 
 /**
@@ -77,30 +117,28 @@ type VoteAccountArgs = {
  */
 export class VoteAccount {
   nodePubkey: PublicKey;
-  authorizedVoterPubkey: PublicKey;
-  authorizedWithdrawerPubkey: PublicKey;
+  authorizedWithdrawer: PublicKey;
   commission: number;
-  votes: Array<Lockout>;
   rootSlot: number | null;
-  epoch: number;
-  credits: number;
-  lastEpochCredits: number;
-  epochCredits: Array<EpochCredits>;
+  votes: Lockout[];
+  authorizedVoters: AuthorizedVoter[];
+  priorVoters: PriorVoter[];
+  epochCredits: EpochCredits[];
+  lastTimestamp: BlockTimestamp;
 
   /**
    * @internal
    */
   constructor(args: VoteAccountArgs) {
     this.nodePubkey = args.nodePubkey;
-    this.authorizedVoterPubkey = args.authorizedVoterPubkey;
-    this.authorizedWithdrawerPubkey = args.authorizedWithdrawerPubkey;
+    this.authorizedWithdrawer = args.authorizedWithdrawer;
     this.commission = args.commission;
-    this.votes = args.votes;
     this.rootSlot = args.rootSlot;
-    this.epoch = args.epoch;
-    this.credits = args.credits;
-    this.lastEpochCredits = args.lastEpochCredits;
+    this.votes = args.votes;
+    this.authorizedVoters = args.authorizedVoters;
+    this.priorVoters = args.priorVoters;
     this.epochCredits = args.epochCredits;
+    this.lastTimestamp = args.lastTimestamp;
   }
 
   /**
@@ -112,7 +150,8 @@ export class VoteAccount {
   static fromAccountData(
     buffer: Buffer | Uint8Array | Array<number>,
   ): VoteAccount {
-    const va = VoteAccountLayout.decode(toBuffer(buffer), 0);
+    const versionOffset = 4;
+    const va = VoteAccountLayout.decode(toBuffer(buffer), versionOffset);
 
     let rootSlot: number | null = va.rootSlot;
     if (!va.rootSlotValid) {
@@ -121,15 +160,49 @@ export class VoteAccount {
 
     return new VoteAccount({
       nodePubkey: new PublicKey(va.nodePubkey),
-      authorizedVoterPubkey: new PublicKey(va.authorizedVoterPubkey),
-      authorizedWithdrawerPubkey: new PublicKey(va.authorizedWithdrawerPubkey),
+      authorizedWithdrawer: new PublicKey(va.authorizedWithdrawer),
       commission: va.commission,
       votes: va.votes,
       rootSlot,
-      epoch: va.epoch,
-      credits: va.credits,
-      lastEpochCredits: va.lastEpochCredits,
+      authorizedVoters: va.authorizedVoters.map(parseAuthorizedVoter),
+      priorVoters: getPriorVoters(va.priorVoters),
       epochCredits: va.epochCredits,
+      lastTimestamp: va.lastTimestamp,
     });
   }
 }
+
+function parseAuthorizedVoter({epoch, authorizedVoter}: AuthorizedVoter) {
+  return {
+    epoch,
+    authorizedVoter: new PublicKey(authorizedVoter),
+  };
+}
+
+function parsePriorVoters({
+  authorizedPubkey,
+  epochOfLastAuthorizedSwitch,
+  targetEpoch,
+}: PriorVoter) {
+  return {
+    authorizedPubkey: new PublicKey(authorizedPubkey),
+    epochOfLastAuthorizedSwitch,
+    targetEpoch,
+  };
+}
+
+function getPriorVoters({
+  buf,
+  idx,
+  isEmpty,
+}: {
+  buf: PriorVoter[];
+  idx: number;
+  isEmpty: boolean;
+}): PriorVoter[] {
+  if (isEmpty) {
+    return [];
+  }
+
+  return [...buf.slice(idx + 1).map(parsePriorVoters), ...buf.slice(0, idx)];
+}

package/src/vote-program.ts

@@ -0,0 +1,290 @@
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {encodeData, decodeData, InstructionType} from './instruction';
+import * as Layout from './layout';
+import {PublicKey} from './publickey';
+import {SystemProgram} from './system-program';
+import {SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY} from './sysvar';
+import {Transaction, TransactionInstruction} from './transaction';
+import {toBuffer} from './util/to-buffer';
+
+/**
+ * Vote account info
+ */
+export class VoteInit {
+  nodePubkey: PublicKey;
+  authorizedVoter: PublicKey;
+  authorizedWithdrawer: PublicKey;
+  commission: number; /** [0, 100] */
+
+  constructor(
+    nodePubkey: PublicKey,
+    authorizedVoter: PublicKey,
+    authorizedWithdrawer: PublicKey,
+    commission: number,
+  ) {
+    this.nodePubkey = nodePubkey;
+    this.authorizedVoter = authorizedVoter;
+    this.authorizedWithdrawer = authorizedWithdrawer;
+    this.commission = commission;
+  }
+}
+
+/**
+ * Create vote account transaction params
+ */
+export type CreateVoteAccountParams = {
+  fromPubkey: PublicKey;
+  votePubkey: PublicKey;
+  voteInit: VoteInit;
+  lamports: number;
+};
+
+/**
+ * InitializeAccount instruction params
+ */
+export type InitializeAccountParams = {
+  votePubkey: PublicKey;
+  nodePubkey: PublicKey;
+  voteInit: VoteInit;
+};
+
+/**
+ * Withdraw from vote account transaction params
+ */
+export type WithdrawFromVoteAccountParams = {
+  votePubkey: PublicKey;
+  authorizedWithdrawerPubkey: PublicKey;
+  lamports: number;
+  toPubkey: PublicKey;
+};
+
+/**
+ * Vote Instruction class
+ */
+export class VoteInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Decode a vote instruction and retrieve the instruction type.
+   */
+  static decodeInstructionType(
+    instruction: TransactionInstruction,
+  ): VoteInstructionType {
+    this.checkProgramId(instruction.programId);
+
+    const instructionTypeLayout = BufferLayout.u32('instruction');
+    const typeIndex = instructionTypeLayout.decode(instruction.data);
+
+    let type: VoteInstructionType | undefined;
+    for (const [ixType, layout] of Object.entries(VOTE_INSTRUCTION_LAYOUTS)) {
+      if (layout.index == typeIndex) {
+        type = ixType as VoteInstructionType;
+        break;
+      }
+    }
+
+    if (!type) {
+      throw new Error('Instruction type incorrect; not a VoteInstruction');
+    }
+
+    return type;
+  }
+
+  /**
+   * Decode an initialize vote instruction and retrieve the instruction params.
+   */
+  static decodeInitializeAccount(
+    instruction: TransactionInstruction,
+  ): InitializeAccountParams {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 4);
+
+    const {voteInit} = decodeData(
+      VOTE_INSTRUCTION_LAYOUTS.InitializeAccount,
+      instruction.data,
+    );
+
+    return {
+      votePubkey: instruction.keys[0].pubkey,
+      nodePubkey: instruction.keys[3].pubkey,
+      voteInit: new VoteInit(
+        new PublicKey(voteInit.nodePubkey),
+        new PublicKey(voteInit.authorizedVoter),
+        new PublicKey(voteInit.authorizedWithdrawer),
+        voteInit.commission,
+      ),
+    };
+  }
+
+  /**
+   * Decode a withdraw instruction and retrieve the instruction params.
+   */
+  static decodeWithdraw(
+    instruction: TransactionInstruction,
+  ): WithdrawFromVoteAccountParams {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+
+    const {lamports} = decodeData(
+      VOTE_INSTRUCTION_LAYOUTS.Withdraw,
+      instruction.data,
+    );
+
+    return {
+      votePubkey: instruction.keys[0].pubkey,
+      authorizedWithdrawerPubkey: instruction.keys[2].pubkey,
+      lamports,
+      toPubkey: instruction.keys[1].pubkey,
+    };
+  }
+
+  /**
+   * @internal
+   */
+  static checkProgramId(programId: PublicKey) {
+    if (!programId.equals(VoteProgram.programId)) {
+      throw new Error('invalid instruction; programId is not VoteProgram');
+    }
+  }
+
+  /**
+   * @internal
+   */
+  static checkKeyLength(keys: Array<any>, expectedLength: number) {
+    if (keys.length < expectedLength) {
+      throw new Error(
+        `invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`,
+      );
+    }
+  }
+}
+
+/**
+ * An enumeration of valid VoteInstructionType's
+ */
+export type VoteInstructionType = 'InitializeAccount' | 'Withdraw';
+
+const VOTE_INSTRUCTION_LAYOUTS: {
+  [type in VoteInstructionType]: InstructionType;
+} = Object.freeze({
+  InitializeAccount: {
+    index: 0,
+    layout: BufferLayout.struct([
+      BufferLayout.u32('instruction'),
+      Layout.voteInit(),
+    ]),
+  },
+  Withdraw: {
+    index: 3,
+    layout: BufferLayout.struct([
+      BufferLayout.u32('instruction'),
+      BufferLayout.ns64('lamports'),
+    ]),
+  },
+});
+
+/**
+ * Factory class for transactions to interact with the Vote program
+ */
+export class VoteProgram {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Public key that identifies the Vote program
+   */
+  static programId: PublicKey = new PublicKey(
+    'Vote111111111111111111111111111111111111111',
+  );
+
+  /**
+   * Max space of a Vote account
+   *
+   * This is generated from the solana-vote-program VoteState struct as
+   * `VoteState::size_of()`:
+   * https://docs.rs/solana-vote-program/1.9.5/solana_vote_program/vote_state/struct.VoteState.html#method.size_of
+   */
+  static space: number = 3731;
+
+  /**
+   * Generate an Initialize instruction.
+   */
+  static initializeAccount(
+    params: InitializeAccountParams,
+  ): TransactionInstruction {
+    const {votePubkey, nodePubkey, voteInit} = params;
+    const type = VOTE_INSTRUCTION_LAYOUTS.InitializeAccount;
+    const data = encodeData(type, {
+      voteInit: {
+        nodePubkey: toBuffer(voteInit.nodePubkey.toBuffer()),
+        authorizedVoter: toBuffer(voteInit.authorizedVoter.toBuffer()),
+        authorizedWithdrawer: toBuffer(
+          voteInit.authorizedWithdrawer.toBuffer(),
+        ),
+        commission: voteInit.commission,
+      },
+    });
+    const instructionData = {
+      keys: [
+        {pubkey: votePubkey, isSigner: false, isWritable: true},
+        {pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
+        {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false},
+        {pubkey: nodePubkey, isSigner: true, isWritable: false},
+      ],
+      programId: this.programId,
+      data,
+    };
+    return new TransactionInstruction(instructionData);
+  }
+
+  /**
+   * Generate a transaction that creates a new Vote account.
+   */
+  static createAccount(params: CreateVoteAccountParams): Transaction {
+    const transaction = new Transaction();
+    transaction.add(
+      SystemProgram.createAccount({
+        fromPubkey: params.fromPubkey,
+        newAccountPubkey: params.votePubkey,
+        lamports: params.lamports,
+        space: this.space,
+        programId: this.programId,
+      }),
+    );
+
+    return transaction.add(
+      this.initializeAccount({
+        votePubkey: params.votePubkey,
+        nodePubkey: params.voteInit.nodePubkey,
+        voteInit: params.voteInit,
+      }),
+    );
+  }
+
+  /**
+   * Generate a transaction to withdraw from a Vote account.
+   */
+  static withdraw(params: WithdrawFromVoteAccountParams): Transaction {
+    const {votePubkey, authorizedWithdrawerPubkey, lamports, toPubkey} = params;
+    const type = VOTE_INSTRUCTION_LAYOUTS.Withdraw;
+    const data = encodeData(type, {lamports});
+
+    const keys = [
+      {pubkey: votePubkey, isSigner: false, isWritable: true},
+      {pubkey: toPubkey, isSigner: false, isWritable: true},
+      {pubkey: authorizedWithdrawerPubkey, isSigner: true, isWritable: false},
+    ];
+
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data,
+    });
+  }
+}