@solana/web3.js 1.32.2 → 1.35.1

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 => {
@@ -4347,13 +4354,13 @@ const VersionResult = superstruct.type({
 const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(superstruct.type({
   err: superstruct.nullable(superstruct.union([superstruct.type({}), superstruct.string()])),
   logs: superstruct.nullable(superstruct.array(superstruct.string())),
-  accounts: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.type({
+  accounts: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.nullable(superstruct.type({
     executable: superstruct.boolean(),
     owner: superstruct.string(),
     lamports: superstruct.number(),
     data: superstruct.array(superstruct.string()),
     rentEpoch: superstruct.optional(superstruct.number())
-  })))),
+  }))))),
   unitsConsumed: superstruct.optional(superstruct.number())
 }));
 
@@ -8258,30 +8265,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,
@@ -8299,6 +8298,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.
    */
@@ -8757,6 +8802,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
  *
@@ -8868,6 +9229,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;