@solana/web3.js 1.32.1 → 1.35.0

package/lib/index.d.ts

@@ -2278,6 +2278,17 @@ declare module '@solana/web3.js' {
     splitStakePubkey: PublicKey;
     lamports: number;
   };
+  /**
+   * Split with seed transaction params
+   */
+  export type SplitStakeWithSeedParams = {
+    stakePubkey: PublicKey;
+    authorizedPubkey: PublicKey;
+    splitStakePubkey: PublicKey;
+    basePubkey: PublicKey;
+    seed: string;
+    lamports: number;
+  };
   /**
    * Withdraw stake instruction params
    */
@@ -2439,6 +2450,11 @@ declare module '@solana/web3.js' {
      * Generate a Transaction that splits Stake tokens into another stake account
      */
     static split(params: SplitStakeParams): Transaction;
+    /**
+     * Generate a Transaction that splits Stake tokens into another account
+     * derived from a base public key and seed
+     */
+    static splitWithSeed(params: SplitStakeWithSeedParams): Transaction;
     /**
      * Generate a Transaction that merges Stake accounts.
      */
@@ -2948,6 +2964,147 @@ 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;
+  };
+  /**
+   * Authorize instruction params
+   */
+  export type AuthorizeVoteParams = {
+    votePubkey: PublicKey;
+    /** Current vote or withdraw authority, depending on `voteAuthorizationType` */
+    authorizedPubkey: PublicKey;
+    newAuthorizedPubkey: PublicKey;
+    voteAuthorizationType: VoteAuthorizationType;
+  };
+  /**
+   * 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 an authorize instruction and retrieve the instruction params.
+     */
+    static decodeAuthorize(
+      instruction: TransactionInstruction,
+    ): AuthorizeVoteParams;
+    /**
+     * Decode a withdraw instruction and retrieve the instruction params.
+     */
+    static decodeWithdraw(
+      instruction: TransactionInstruction,
+    ): WithdrawFromVoteAccountParams;
+  }
+  /**
+   * An enumeration of valid VoteInstructionType's
+   */
+  export type VoteInstructionType =
+    | 'Authorize'
+    | 'InitializeAccount'
+    | 'Withdraw';
+  /**
+   * VoteAuthorize type
+   */
+  export type VoteAuthorizationType = {
+    /** The VoteAuthorize index (from solana-vote-program) */
+    index: number;
+  };
+  /**
+   * An enumeration of valid VoteAuthorization layouts.
+   */
+  export const VoteAuthorizationLayout: Readonly<{
+    Voter: {
+      index: number;
+    };
+    Withdrawer: {
+      index: number;
+    };
+  }>;
+  /**
+   * 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 that authorizes a new Voter or Withdrawer on the Vote account.
+     */
+    static authorize(params: AuthorizeVoteParams): 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 => {
@@ -6904,7 +6911,14 @@ class Connection {
         this._rpcWebSocketIdleTimeout = setTimeout(() => {
           this._rpcWebSocketIdleTimeout = null;
 
-          this._rpcWebSocket.close();
+          try {
+            this._rpcWebSocket.close();
+          } catch (err) {
+            // swallow error if socket has already been closed.
+            if (err instanceof Error) {
+              console.log(`Error when closing socket connection: ${err.message}`);
+            }
+          }
         }, 500);
       }
 
@@ -8216,30 +8230,22 @@ class StakeProgram {
     });
   }
   /**
-   * Generate a Transaction that splits Stake tokens into another stake account
+   * @internal
    */
 
 
-  static split(params) {
+  static splitInstruction(params) {
     const {
       stakePubkey,
       authorizedPubkey,
       splitStakePubkey,
       lamports
     } = params;
-    const transaction = new Transaction();
-    transaction.add(SystemProgram.createAccount({
-      fromPubkey: authorizedPubkey,
-      newAccountPubkey: splitStakePubkey,
-      lamports: 0,
-      space: this.space,
-      programId: this.programId
-    }));
     const type = STAKE_INSTRUCTION_LAYOUTS.Split;
     const data = encodeData(type, {
       lamports
     });
-    return transaction.add({
+    return new TransactionInstruction({
       keys: [{
         pubkey: stakePubkey,
         isSigner: false,
@@ -8257,6 +8263,52 @@ class StakeProgram {
       data
     });
   }
+  /**
+   * Generate a Transaction that splits Stake tokens into another stake account
+   */
+
+
+  static split(params) {
+    const transaction = new Transaction();
+    transaction.add(SystemProgram.createAccount({
+      fromPubkey: params.authorizedPubkey,
+      newAccountPubkey: params.splitStakePubkey,
+      lamports: 0,
+      space: this.space,
+      programId: this.programId
+    }));
+    return transaction.add(this.splitInstruction(params));
+  }
+  /**
+   * Generate a Transaction that splits Stake tokens into another account
+   * derived from a base public key and seed
+   */
+
+
+  static splitWithSeed(params) {
+    const {
+      stakePubkey,
+      authorizedPubkey,
+      splitStakePubkey,
+      basePubkey,
+      seed,
+      lamports
+    } = params;
+    const transaction = new Transaction();
+    transaction.add(SystemProgram.allocate({
+      accountPubkey: splitStakePubkey,
+      basePubkey,
+      seed,
+      space: this.space,
+      programId: this.programId
+    }));
+    return transaction.add(this.splitInstruction({
+      stakePubkey,
+      authorizedPubkey,
+      splitStakePubkey,
+      lamports
+    }));
+  }
   /**
    * Generate a Transaction that merges Stake accounts.
    */
@@ -8715,6 +8767,322 @@ 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 an authorize instruction and retrieve the instruction params.
+   */
+
+
+  static decodeAuthorize(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+    const {
+      newAuthorized,
+      voteAuthorizationType
+    } = decodeData(VOTE_INSTRUCTION_LAYOUTS.Authorize, instruction.data);
+    return {
+      votePubkey: instruction.keys[0].pubkey,
+      authorizedPubkey: instruction.keys[2].pubkey,
+      newAuthorizedPubkey: new PublicKey(newAuthorized),
+      voteAuthorizationType: {
+        index: voteAuthorizationType
+      }
+    };
+  }
+  /**
+   * 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()])
+  },
+  Authorize: {
+    index: 1,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), publicKey('newAuthorized'), BufferLayout.u32('voteAuthorizationType')])
+  },
+  Withdraw: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+  }
+});
+/**
+ * VoteAuthorize type
+ */
+
+/**
+ * An enumeration of valid VoteAuthorization layouts.
+ */
+const VoteAuthorizationLayout = Object.freeze({
+  Voter: {
+    index: 0
+  },
+  Withdrawer: {
+    index: 1
+  }
+});
+/**
+ * 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 that authorizes a new Voter or Withdrawer on the Vote account.
+   */
+
+
+  static authorize(params) {
+    const {
+      votePubkey,
+      authorizedPubkey,
+      newAuthorizedPubkey,
+      voteAuthorizationType
+    } = params;
+    const type = VOTE_INSTRUCTION_LAYOUTS.Authorize;
+    const data = encodeData(type, {
+      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
+      voteAuthorizationType: voteAuthorizationType.index
+    });
+    const keys = [{
+      pubkey: votePubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: SYSVAR_CLOCK_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    }, {
+      pubkey: authorizedPubkey,
+      isSigner: true,
+      isWritable: false
+    }];
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * 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
  *
@@ -8778,5 +9146,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, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.esm.js.map