@solana/web3.js 1.32.0 → 1.34.0

package/lib/index.cjs.js

@@ -2110,6 +2110,13 @@ const authorized = (property = 'authorized') => {
 const lockup = (property = 'lockup') => {
   return BufferLayout__namespace.struct([BufferLayout__namespace.ns64('unixTimestamp'), BufferLayout__namespace.ns64('epoch'), publicKey('custodian')], property);
 };
+/**
+ *  Layout for a VoteInit object
+ */
+
+const voteInit = (property = 'voteInit') => {
+  return BufferLayout__namespace.struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), BufferLayout__namespace.u8('commission')], property);
+};
 function getAlloc(type, fields) {
   let alloc = 0;
   type.layout.fields.forEach(item => {
@@ -2964,7 +2971,8 @@ const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey('SysvarStakeHistory11111111111
 async function sendAndConfirmTransaction(connection, transaction, signers, options) {
   const sendOptions = options && {
     skipPreflight: options.skipPreflight,
-    preflightCommitment: options.preflightCommitment || options.commitment
+    preflightCommitment: options.preflightCommitment || options.commitment,
+    maxRetries: options.maxRetries
   };
   const signature = await connection.sendTransaction(transaction, signers, sendOptions);
   const status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
@@ -4909,8 +4917,31 @@ const ParsedConfirmedTransactionMetaResult = superstruct.type({
   preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult)))
 });
+/**
+ * Expected JSON RPC response for the "getBlock" message
+ */
+
+const GetBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+  blockhash: superstruct.string(),
+  previousBlockhash: superstruct.string(),
+  parentSlot: superstruct.number(),
+  transactions: superstruct.array(superstruct.type({
+    transaction: ConfirmedTransactionResult,
+    meta: superstruct.nullable(ConfirmedTransactionMetaResult)
+  })),
+  rewards: superstruct.optional(superstruct.array(superstruct.type({
+    pubkey: superstruct.string(),
+    lamports: superstruct.number(),
+    postBalance: superstruct.nullable(superstruct.number()),
+    rewardType: superstruct.nullable(superstruct.string())
+  }))),
+  blockTime: superstruct.nullable(superstruct.number()),
+  blockHeight: superstruct.nullable(superstruct.number())
+})));
 /**
  * Expected JSON RPC response for the "getConfirmedBlock" message
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetBlockRpcResult} instead.
  */
 
 const GetConfirmedBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
@@ -4930,10 +4961,10 @@ const GetConfirmedBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruc
   blockTime: superstruct.nullable(superstruct.number())
 })));
 /**
- * Expected JSON RPC response for the "getConfirmedBlockSignatures" message
+ * Expected JSON RPC response for the "getBlock" message
  */
 
-const GetConfirmedBlockSignaturesRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+const GetBlockSignaturesRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
   blockhash: superstruct.string(),
   previousBlockhash: superstruct.string(),
   parentSlot: superstruct.number(),
@@ -4941,20 +4972,20 @@ const GetConfirmedBlockSignaturesRpcResult = jsonRpcResult(superstruct.nullable(
   blockTime: superstruct.nullable(superstruct.number())
 })));
 /**
- * Expected JSON RPC response for the "getConfirmedTransaction" message
+ * Expected JSON RPC response for the "getTransaction" message
  */
 
-const GetConfirmedTransactionRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+const GetTransactionRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
   slot: superstruct.number(),
   meta: ConfirmedTransactionMetaResult,
   blockTime: superstruct.optional(superstruct.nullable(superstruct.number())),
   transaction: ConfirmedTransactionResult
 })));
 /**
- * Expected JSON RPC response for the "getConfirmedTransaction" message
+ * Expected parsed JSON RPC response for the "getTransaction" message
  */
 
-const GetParsedConfirmedTransactionRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+const GetParsedTransactionRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
   slot: superstruct.number(),
   transaction: ParsedConfirmedTransactionResult,
   meta: superstruct.nullable(ParsedConfirmedTransactionMetaResult),
@@ -4962,6 +4993,8 @@ const GetParsedConfirmedTransactionRpcResult = jsonRpcResult(superstruct.nullabl
 })));
 /**
  * Expected JSON RPC response for the "getRecentBlockhash" message
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetLatestBlockhashRpcResult} instead.
  */
 
 const GetRecentBlockhashAndContextRpcResult = jsonRpcResultAndContext(superstruct.type({
@@ -4970,6 +5003,14 @@ const GetRecentBlockhashAndContextRpcResult = jsonRpcResultAndContext(superstruc
     lamportsPerSignature: superstruct.number()
   })
 }));
+/**
+ * Expected JSON RPC response for the "getLatestBlockhash" message
+ */
+
+const GetLatestBlockhashRpcResult = jsonRpcResultAndContext(superstruct.type({
+  blockhash: superstruct.string(),
+  lastValidBlockHeight: superstruct.number()
+}));
 const PerfSampleResult = superstruct.type({
   slot: superstruct.number(),
   numTransactions: superstruct.number(),
@@ -5914,6 +5955,8 @@ class Connection {
   /**
    * Fetch a recent blockhash from the cluster, return with context
    * @return {Promise<RpcResponseAndContext<{blockhash: Blockhash, feeCalculator: FeeCalculator}>>}
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getLatestBlockhash} instead.
    */
 
 
@@ -5949,6 +5992,8 @@ class Connection {
   }
   /**
    * Fetch the fee calculator for a recent blockhash from the cluster, return with context
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getFeeForMessage} instead.
    */
 
 
@@ -5997,6 +6042,8 @@ class Connection {
   /**
    * Fetch a recent blockhash from the cluster
    * @return {Promise<{blockhash: Blockhash, feeCalculator: FeeCalculator}>}
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getLatestBlockhash} instead.
    */
 
 
@@ -6008,6 +6055,38 @@ class Connection {
       throw new Error('failed to get recent blockhash: ' + e);
     }
   }
+  /**
+   * Fetch the latest blockhash from the cluster
+   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   */
+
+
+  async getLatestBlockhash(commitment) {
+    try {
+      const res = await this.getLatestBlockhashAndContext(commitment);
+      return res.value;
+    } catch (e) {
+      throw new Error('failed to get recent blockhash: ' + e);
+    }
+  }
+  /**
+   * Fetch the latest blockhash from the cluster
+   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   */
+
+
+  async getLatestBlockhashAndContext(commitment) {
+    const args = this._buildArgs([], commitment);
+
+    const unsafeRes = await this._rpcRequest('getLatestBlockhash', args);
+    const res = superstruct.create(unsafeRes, GetLatestBlockhashRpcResult);
+
+    if ('error' in res) {
+      throw new Error('failed to get latest blockhash: ' + res.error.message);
+    }
+
+    return res.result;
+  }
   /**
    * Fetch the node version
    */
@@ -6046,8 +6125,8 @@ class Connection {
   async getBlock(slot, opts) {
     const args = this._buildArgsAtLeastConfirmed([slot], opts && opts.commitment);
 
-    const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);
-    const res = superstruct.create(unsafeRes, GetConfirmedBlockRpcResult);
+    const unsafeRes = await this._rpcRequest('getBlock', args);
+    const res = superstruct.create(unsafeRes, GetBlockRpcResult);
 
     if ('error' in res) {
       throw new Error('failed to get confirmed block: ' + res.error.message);
@@ -6071,18 +6150,18 @@ class Connection {
     };
   }
   /**
-   * Fetch a processed transaction from the cluster.
+   * Fetch a confirmed or finalized transaction from the cluster.
    */
 
 
   async getTransaction(signature, opts) {
     const args = this._buildArgsAtLeastConfirmed([signature], opts && opts.commitment);
 
-    const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
-    const res = superstruct.create(unsafeRes, GetConfirmedTransactionRpcResult);
+    const unsafeRes = await this._rpcRequest('getTransaction', args);
+    const res = superstruct.create(unsafeRes, GetTransactionRpcResult);
 
     if ('error' in res) {
-      throw new Error('failed to get confirmed transaction: ' + res.error.message);
+      throw new Error('failed to get transaction: ' + res.error.message);
     }
 
     const result = res.result;
@@ -6093,6 +6172,49 @@ class Connection {
       }
     };
   }
+  /**
+   * Fetch parsed transaction details for a confirmed or finalized transaction
+   */
+
+
+  async getParsedTransaction(signature, commitment) {
+    const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed');
+
+    const unsafeRes = await this._rpcRequest('getTransaction', args);
+    const res = superstruct.create(unsafeRes, GetParsedTransactionRpcResult);
+
+    if ('error' in res) {
+      throw new Error('failed to get transaction: ' + res.error.message);
+    }
+
+    return res.result;
+  }
+  /**
+   * Fetch parsed transaction details for a batch of confirmed transactions
+   */
+
+
+  async getParsedTransactions(signatures, commitment) {
+    const batch = signatures.map(signature => {
+      const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed');
+
+      return {
+        methodName: 'getTransaction',
+        args
+      };
+    });
+    const unsafeRes = await this._rpcBatchRequest(batch);
+    const res = unsafeRes.map(unsafeRes => {
+      const res = superstruct.create(unsafeRes, GetParsedTransactionRpcResult);
+
+      if ('error' in res) {
+        throw new Error('failed to get transactions: ' + res.error.message);
+      }
+
+      return res.result;
+    });
+    return res;
+  }
   /**
    * Fetch a list of Transactions and transaction statuses from the cluster
    * for a confirmed block.
@@ -6102,18 +6224,39 @@ class Connection {
 
 
   async getConfirmedBlock(slot, commitment) {
-    const result = await this.getBlock(slot, {
-      commitment
-    });
+    const args = this._buildArgsAtLeastConfirmed([slot], commitment);
+
+    const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);
+    const res = superstruct.create(unsafeRes, GetConfirmedBlockRpcResult);
+
+    if ('error' in res) {
+      throw new Error('failed to get confirmed block: ' + res.error.message);
+    }
+
+    const result = res.result;
 
     if (!result) {
       throw new Error('Confirmed block ' + slot + ' not found');
     }
 
-    return { ...result,
+    const block = { ...result,
       transactions: result.transactions.map(({
         transaction,
         meta
+      }) => {
+        const message = new Message(transaction.message);
+        return {
+          meta,
+          transaction: { ...transaction,
+            message
+          }
+        };
+      })
+    };
+    return { ...block,
+      transactions: block.transactions.map(({
+        transaction,
+        meta
       }) => {
         return {
           meta,
@@ -6130,7 +6273,7 @@ class Connection {
   async getBlocks(startSlot, endSlot, commitment) {
     const args = this._buildArgsAtLeastConfirmed(endSlot !== undefined ? [startSlot, endSlot] : [startSlot], commitment);
 
-    const unsafeRes = await this._rpcRequest('getConfirmedBlocks', args);
+    const unsafeRes = await this._rpcRequest('getBlocks', args);
     const res = superstruct.create(unsafeRes, jsonRpcResult(superstruct.array(superstruct.number())));
 
     if ('error' in res) {
@@ -6139,8 +6282,36 @@ class Connection {
 
     return res.result;
   }
+  /**
+   * Fetch a list of Signatures from the cluster for a block, excluding rewards
+   */
+
+
+  async getBlockSignatures(slot, commitment) {
+    const args = this._buildArgsAtLeastConfirmed([slot], commitment, undefined, {
+      transactionDetails: 'signatures',
+      rewards: false
+    });
+
+    const unsafeRes = await this._rpcRequest('getBlock', args);
+    const res = superstruct.create(unsafeRes, GetBlockSignaturesRpcResult);
+
+    if ('error' in res) {
+      throw new Error('failed to get block: ' + res.error.message);
+    }
+
+    const result = res.result;
+
+    if (!result) {
+      throw new Error('Block ' + slot + ' not found');
+    }
+
+    return result;
+  }
   /**
    * Fetch a list of Signatures from the cluster for a confirmed block, excluding rewards
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getBlockSignatures} instead.
    */
 
 
@@ -6151,7 +6322,7 @@ class Connection {
     });
 
     const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);
-    const res = superstruct.create(unsafeRes, GetConfirmedBlockSignaturesRpcResult);
+    const res = superstruct.create(unsafeRes, GetBlockSignaturesRpcResult);
 
     if ('error' in res) {
       throw new Error('failed to get confirmed block: ' + res.error.message);
@@ -6167,24 +6338,33 @@ class Connection {
   }
   /**
    * Fetch a transaction details for a confirmed transaction
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getTransaction} instead.
    */
 
 
   async getConfirmedTransaction(signature, commitment) {
-    const result = await this.getTransaction(signature, {
-      commitment
-    });
+    const args = this._buildArgsAtLeastConfirmed([signature], commitment);
+
+    const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
+    const res = superstruct.create(unsafeRes, GetTransactionRpcResult);
+
+    if ('error' in res) {
+      throw new Error('failed to get transaction: ' + res.error.message);
+    }
+
+    const result = res.result;
     if (!result) return result;
-    const {
-      message,
-      signatures
-    } = result.transaction;
+    const message = new Message(result.transaction.message);
+    const signatures = result.transaction.signatures;
     return { ...result,
       transaction: Transaction.populate(message, signatures)
     };
   }
   /**
    * Fetch parsed transaction details for a confirmed transaction
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getParsedTransaction} instead.
    */
 
 
@@ -6192,7 +6372,7 @@ class Connection {
     const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed');
 
     const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
-    const res = superstruct.create(unsafeRes, GetParsedConfirmedTransactionRpcResult);
+    const res = superstruct.create(unsafeRes, GetParsedTransactionRpcResult);
 
     if ('error' in res) {
       throw new Error('failed to get confirmed transaction: ' + res.error.message);
@@ -6202,6 +6382,8 @@ class Connection {
   }
   /**
    * Fetch parsed transaction details for a batch of confirmed transactions
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getParsedTransactions} instead.
    */
 
 
@@ -6216,7 +6398,7 @@ class Connection {
     });
     const unsafeRes = await this._rpcBatchRequest(batch);
     const res = unsafeRes.map(unsafeRes => {
-      const res = superstruct.create(unsafeRes, GetParsedConfirmedTransactionRpcResult);
+      const res = superstruct.create(unsafeRes, GetParsedTransactionRpcResult);
 
       if ('error' in res) {
         throw new Error('failed to get confirmed transactions: ' + res.error.message);
@@ -6606,6 +6788,10 @@ class Connection {
     const skipPreflight = options && options.skipPreflight;
     const preflightCommitment = options && options.preflightCommitment || this.commitment;
 
+    if (options && options.maxRetries) {
+      config.maxRetries = options.maxRetries;
+    }
+
     if (skipPreflight) {
       config.skipPreflight = skipPreflight;
     }
@@ -6760,7 +6946,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);
       }
 
@@ -8571,6 +8764,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__namespace.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__namespace.struct([BufferLayout__namespace.u32('instruction'), voteInit()])
+  },
+  Authorize: {
+    index: 1,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), publicKey('newAuthorized'), BufferLayout__namespace.u32('voteAuthorizationType')])
+  },
+  Withdraw: {
+    index: 3,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), BufferLayout__namespace.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
  *
@@ -8600,12 +9109,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/'
   }
 };
 
@@ -8682,6 +9191,10 @@ exports.VALIDATOR_INFO_KEY = VALIDATOR_INFO_KEY;
 exports.VOTE_PROGRAM_ID = VOTE_PROGRAM_ID;
 exports.ValidatorInfo = ValidatorInfo;
 exports.VoteAccount = VoteAccount;
+exports.VoteAuthorizationLayout = VoteAuthorizationLayout;
+exports.VoteInit = VoteInit;
+exports.VoteInstruction = VoteInstruction;
+exports.VoteProgram = VoteProgram;
 exports.clusterApiUrl = clusterApiUrl;
 exports.sendAndConfirmRawTransaction = sendAndConfirmRawTransaction;
 exports.sendAndConfirmTransaction = sendAndConfirmTransaction;