@solana/web3.js 1.32.1 → 1.35.0

package/lib/index.iife.js

@@ -13978,6 +13978,13 @@ var solanaWeb3 = (function (exports) {
 	const lockup = (property = 'lockup') => {
 	  return struct([ns64('unixTimestamp'), ns64('epoch'), publicKey('custodian')], property);
 	};
+	/**
+	 *  Layout for a VoteInit object
+	 */
+
+	const voteInit = (property = 'voteInit') => {
+	  return struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), u8('commission')], property);
+	};
 	function getAlloc(type, fields) {
 	  let alloc = 0;
 	  type.layout.fields.forEach(item => {
@@ -22430,7 +22437,14 @@ var solanaWeb3 = (function (exports) {
 	        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);
 	      }
 
@@ -23742,30 +23756,22 @@ var solanaWeb3 = (function (exports) {
 	    });
 	  }
 	  /**
-	   * 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,
@@ -23783,6 +23789,52 @@ var solanaWeb3 = (function (exports) {
 	      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.
 	   */
@@ -29075,6 +29127,322 @@ var solanaWeb3 = (function (exports) {
 	  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 = 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: struct([u32('instruction'), voteInit()])
+	  },
+	  Authorize: {
+	    index: 1,
+	    layout: struct([u32('instruction'), publicKey('newAuthorized'), u32('voteAuthorizationType')])
+	  },
+	  Withdraw: {
+	    index: 3,
+	    layout: struct([u32('instruction'), 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
 	 *
@@ -29186,6 +29554,10 @@ var solanaWeb3 = (function (exports) {
 	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;