@exodus/solana-lib 1.2.4 → 1.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.2.4",
+  "version": "1.2.7",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@exodus/asset-lib": "^3.4.3",
-    "@exodus/assets": "^8.0.0",
+    "@exodus/assets": "^8.0.2",
     "@exodus/buffer-layout": "^1.2.0-exodus1",
     "@exodus/models": "^8.4.0",
     "bn.js": "~4.11.0",
@@ -22,5 +22,5 @@
     "create-hash": "~1.1.3",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "f5a2d444a2789ca118671566f32805dba061ce5a"
+  "gitHead": "892c55db784616256e065a2c931a5e5611f5404f"
 }

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/helpers/tokenTransfer.js

@@ -52,17 +52,11 @@ function createIx(
   })
 }
 
-// https://github.com/paul-schaaf/spl-token-ui/blob/main/src/solana/token/editing.ts#L207
-export const createTokenTransferInstruction = (
-  owner,
-  fromTokenAddress,
-  tokenMintAddress,
-  to,
-  amount
-) => {
+// https://github.com/paul-schaaf/spl-token-ui/blob/main/src/solana/token/editing.ts#L211
+export const createTokenTransferInstruction = (owner, fromTokenAddress, to, amount) => {
   const sourcePubkey = new PublicKey(fromTokenAddress) // the token ADDRESS needed!
-  const destinationPubkey = new PublicKey(findAssociatedTokenAddress(to, tokenMintAddress))
-  console.log(`destination associatedTokenAddress: ${destinationPubkey.toBase58()}`)
+  const destinationPubkey = new PublicKey(to)
+  console.log(`destination token address: ${destinationPubkey.toBase58()}`)
   const ownerAccountOrWalletPublicKey = new PublicKey(owner) // the only native SOL address
 
   const transferIx = Token.createTransferInstruction(

package/src/tokens.js

@@ -1,26 +1,19 @@
-// reference https://github.com/project-serum/spl-token-wallet/blob/master/src/utils/tokens/names.js
+// adapted from https://github.com/project-serum/spl-token-wallet/blob/master/src/utils/tokens/names.js
 
 const TOKENS = [
   {
     mintAddress: 'SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt',
-    tokenName: 'Serum',
+    tokenName: 'serum',
+    tokenProperName: 'Serum',
     tokenSymbol: 'SRM',
   },
   {
-    tokenSymbol: 'BTC',
-    mintAddress: '9n4nbM75f5Ui33ZbPYXn59EwSgE8CGsHtAeTH5YFeJ9E',
-    tokenName: 'Wrapped Bitcoin',
-    icon:
-      'https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/bitcoin/info/logo.png',
-  },
-  {
-    tokenSymbol: 'USDC',
     mintAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-    tokenName: 'USD Coin',
-    icon:
-      'https://raw.githubusercontent.com/trustwallet/assets/f3ffd0b9ae2165336279ce2f8db1981a55ce30f8/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png',
+    tokenName: 'usdcoin_solana',
+    tokenProperName: 'USD Coin Solana',
+    tokenSymbol: 'USDC Solana',
   },
-  // ... TODO: do we want to add decimals for every token? (Serum SRM is 6)
+  // ....
 ]
 
 export default TOKENS

package/src/transaction.js

@@ -2,11 +2,21 @@
 import assert from 'assert'
 
 import { getKeyPairFromPrivateKey } from './keypair'
+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'
 
@@ -18,7 +28,8 @@ class Tx {
     recentBlockhash,
     // fee, // (Fee per Signature: 5000 lamports)
     // Tokens related:
-    tokenTicker,
+    tokenName,
+    destinationAddressType,
     isAssociatedTokenAccountActive, // true when recipient balance !== 0
     fromTokenAddresses, // sender token addresses
   } = {}) {
@@ -27,7 +38,11 @@ class Tx {
     assert(amount, 'amount is required')
     assert(typeof amount === 'number', 'amount must be a number')
     assert(recentBlockhash, 'recentBlockhash is required')
-    if (tokenTicker) {
+    if (tokenName) {
+      assert(
+        typeof destinationAddressType !== 'undefined',
+        'destinationAddressType is required when sending tokens'
+      )
       assert(
         typeof isAssociatedTokenAccountActive !== 'undefined',
         'isAssociatedTokenAccountActive is required when sending tokens'
@@ -35,13 +50,14 @@ class Tx {
       assert(Array.isArray(fromTokenAddresses), 'fromTokenAddresses Array is required')
     }
 
-    const token = TOKENS.find(({ tokenSymbol }) => tokenSymbol === tokenTicker)
+    const token = TOKENS.find(({ tokenName: name }) => name === tokenName)
     this.txObj = {
       from,
       to,
       amount,
       recentBlockhash,
       token,
+      destinationAddressType,
       isAssociatedTokenAccountActive,
       fromTokenAddresses,
     }
@@ -74,14 +90,18 @@ class Tx {
     amount,
     recentBlockhash,
     token,
+    destinationAddressType,
     isAssociatedTokenAccountActive,
     fromTokenAddresses,
   }) {
     this.transaction = new Transaction({
       recentBlockhash,
     })
+    const isUnknown = destinationAddressType === null
+    const isSOLaddress = destinationAddressType === 'solana'
     // crete account instruction
-    if (!isAssociatedTokenAccountActive)
+    if (isUnknown) throw new Error('Destination SOL balance cannot be zero (address not active)') // cannot initialize without knowing the owner
+    if (isSOLaddress && !isAssociatedTokenAccountActive)
       this.transaction.add(createAssociatedTokenAccount(from, token.mintAddress, to))
 
     let amountLeft = amount
@@ -100,28 +120,47 @@ class Tx {
         amountLeft -= amountToSend
       }
 
+      const dest = isSOLaddress ? findAssociatedTokenAddress(to, token.mintAddress) : to
       // add transfer token instruction
       this.transaction.add(
-        createTokenTransferInstruction(
-          from,
-          tokenAccountAddress,
-          token.mintAddress,
-          to,
-          amountToSend
-        )
+        createTokenTransferInstruction(from, tokenAccountAddress, dest, amountToSend)
       )
     }
 
     assert(amountLeft === 0, `Not enough balance to send ${amount} ${token.tokenSymbol}`)
   }
 
-  static sign(tx: Tx, privateKey: Buffer | string) {
+  static createStakeAccountTransaction({ address, amount, seed = SEED, recentBlockhash }) {
+    const fromPubkey = new PublicKey(address)
+    const stakeAddress = createStakeAddress(address, seed)
+    const stakePublicKey = new PublicKey(stakeAddress)
+
+    const authorized = new Authorized(fromPubkey, fromPubkey) // staker, withdrawer
+    const lockup = new Lockup(0, 0, fromPubkey) // no lockup
+
+    const transaction = StakeProgram.createAccountWithSeed({
+      fromPubkey,
+      stakePubkey: stakePublicKey,
+      basePubkey: fromPubkey,
+      seed,
+      authorized,
+      lockup,
+      lamports: amount, // number
+    })
+    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
     }
   }
@@ -131,6 +170,12 @@ 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')

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

@@ -6,6 +6,11 @@ export function createUnsignedTx({
   to,
   amount,
   recentBlockhash,
+  // Tokens related:
+  tokenName,
+  destinationAddressType,
+  isAssociatedTokenAccountActive, // true when recipient balance !== 0
+  fromTokenAddresses, // sender token addresses
 }: ParsedTransaction): UnsignedTransaction {
   return {
     txData: {
@@ -13,6 +18,11 @@ export function createUnsignedTx({
       to,
       amount: amount.toBase().toNumber(),
       recentBlockhash,
+      // Tokens related:
+      tokenName,
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAddresses,
     },
     txMeta: {
       assetName: asset.name,

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

@@ -3,7 +3,16 @@ import type { UnsignedTransaction, ParsedTransaction } from '@exodus/models/lib/
 
 export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransaction {
   const asset = assets.solana
-  const { from, to, recentBlockhash, ...txData } = unsignedTx.txData
+  const {
+    from,
+    to,
+    recentBlockhash,
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
+    ...txData
+  } = unsignedTx.txData
 
   const amount = asset.currency.baseUnit(txData.amount)
   return {
@@ -12,5 +21,10 @@ export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransact
     to,
     amount,
     recentBlockhash,
+    // token related
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
   }
 }

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

@@ -6,7 +6,16 @@ export function signUnsignedTx(
   unsignedTx: UnsignedTransaction,
   privateKey: Buffer
 ): SignedTransaction {
-  const { from, to, amount, recentBlockhash } = unsignedTx.txData
+  const {
+    from,
+    to,
+    amount,
+    recentBlockhash,
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
+  } = unsignedTx.txData
 
   const asset = assets.solana
   const tx = new Transaction({
@@ -14,6 +23,10 @@ export function signUnsignedTx(
     to,
     amount: asset.currency.baseUnit(amount).toNumber(),
     recentBlockhash,
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
   })
 
   // sign plain tx

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,675 @@
+// @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 an authorize stake instruction and retrieve the instruction params.
+   */
+  static decodeAuthorize(instruction: TransactionInstruction): AuthorizeStakeParams {
+    this.checkProgramId(instruction.programId)
+    this.checkKeyLength(instruction.keys, 3)
+    const { newAuthorized, stakeAuthorizationType } = decodeData(
+      STAKE_INSTRUCTION_LAYOUTS.Authorize,
+      instruction.data
+    )
+
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      authorizedPubkey: instruction.keys[2].pubkey,
+      newAuthorizedPubkey: new PublicKey(newAuthorized),
+      stakeAuthorizationType: {
+        index: stakeAuthorizationType,
+      },
+    }
+  }
+
+  /**
+   * Decode an authorize-with-seed stake instruction and retrieve the instruction params.
+   */
+  static decodeAuthorizeWithSeed(
+    instruction: TransactionInstruction
+  ): AuthorizeWithSeedStakeParams {
+    this.checkProgramId(instruction.programId)
+    this.checkKeyLength(instruction.keys, 2)
+    const { newAuthorized, stakeAuthorizationType, authoritySeed, authorityOwner } = decodeData(
+      STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed,
+      instruction.data
+    )
+
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      authorityBase: instruction.keys[1].pubkey,
+      authoritySeed: authoritySeed,
+      authorityOwner: new PublicKey(authorityOwner),
+      newAuthorizedPubkey: new PublicKey(newAuthorized),
+      stakeAuthorizationType: {
+        index: stakeAuthorizationType,
+      },
+    }
+  }
+
+  /**
+   * Decode a split stake instruction and retrieve the instruction params.
+   */
+  static decodeSplit(instruction: TransactionInstruction): SplitStakeParams {
+    this.checkProgramId(instruction.programId)
+    this.checkKeyLength(instruction.keys, 3)
+    const { lamports } = decodeData(STAKE_INSTRUCTION_LAYOUTS.Split, instruction.data)
+
+    return {
+      stakePubkey: instruction.keys[0].pubkey,
+      splitStakePubkey: instruction.keys[1].pubkey,
+      authorizedPubkey: instruction.keys[2].pubkey,
+      lamports,
+    }
+  }
+
+  /**
+   * 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 authorizes a new PublicKey as Staker
+   * or Withdrawer on the Stake account.
+   */
+  static authorize(params: AuthorizeStakeParams): Transaction {
+    const { stakePubkey, authorizedPubkey, newAuthorizedPubkey, stakeAuthorizationType } = params
+
+    const type = STAKE_INSTRUCTION_LAYOUTS.Authorize
+    const data = encodeData(type, {
+      newAuthorized: newAuthorizedPubkey.toBuffer(),
+      stakeAuthorizationType: stakeAuthorizationType.index,
+    })
+
+    return new Transaction().add({
+      keys: [
+        { pubkey: stakePubkey, isSigner: false, isWritable: true },
+        { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: true },
+        { pubkey: authorizedPubkey, isSigner: true, isWritable: false },
+      ],
+      programId: this.programId,
+      data,
+    })
+  }
+
+  /**
+   * Generate a Transaction that authorizes a new PublicKey as Staker
+   * or Withdrawer on the Stake account.
+   */
+  static authorizeWithSeed(params: AuthorizeWithSeedStakeParams): Transaction {
+    const {
+      stakePubkey,
+      authorityBase,
+      authoritySeed,
+      authorityOwner,
+      newAuthorizedPubkey,
+      stakeAuthorizationType,
+    } = params
+
+    const type = STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed
+    const data = encodeData(type, {
+      newAuthorized: newAuthorizedPubkey.toBuffer(),
+      stakeAuthorizationType: stakeAuthorizationType.index,
+      authoritySeed: authoritySeed,
+      authorityOwner: authorityOwner.toBuffer(),
+    })
+
+    return new Transaction().add({
+      keys: [
+        { pubkey: stakePubkey, isSigner: false, isWritable: true },
+        { pubkey: authorityBase, isSigner: true, isWritable: false },
+      ],
+      programId: this.programId,
+      data,
+    })
+  }
+
+  /**
+   * Generate a Transaction that splits Stake tokens into another stake account
+   */
+  static split(params: SplitStakeParams): Transaction {
+    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({
+      keys: [
+        { pubkey: stakePubkey, isSigner: false, isWritable: true },
+        { pubkey: splitStakePubkey, isSigner: false, isWritable: true },
+        { 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,
+    })
+  }
+}

package/src/vendor/transaction.js

@@ -316,7 +316,9 @@ export class Transaction {
     })
 
     if (numRequiredSignatures !== this.signatures.length) {
-      throw new Error('missing signer(s)')
+      throw new Error(
+        `missing signer(s) - required signatures: ${numRequiredSignatures}, got ${this.signatures.length}`
+      )
     }
 
     const accountKeys = signedKeys.concat(unsignedKeys)