@exodus/solana-lib 1.2.12 → 1.2.14

package/lib/vendor/stake-program.js

@@ -0,0 +1,476 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StakeProgram = exports.StakeAuthorizationLayout = exports.StakeInstruction = exports.STAKE_INSTRUCTION_LAYOUTS = exports.Lockup = exports.Authorized = exports.STAKE_CONFIG_ID = void 0;
+
+var BufferLayout = _interopRequireWildcard(require("@exodus/buffer-layout"));
+
+var _instruction = require("./instruction");
+
+var Layout = _interopRequireWildcard(require("./utils/layout"));
+
+var _publickey = require("./publickey");
+
+var _systemProgram = require("./system-program");
+
+var _sysvar = require("./sysvar");
+
+var _transaction = require("./transaction");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const STAKE_CONFIG_ID = new _publickey.PublicKey('StakeConfig11111111111111111111111111111111');
+exports.STAKE_CONFIG_ID = STAKE_CONFIG_ID;
+
+class Authorized {
+  /**
+   * Create a new Authorized object
+   */
+  constructor(staker, withdrawer) {
+    _defineProperty(this, "staker", void 0);
+
+    _defineProperty(this, "withdrawer", void 0);
+
+    this.staker = staker;
+    this.withdrawer = withdrawer;
+  }
+
+}
+
+exports.Authorized = Authorized;
+
+class Lockup {
+  /**
+   * Create a new Lockup object
+   */
+  constructor(unixTimestamp, epoch, custodian) {
+    _defineProperty(this, "unixTimestamp", void 0);
+
+    _defineProperty(this, "epoch", void 0);
+
+    _defineProperty(this, "custodian", void 0);
+
+    this.unixTimestamp = unixTimestamp;
+    this.epoch = epoch;
+    this.custodian = custodian;
+  }
+
+}
+/**
+ * Create stake account transaction params
+ * @typedef {Object} CreateStakeAccountParams
+ * @property {PublicKey} fromPubkey
+ * @property {PublicKey} stakePubkey
+ * @property {Authorized} authorized
+ * @property {Lockup} lockup
+ * @property {number} lamports
+ */
+
+
+exports.Lockup = Lockup;
+
+/**
+ * An enumeration of valid stake InstructionType's
+ */
+const STAKE_INSTRUCTION_LAYOUTS = Object.freeze({
+  Initialize: {
+    index: 0,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.authorized(), Layout.lockup()])
+  },
+  Authorize: {
+    index: 1,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('newAuthorized'), BufferLayout.u32('stakeAuthorizationType')])
+  },
+  Delegate: {
+    index: 2,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction')])
+  },
+  Split: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+  },
+  Withdraw: {
+    index: 4,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+  },
+  Deactivate: {
+    index: 5,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction')])
+  },
+  AuthorizeWithSeed: {
+    index: 8,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('newAuthorized'), BufferLayout.u32('stakeAuthorizationType'), Layout.rustString('authoritySeed'), Layout.publicKey('authorityOwner')])
+  }
+});
+/**
+ * Stake Instruction class
+ */
+
+exports.STAKE_INSTRUCTION_LAYOUTS = STAKE_INSTRUCTION_LAYOUTS;
+
+class StakeInstruction {
+  /**
+   * Decode a stake 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 t of Object.keys(STAKE_INSTRUCTION_LAYOUTS)) {
+      if (STAKE_INSTRUCTION_LAYOUTS[t].index === typeIndex) {
+        type = t;
+      }
+    }
+
+    if (!type) {
+      throw new Error('Instruction type incorrect; not a StakeInstruction');
+    }
+
+    return type;
+  }
+  /**
+   * Decode a initialize stake instruction and retrieve the instruction params.
+   */
+
+
+  static decodeInitialize(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 2);
+    const {
+      authorized,
+      lockup
+    } = (0, _instruction.decodeData)(STAKE_INSTRUCTION_LAYOUTS.Initialize, instruction.data);
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      authorized: new Authorized(new _publickey.PublicKey(authorized.staker), new _publickey.PublicKey(authorized.withdrawer)),
+      lockup: new Lockup(lockup.unixTimestamp, lockup.epoch, new _publickey.PublicKey(lockup.custodian))
+    };
+  }
+  /**
+   * Decode a delegate stake instruction and retrieve the instruction params.
+   */
+
+
+  static decodeDelegate(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 6);
+    (0, _instruction.decodeData)(STAKE_INSTRUCTION_LAYOUTS.Delegate, instruction.data);
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      votePubkey: instruction.keys[1].pubkey,
+      authorizedPubkey: instruction.keys[5].pubkey
+    };
+  }
+  /**
+   * Decode a withdraw stake instruction and retrieve the instruction params.
+   */
+
+
+  static decodeWithdraw(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 5);
+    const {
+      lamports
+    } = (0, _instruction.decodeData)(STAKE_INSTRUCTION_LAYOUTS.Withdraw, instruction.data);
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      toPubkey: instruction.keys[1].pubkey,
+      authorizedPubkey: instruction.keys[4].pubkey,
+      lamports
+    };
+  }
+  /**
+   * Decode a deactivate stake instruction and retrieve the instruction params.
+   */
+
+
+  static decodeDeactivate(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+    (0, _instruction.decodeData)(STAKE_INSTRUCTION_LAYOUTS.Deactivate, instruction.data);
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      authorizedPubkey: instruction.keys[2].pubkey
+    };
+  }
+  /**
+   * @private
+   */
+
+
+  static checkProgramId(programId) {
+    if (!programId.equals(StakeProgram.programId)) {
+      throw new Error('invalid instruction; programId is not StakeProgram');
+    }
+  }
+  /**
+   * @private
+   */
+
+
+  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 StakeAuthorizationLayout's
+ */
+
+
+exports.StakeInstruction = StakeInstruction;
+const StakeAuthorizationLayout = Object.freeze({
+  Staker: {
+    index: 0
+  },
+  Withdrawer: {
+    index: 1
+  }
+});
+/**
+ * Factory class for transactions to interact with the Stake program
+ */
+
+exports.StakeAuthorizationLayout = StakeAuthorizationLayout;
+
+class StakeProgram {
+  /**
+   * Public key that identifies the Stake program
+   */
+  static get programId() {
+    return new _publickey.PublicKey('Stake11111111111111111111111111111111111111');
+  }
+  /**
+   * Max space of a Stake account
+   *
+   * This is generated from the solana-stake-program StakeState struct as
+   * `std::mem::size_of::<StakeState>()`:
+   * https://docs.rs/solana-stake-program/1.4.4/solana_stake_program/stake_state/enum.StakeState.html
+   */
+
+
+  static get space() {
+    return 200;
+  }
+  /**
+   * Generate an Initialize instruction to add to a Stake Create transaction
+   */
+
+
+  static initialize(params) {
+    const {
+      stakePubkey,
+      authorized,
+      lockup
+    } = params;
+    const type = STAKE_INSTRUCTION_LAYOUTS.Initialize;
+    const data = (0, _instruction.encodeData)(type, {
+      authorized: {
+        staker: authorized.staker.toBuffer(),
+        withdrawer: authorized.withdrawer.toBuffer()
+      },
+      lockup: {
+        unixTimestamp: lockup.unixTimestamp,
+        epoch: lockup.epoch,
+        custodian: lockup.custodian.toBuffer()
+      }
+    });
+    const instructionData = {
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: _sysvar.SYSVAR_RENT_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    };
+    return new _transaction.TransactionInstruction(instructionData);
+  }
+  /**
+   * Generate a Transaction that creates a new Stake account at
+   *   an address generated with `from`, a seed, and the Stake programId
+   */
+
+
+  static createAccountWithSeed(params) {
+    const transaction = new _transaction.Transaction();
+    transaction.add(_systemProgram.SystemProgram.createAccountWithSeed({
+      fromPubkey: params.fromPubkey,
+      newAccountPubkey: params.stakePubkey,
+      basePubkey: params.basePubkey,
+      seed: params.seed,
+      lamports: params.lamports,
+      space: this.space,
+      programId: this.programId
+    }));
+    const {
+      stakePubkey,
+      authorized,
+      lockup
+    } = params;
+    return transaction.add(this.initialize({
+      stakePubkey,
+      authorized,
+      lockup
+    }));
+  }
+  /**
+   * Generate a Transaction that creates a new Stake account
+   */
+
+
+  static createAccount(params) {
+    const transaction = new _transaction.Transaction();
+    transaction.add(_systemProgram.SystemProgram.createAccount({
+      fromPubkey: params.fromPubkey,
+      newAccountPubkey: params.stakePubkey,
+      lamports: params.lamports,
+      space: this.space,
+      programId: this.programId
+    }));
+    const {
+      stakePubkey,
+      authorized,
+      lockup
+    } = params;
+    return transaction.add(this.initialize({
+      stakePubkey,
+      authorized,
+      lockup
+    }));
+  }
+  /**
+   * Generate a Transaction that delegates Stake tokens to a validator
+   * Vote PublicKey. This transaction can also be used to redelegate Stake
+   * to a new validator Vote PublicKey.
+   */
+
+
+  static delegate(params) {
+    const {
+      stakePubkey,
+      authorizedPubkey,
+      votePubkey
+    } = params;
+    const type = STAKE_INSTRUCTION_LAYOUTS.Delegate;
+    const data = (0, _instruction.encodeData)(type);
+    return new _transaction.Transaction().add({
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: votePubkey,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: _sysvar.SYSVAR_CLOCK_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: _sysvar.SYSVAR_STAKE_HISTORY_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: STAKE_CONFIG_ID,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a Transaction that withdraws deactivated Stake tokens.
+   */
+
+
+  static withdraw(params) {
+    const {
+      stakePubkey,
+      authorizedPubkey,
+      toPubkey,
+      lamports
+    } = params;
+    const type = STAKE_INSTRUCTION_LAYOUTS.Withdraw;
+    const data = (0, _instruction.encodeData)(type, {
+      lamports
+    });
+    return new _transaction.Transaction().add({
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: toPubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: _sysvar.SYSVAR_CLOCK_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: _sysvar.SYSVAR_STAKE_HISTORY_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a Transaction that deactivates Stake tokens.
+   */
+
+
+  static deactivate(params) {
+    const {
+      stakePubkey,
+      authorizedPubkey
+    } = params;
+    const type = STAKE_INSTRUCTION_LAYOUTS.Deactivate;
+    const data = (0, _instruction.encodeData)(type);
+    return new _transaction.Transaction().add({
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: _sysvar.SYSVAR_CLOCK_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+
+}
+
+exports.StakeProgram = StakeProgram;