@exodus/solana-lib 1.2.5 → 1.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.2.5",
+  "version": "1.2.8",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -22,5 +22,5 @@
     "create-hash": "~1.1.3",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "791e305a718246460d5ac93ed2eb7808955c0f5d"
+  "gitHead": "0dc8adf4a7d4d6dc3d0785f5b5d39e0a6bfb23cd"
 }

package/src/constants.js

@@ -1,8 +1,12 @@
-import { PublicKey, SystemProgram } from './vendor'
+import { PublicKey, SystemProgram, StakeProgram } from './vendor'
 
 export const SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID = new PublicKey(
   'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL'
 )
 export const SYSTEM_PROGRAM_ID = SystemProgram.programId
 
+export const STAKE_PROGRAM_ID = StakeProgram.programId
+
 export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')
+
+export const SEED = 'stake:0'

package/src/encode.js

@@ -1,6 +1,6 @@
 // @flow
-import { PublicKey } from './vendor'
-import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID } from './constants'
+import { PublicKey, StakeProgram } from './vendor'
+import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID, SEED } from './constants'
 import { getPublicKey } from './keypair'
 import bs58 from 'bs58'
 import BN from 'bn.js'
@@ -42,3 +42,16 @@ export function findAssociatedTokenAddress(
     SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID
   )[0].toBase58() // returns encoded PublicKey
 }
+
+export function createStakeAddress(walletAddress: string, seed = SEED): string {
+  const fromPubkey = new PublicKey(walletAddress)
+
+  const newAccountPubkey = PublicKey.createWithSeed(
+    // HACK: refactored to sync
+    fromPubkey,
+    seed,
+    StakeProgram.programId
+  )
+
+  return newAccountPubkey.toBase58()
+}

package/src/tokens.js

@@ -7,6 +7,12 @@ const TOKENS = [
     tokenProperName: 'Serum',
     tokenSymbol: 'SRM',
   },
+  {
+    mintAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+    tokenName: 'usdcoin_solana',
+    tokenProperName: 'USD Coin Solana',
+    tokenSymbol: 'USDC Solana',
+  },
   // ....
 ]
 

package/src/transaction.js

@@ -2,12 +2,21 @@
 import assert from 'assert'
 
 import { getKeyPairFromPrivateKey } from './keypair'
-import { findAssociatedTokenAddress } from './encode'
+import { findAssociatedTokenAddress, createStakeAddress } from './encode'
 import {
   createAssociatedTokenAccount,
   createTokenTransferInstruction,
 } from './helpers/tokenTransfer'
-import { PublicKey, Account, Transaction, SystemProgram } from './vendor'
+import {
+  PublicKey,
+  Account,
+  Transaction,
+  SystemProgram,
+  StakeProgram,
+  Authorized,
+  Lockup,
+} from './vendor'
+import { SEED } from './constants'
 import TOKENS from './tokens'
 import bs58 from 'bs58'
 
@@ -121,13 +130,81 @@ class Tx {
     assert(amountLeft === 0, `Not enough balance to send ${amount} ${token.tokenSymbol}`)
   }
 
-  static sign(tx: Tx, privateKey: Buffer | string) {
+  static createStakeAccountTransaction({ address, amount, seed = SEED, pool, recentBlockhash }) {
+    const fromPubkey = new PublicKey(address)
+    const stakeAddress = createStakeAddress(address, seed)
+    const stakePublicKey = new PublicKey(stakeAddress)
+    const poolKey = new PublicKey(pool)
+
+    const authorized = new Authorized(fromPubkey, fromPubkey) // staker, withdrawer
+    const lockup = new Lockup(0, 0, fromPubkey) // no lockup
+
+    // create account instruction
+    const programTx = StakeProgram.createAccountWithSeed({
+      fromPubkey,
+      stakePubkey: stakePublicKey,
+      basePubkey: fromPubkey,
+      seed,
+      authorized,
+      lockup,
+      lamports: amount, // number
+    })
+
+    // delegate funds instruction
+    const delegateTx = StakeProgram.delegate({
+      stakePubkey: stakePublicKey,
+      authorizedPubkey: fromPubkey,
+      votePubkey: poolKey, // pool vote key
+    })
+
+    const transaction = new Transaction({ recentBlockhash }).add(programTx).add(delegateTx)
+    return transaction
+  }
+
+  static undelegate({ address, stakeAddresses, recentBlockhash }) {
+    // undelegate all stake addresses
+    assert(Array.isArray(stakeAddresses), 'stakeAddresses Array is required')
+
+    const fromPubkey = new PublicKey(address)
+    const transaction = new Transaction({ recentBlockhash })
+
+    stakeAddresses.forEach((stakeAddress) => {
+      const stakePublicKey = new PublicKey(stakeAddress)
+      const programTx = StakeProgram.deactivate({
+        stakePubkey: stakePublicKey,
+        authorizedPubkey: fromPubkey,
+      })
+      transaction.add(programTx)
+    })
+
+    return transaction
+  }
+
+  static withdraw({ address, stakeAddresses, amount, recentBlockhash }) {
+    const fromPubkey = new PublicKey(address)
+    const stakeAddress = Array.isArray(stakeAddresses) ? stakeAddresses[0] : stakeAddresses
+    const stakePublicKey = new PublicKey(stakeAddress)
+
+    const transaction = StakeProgram.withdraw({
+      stakePubkey: stakePublicKey,
+      authorizedPubkey: fromPubkey,
+      toPubkey: fromPubkey,
+      lamports: amount,
+    })
+    transaction.recentBlockhash = recentBlockhash
+    return transaction
+  }
+
+  static sign(tx, privateKey: Buffer | string) {
     if (!privateKey) throw new Error('Please provide a secretKey')
     const { secretKey } = getKeyPairFromPrivateKey(privateKey)
     const signers = [new Account(secretKey)]
 
-    tx.transaction.sign(...signers)
-    if (!tx.transaction.signature) {
+    let transaction = tx
+    if (tx instanceof Tx) transaction = tx.transaction
+
+    transaction.sign(...signers)
+    if (!transaction.signature) {
       throw new Error('!signature') // should never happen
     }
   }
@@ -137,12 +214,27 @@ class Tx {
     return wireTransaction.toString('base64')
   }
 
+  static serialize(tx) {
+    let transaction = tx
+    if (tx instanceof Tx) transaction = tx.transaction
+    return transaction.serialize().toString('base64')
+  }
+
   getTxId() {
     if (!this.transaction.signature) {
       throw new Error('Cannot get txId, tx is not signed')
     }
     return bs58.encode(this.transaction.signature)
   }
+
+  static getTxId(tx) {
+    let transaction = tx
+    if (tx instanceof Tx) transaction = tx.transaction
+    if (!transaction.signature) {
+      throw new Error('Cannot get txId, tx is not signed')
+    }
+    return bs58.encode(transaction.signature)
+  }
 }
 
 export default Tx

package/src/tx/create-unsigned-tx.js

@@ -11,6 +11,11 @@ export function createUnsignedTx({
   destinationAddressType,
   isAssociatedTokenAccountActive, // true when recipient balance !== 0
   fromTokenAddresses, // sender token addresses
+  // Staking related:
+  method,
+  stakeAddresses,
+  seed,
+  pool,
 }: ParsedTransaction): UnsignedTransaction {
   return {
     txData: {
@@ -23,6 +28,11 @@ export function createUnsignedTx({
       destinationAddressType,
       isAssociatedTokenAccountActive,
       fromTokenAddresses,
+      // Staking related:
+      method,
+      stakeAddresses,
+      seed,
+      pool,
     },
     txMeta: {
       assetName: asset.name,

package/src/tx/parse-unsigned-tx.js

@@ -11,6 +11,10 @@ export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransact
     destinationAddressType,
     isAssociatedTokenAccountActive,
     fromTokenAddresses,
+    method,
+    stakeAddresses,
+    seed,
+    pool,
     ...txData
   } = unsignedTx.txData
 
@@ -26,5 +30,10 @@ export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransact
     destinationAddressType,
     isAssociatedTokenAccountActive,
     fromTokenAddresses,
+    // staking related
+    method,
+    stakeAddresses,
+    seed,
+    pool,
   }
 }

package/src/tx/sign-unsigned-tx.js

@@ -9,30 +9,70 @@ export function signUnsignedTx(
   const {
     from,
     to,
-    amount,
+    amount: unitAmount,
     recentBlockhash,
+    // tokens related
     tokenName,
     destinationAddressType,
     isAssociatedTokenAccountActive,
     fromTokenAddresses,
+    // staking related
+    stakeAddresses,
+    method,
+    seed,
+    pool,
   } = unsignedTx.txData
 
   const asset = assets.solana
-  const tx = new Transaction({
-    from,
-    to,
-    amount: asset.currency.baseUnit(amount).toNumber(),
-    recentBlockhash,
-    tokenName,
-    destinationAddressType,
-    isAssociatedTokenAccountActive,
-    fromTokenAddresses,
-  })
+
+  const address = from
+  const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount
+
+  let tx
+  switch (method) {
+    case 'delegate':
+      tx = Transaction.createStakeAccountTransaction({
+        address,
+        amount,
+        recentBlockhash,
+        seed,
+        pool,
+      })
+      break
+    case 'undelegate':
+      tx = Transaction.undelegate({
+        address,
+        stakeAddresses,
+        recentBlockhash,
+      })
+      break
+    case 'withdraw':
+      tx = Transaction.withdraw({
+        address,
+        stakeAddresses,
+        amount,
+        recentBlockhash,
+      })
+      break
+    default:
+      // SOL and Token tx
+      tx = new Transaction({
+        from,
+        to,
+        amount,
+        recentBlockhash,
+        tokenName,
+        destinationAddressType,
+        isAssociatedTokenAccountActive,
+        fromTokenAddresses,
+      })
+      break
+  }
 
   // sign plain tx
   Transaction.sign(tx, privateKey)
-  const rawTx = tx.serialize()
-  const txId = tx.getTxId()
+  const rawTx = Transaction.serialize(tx)
+  const txId = Transaction.getTxId(tx)
 
   return { txId, rawTx }
 }

package/src/vendor/index.js

@@ -4,5 +4,6 @@ export * from './message'
 export * from './nonce-account'
 export * from './publickey'
 export * from './system-program'
+export * from './stake-program'
 export * from './sysvar'
 export * from './transaction'

package/src/vendor/publickey.js

@@ -97,6 +97,26 @@ export class PublicKey {
     throw new Error('Unable to find a viable program address nonce')
   }
 
+  /**
+   * Derive a public key from another key, a seed, and a program ID.
+   * HACK: transformed in sync function
+   */
+  static createWithSeed(
+    fromPublicKey: PublicKey,
+    seed: string,
+    programId: PublicKey
+  ): Promise<PublicKey> {
+    const buffer = Buffer.concat([
+      fromPublicKey.toBuffer(),
+      Buffer.from(seed),
+      programId.toBuffer(),
+    ])
+    const hash = createHash('sha256')
+      .update(buffer)
+      .digest('hex')
+    return new PublicKey(Buffer.from(hash, 'hex'))
+  }
+
   /**
    * Derive a program address from seeds and a program ID.
    */

package/src/vendor/stake-program.js

@@ -0,0 +1,527 @@
+// @flow
+
+import * as BufferLayout from '@exodus/buffer-layout'
+
+import { encodeData, decodeData } from './instruction'
+import * as Layout from './utils/layout'
+import { PublicKey } from './publickey'
+import { SystemProgram } from './system-program'
+import { SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY } from './sysvar'
+import { Transaction, TransactionInstruction } from './transaction'
+
+export const STAKE_CONFIG_ID = new PublicKey('StakeConfig11111111111111111111111111111111')
+
+export class Authorized {
+  staker: PublicKey
+  withdrawer: PublicKey
+
+  /**
+   * Create a new Authorized object
+   */
+  constructor(staker: PublicKey, withdrawer: PublicKey) {
+    this.staker = staker
+    this.withdrawer = withdrawer
+  }
+}
+
+export class Lockup {
+  unixTimestamp: number
+  epoch: number
+  custodian: PublicKey
+
+  /**
+   * Create a new Lockup object
+   */
+  constructor(unixTimestamp: number, epoch: number, custodian: PublicKey) {
+    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
+ */
+export type CreateStakeAccountParams = {|
+  fromPubkey: PublicKey,
+  stakePubkey: PublicKey,
+  authorized: Authorized,
+  lockup: Lockup,
+  lamports: number,
+|}
+
+/**
+ * Create stake account with seed transaction params
+ * @typedef {Object} CreateStakeAccountWithSeedParams
+ * @property {PublicKey} fromPubkey
+ * @property {PublicKey} stakePubkey
+ * @property {PublicKey} basePubkey
+ * @property {string} seed
+ * @property {Authorized} authorized
+ * @property {Lockup} lockup
+ * @property {number} lamports
+ */
+export type CreateStakeAccountWithSeedParams = {|
+  fromPubkey: PublicKey,
+  stakePubkey: PublicKey,
+  basePubkey: PublicKey,
+  seed: string,
+  authorized: Authorized,
+  lockup: Lockup,
+  lamports: number,
+|}
+
+/**
+ * Initialize stake instruction params
+ * @typedef {Object} InitializeStakeParams
+ * @property {PublicKey} stakePubkey
+ * @property {Authorized} authorized
+ * @property {Lockup} lockup
+ */
+export type InitializeStakeParams = {|
+  stakePubkey: PublicKey,
+  authorized: Authorized,
+  lockup: Lockup,
+|}
+
+/**
+ * Delegate stake instruction params
+ * @typedef {Object} DelegateStakeParams
+ * @property {PublicKey} stakePubkey
+ * @property {PublicKey} authorizedPubkey
+ * @property {PublicKey} votePubkey
+ */
+export type DelegateStakeParams = {|
+  stakePubkey: PublicKey,
+  authorizedPubkey: PublicKey,
+  votePubkey: PublicKey,
+|}
+
+/**
+ * @typedef {Object} StakeAuthorizationType
+ * @property (index} The Stake Authorization index (from solana-stake-program)
+ */
+export type StakeAuthorizationType = {|
+  index: number,
+|}
+
+/**
+ * Authorize stake instruction params
+ * @typedef {Object} AuthorizeStakeParams
+ * @property {PublicKey} stakePubkey
+ * @property {PublicKey} authorizedPubkey
+ * @property {PublicKey} newAuthorizedPubkey
+ * @property {StakeAuthorizationType} stakeAuthorizationType
+ */
+export type AuthorizeStakeParams = {|
+  stakePubkey: PublicKey,
+  authorizedPubkey: PublicKey,
+  newAuthorizedPubkey: PublicKey,
+  stakeAuthorizationType: StakeAuthorizationType,
+|}
+
+/**
+ * Authorize stake instruction params using a derived key
+ * @typedef {Object} AuthorizeWithSeedStakeParams
+ * @property {PublicKey} stakePubkey
+ * @property {PublicKey} authorityBase
+ * @property {string} authoritySeed
+ * @property {PublicKey} authorityOwner
+ * @property {PublicKey} newAuthorizedPubkey
+ * @property {StakeAuthorizationType} stakeAuthorizationType
+ */
+export type AuthorizeWithSeedStakeParams = {|
+  stakePubkey: PublicKey,
+  authorityBase: PublicKey,
+  authoritySeed: string,
+  authorityOwner: PublicKey,
+  newAuthorizedPubkey: PublicKey,
+  stakeAuthorizationType: StakeAuthorizationType,
+|}
+
+/**
+ * Split stake instruction params
+ * @typedef {Object} SplitStakeParams
+ * @property {PublicKey} stakePubkey
+ * @property {PublicKey} authorizedPubkey
+ * @property {PublicKey} splitStakePubkey
+ * @property {number} lamports
+ */
+export type SplitStakeParams = {|
+  stakePubkey: PublicKey,
+  authorizedPubkey: PublicKey,
+  splitStakePubkey: PublicKey,
+  lamports: number,
+|}
+
+/**
+ * Withdraw stake instruction params
+ * @typedef {Object} WithdrawStakeParams
+ * @property {PublicKey} stakePubkey
+ * @property {PublicKey} authorizedPubkey
+ * @property {PublicKey} toPubkey
+ * @property {number} lamports
+ */
+export type WithdrawStakeParams = {|
+  stakePubkey: PublicKey,
+  authorizedPubkey: PublicKey,
+  toPubkey: PublicKey,
+  lamports: number,
+|}
+
+/**
+ * Deactivate stake instruction params
+ * @typedef {Object} DeactivateStakeParams
+ * @property {PublicKey} stakePubkey
+ * @property {PublicKey} authorizedPubkey
+ */
+export type DeactivateStakeParams = {|
+  stakePubkey: PublicKey,
+  authorizedPubkey: PublicKey,
+|}
+
+/**
+ * An enumeration of valid stake InstructionType's
+ */
+export 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
+ */
+export class StakeInstruction {
+  /**
+   * Decode a stake instruction and retrieve the instruction type.
+   */
+  static decodeInstructionType(instruction: TransactionInstruction) {
+    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: TransactionInstruction): InitializeStakeParams {
+    this.checkProgramId(instruction.programId)
+    this.checkKeyLength(instruction.keys, 2)
+
+    const { authorized, lockup } = decodeData(
+      STAKE_INSTRUCTION_LAYOUTS.Initialize,
+      instruction.data
+    )
+
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      authorized: new Authorized(
+        new PublicKey(authorized.staker),
+        new PublicKey(authorized.withdrawer)
+      ),
+      lockup: new Lockup(lockup.unixTimestamp, lockup.epoch, new PublicKey(lockup.custodian)),
+    }
+  }
+
+  /**
+   * Decode a delegate stake instruction and retrieve the instruction params.
+   */
+  static decodeDelegate(instruction: TransactionInstruction): DelegateStakeParams {
+    this.checkProgramId(instruction.programId)
+    this.checkKeyLength(instruction.keys, 6)
+    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: TransactionInstruction): WithdrawStakeParams {
+    this.checkProgramId(instruction.programId)
+    this.checkKeyLength(instruction.keys, 5)
+    const { lamports } = 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: TransactionInstruction): DeactivateStakeParams {
+    this.checkProgramId(instruction.programId)
+    this.checkKeyLength(instruction.keys, 3)
+    decodeData(STAKE_INSTRUCTION_LAYOUTS.Deactivate, instruction.data)
+
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      authorizedPubkey: instruction.keys[2].pubkey,
+    }
+  }
+
+  /**
+   * @private
+   */
+  static checkProgramId(programId: PublicKey) {
+    if (!programId.equals(StakeProgram.programId)) {
+      throw new Error('invalid instruction; programId is not StakeProgram')
+    }
+  }
+
+  /**
+   * @private
+   */
+  static checkKeyLength(keys: Array<any>, expectedLength: number) {
+    if (keys.length < expectedLength) {
+      throw new Error(
+        `invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`
+      )
+    }
+  }
+}
+
+/**
+ * An enumeration of valid StakeAuthorizationLayout's
+ */
+export const StakeAuthorizationLayout = Object.freeze({
+  Staker: {
+    index: 0,
+  },
+  Withdrawer: {
+    index: 1,
+  },
+})
+
+/**
+ * Factory class for transactions to interact with the Stake program
+ */
+export class StakeProgram {
+  /**
+   * Public key that identifies the Stake program
+   */
+  static get programId(): PublicKey {
+    return new 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(): number {
+    return 200
+  }
+
+  /**
+   * Generate an Initialize instruction to add to a Stake Create transaction
+   */
+  static initialize(params: InitializeStakeParams): TransactionInstruction {
+    const { stakePubkey, authorized, lockup } = params
+    const type = STAKE_INSTRUCTION_LAYOUTS.Initialize
+    const data = 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_RENT_PUBKEY, isSigner: false, isWritable: false },
+      ],
+      programId: this.programId,
+      data,
+    }
+    return new 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: CreateStakeAccountWithSeedParams): Transaction {
+    const transaction = new Transaction()
+    transaction.add(
+      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: CreateStakeAccountParams): Transaction {
+    const transaction = new Transaction()
+    transaction.add(
+      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: DelegateStakeParams): Transaction {
+    const { stakePubkey, authorizedPubkey, votePubkey } = params
+
+    const type = STAKE_INSTRUCTION_LAYOUTS.Delegate
+    const data = encodeData(type)
+
+    return new Transaction().add({
+      keys: [
+        { pubkey: stakePubkey, isSigner: false, isWritable: true },
+        { pubkey: votePubkey, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+        {
+          pubkey: 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: WithdrawStakeParams): Transaction {
+    const { stakePubkey, authorizedPubkey, toPubkey, lamports } = params
+    const type = STAKE_INSTRUCTION_LAYOUTS.Withdraw
+    const data = encodeData(type, { lamports })
+
+    return new Transaction().add({
+      keys: [
+        { pubkey: stakePubkey, isSigner: false, isWritable: true },
+        { pubkey: toPubkey, isSigner: false, isWritable: true },
+        { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+        {
+          pubkey: 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: DeactivateStakeParams): Transaction {
+    const { stakePubkey, authorizedPubkey } = params
+    const type = STAKE_INSTRUCTION_LAYOUTS.Deactivate
+    const data = encodeData(type)
+
+    return new Transaction().add({
+      keys: [
+        { pubkey: stakePubkey, isSigner: false, isWritable: true },
+        { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+        { pubkey: authorizedPubkey, isSigner: true, isWritable: false },
+      ],
+      programId: this.programId,
+      data,
+    })
+  }
+}