@solana/web3.js 1.32.2 → 1.33.0

package/lib/index.d.ts

@@ -2948,6 +2948,106 @@ declare module '@solana/web3.js' {
     ): VoteAccount;
   }
 
+  /**
+   * 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,
+    );
+  }
+  /**
+   * 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 {
+    /**
+     * Decode a vote instruction and retrieve the instruction type.
+     */
+    static decodeInstructionType(
+      instruction: TransactionInstruction,
+    ): VoteInstructionType;
+    /**
+     * Decode an initialize vote instruction and retrieve the instruction params.
+     */
+    static decodeInitializeAccount(
+      instruction: TransactionInstruction,
+    ): InitializeAccountParams;
+    /**
+     * Decode a withdraw instruction and retrieve the instruction params.
+     */
+    static decodeWithdraw(
+      instruction: TransactionInstruction,
+    ): WithdrawFromVoteAccountParams;
+  }
+  /**
+   * An enumeration of valid VoteInstructionType's
+   */
+  export type VoteInstructionType = 'InitializeAccount' | 'Withdraw';
+  /**
+   * Factory class for transactions to interact with the Vote program
+   */
+  export class VoteProgram {
+    /**
+     * Public key that identifies the Vote program
+     */
+    static programId: PublicKey;
+    /**
+     * 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;
+    /**
+     * Generate an Initialize instruction.
+     */
+    static initializeAccount(
+      params: InitializeAccountParams,
+    ): TransactionInstruction;
+    /**
+     * Generate a transaction that creates a new Vote account.
+     */
+    static createAccount(params: CreateVoteAccountParams): Transaction;
+    /**
+     * Generate a transaction to withdraw from a Vote account.
+     */
+    static withdraw(params: WithdrawFromVoteAccountParams): Transaction;
+  }
+
   export const SYSVAR_CLOCK_PUBKEY: PublicKey;
   export const SYSVAR_EPOCH_SCHEDULE_PUBKEY: PublicKey;
   export const SYSVAR_INSTRUCTIONS_PUBKEY: PublicKey;

package/lib/index.esm.js

@@ -2075,6 +2075,13 @@ const authorized = (property = 'authorized') => {
 const lockup = (property = 'lockup') => {
   return BufferLayout.struct([BufferLayout.ns64('unixTimestamp'), BufferLayout.ns64('epoch'), publicKey('custodian')], property);
 };
+/**
+ *  Layout for a VoteInit object
+ */
+
+const voteInit = (property = 'voteInit') => {
+  return BufferLayout.struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), BufferLayout.u8('commission')], property);
+};
 function getAlloc(type, fields) {
   let alloc = 0;
   type.layout.fields.forEach(item => {
@@ -8722,6 +8729,246 @@ function getPriorVoters({
   return [...buf.slice(idx + 1).map(parsePriorVoters), ...buf.slice(0, idx)];
 }
 
+/**
+ * Vote account info
+ */
+
+class VoteInit {
+  /** [0, 100] */
+  constructor(nodePubkey, authorizedVoter, authorizedWithdrawer, commission) {
+    this.nodePubkey = void 0;
+    this.authorizedVoter = void 0;
+    this.authorizedWithdrawer = void 0;
+    this.commission = void 0;
+    this.nodePubkey = nodePubkey;
+    this.authorizedVoter = authorizedVoter;
+    this.authorizedWithdrawer = authorizedWithdrawer;
+    this.commission = commission;
+  }
+
+}
+/**
+ * Create vote account transaction params
+ */
+
+/**
+ * Vote Instruction class
+ */
+class VoteInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+  /**
+   * Decode a vote instruction and retrieve the instruction type.
+   */
+
+
+  static decodeInstructionType(instruction) {
+    this.checkProgramId(instruction.programId);
+    const instructionTypeLayout = BufferLayout.u32('instruction');
+    const typeIndex = instructionTypeLayout.decode(instruction.data);
+    let type;
+
+    for (const [ixType, layout] of Object.entries(VOTE_INSTRUCTION_LAYOUTS)) {
+      if (layout.index == typeIndex) {
+        type = ixType;
+        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) {
+    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) {
+    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) {
+    if (!programId.equals(VoteProgram.programId)) {
+      throw new Error('invalid instruction; programId is not VoteProgram');
+    }
+  }
+  /**
+   * @internal
+   */
+
+
+  static checkKeyLength(keys, expectedLength) {
+    if (keys.length < expectedLength) {
+      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);
+    }
+  }
+
+}
+/**
+ * An enumeration of valid VoteInstructionType's
+ */
+
+const VOTE_INSTRUCTION_LAYOUTS = Object.freeze({
+  InitializeAccount: {
+    index: 0,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), voteInit()])
+  },
+  Withdraw: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+  }
+});
+/**
+ * Factory class for transactions to interact with the Vote program
+ */
+
+class VoteProgram {
+  /**
+   * @internal
+   */
+  constructor() {}
+  /**
+   * Public key that identifies the Vote program
+   */
+
+
+  /**
+   * Generate an Initialize instruction.
+   */
+  static initializeAccount(params) {
+    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) {
+    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) {
+    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
+    });
+  }
+
+}
+VoteProgram.programId = new PublicKey('Vote111111111111111111111111111111111111111');
+VoteProgram.space = 3731;
+
 /**
  * Send and confirm a raw transaction
  *
@@ -8785,5 +9032,5 @@ function clusterApiUrl(cluster, tls) {
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, 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, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, 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, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.esm.js.map