@exodus/solana-lib 1.2.9-build2 → 1.2.10

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.2.9-build2",
+  "version": "1.2.10",
   "description": "Exodus internal Solana low-level library",
-  "main": "lib/index.js",
+  "main": "src/index.js",
   "files": [
-    "lib/",
+    "src/",
     "!src/__tests__"
   ],
   "author": "Exodus",
@@ -21,5 +21,6 @@
     "bs58": "~4.0.1",
     "create-hash": "~1.1.3",
     "tweetnacl": "^1.0.3"
-  }
+  },
+  "gitHead": "9ea01d6b464b1a6a23e49f3634b9e661e755efc8"
 }

package/src/constants.js

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,57 @@
+// @flow
+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'
+
+export function getAddressFromPublicKey(publicKey: string | Buffer): string {
+  return bs58.encode(Buffer.from(publicKey, 'hex'))
+}
+
+export function getAddressFromPrivateKey(privateKey: string | Buffer): string {
+  return getAddressFromPublicKey(getPublicKey(privateKey))
+}
+
+export function isValidAddress(address: string): boolean {
+  try {
+    // assume base 58 encoding by default
+    const decoded = bs58.decode(address)
+    if (decoded.length !== 32) {
+      return false
+    }
+    const _bn = new BN(decoded)
+    if (_bn.byteLength() > 32) {
+      return false
+    }
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+// doc: https://spl.solana.com/associated-token-account (HACK: refactored to sync)
+export function findAssociatedTokenAddress(
+  walletAddress: string,
+  tokenMintAddress: string
+): string {
+  walletAddress = new PublicKey(walletAddress)
+  tokenMintAddress = new PublicKey(tokenMintAddress)
+  return PublicKey.findProgramAddress(
+    [walletAddress.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), tokenMintAddress.toBuffer()],
+    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/fee-data/index.js

@@ -0,0 +1 @@
+export { default as solana } from './solana'

package/src/fee-data/solana.js

@@ -0,0 +1,9 @@
+import { FeeData } from '@exodus/asset-lib'
+
+export default new FeeData(
+  {
+    fee: '0.000005 SOL',
+  },
+  'fee',
+  'solana'
+)

package/src/helpers/spl-token.js

@@ -0,0 +1,108 @@
+import assert from 'assert'
+import BN from 'bn.js'
+import * as BufferLayout from '@exodus/buffer-layout'
+import { Account, PublicKey, TransactionInstruction } from '../vendor'
+import * as Layout from '../vendor/utils/layout'
+
+// Extracted from https://github.com/ExodusMovement/solana-spl-token/blob/master/src/index.js#L263
+
+/**
+ * 64-bit value
+ */
+export class U64 extends BN {
+  /**
+   * Convert to Buffer representation
+   */
+  toBuffer(): typeof Buffer {
+    const a = super.toArray().reverse()
+    const b = Buffer.from(a)
+    if (b.length === 8) {
+      return b
+    }
+    assert(b.length < 8, 'u64 too large')
+
+    const zeroPad = Buffer.alloc(8)
+    b.copy(zeroPad)
+    return zeroPad
+  }
+
+  /**
+   * Construct a u64 from Buffer representation
+   */
+  static fromBuffer(buffer: typeof Buffer): U64 {
+    assert(buffer.length === 8, `Invalid buffer length: ${buffer.length}`)
+    return new U64(
+      [...buffer]
+        .reverse()
+        .map((i) => `00${i.toString(16)}`.slice(-2))
+        .join(''),
+      16
+    )
+  }
+}
+
+const u64 = U64 // alias
+
+/**
+ * An ERC20-like Token
+ */
+export class Token {
+  /**
+   * Construct a Transfer instruction
+   *
+   * @param programId SPL Token program account
+   * @param source Source account
+   * @param destination Destination account
+   * @param owner Owner of the source account
+   * @param multiSigners Signing accounts if `authority` is a multiSig
+   * @param amount Number of tokens to transfer
+   */
+  static createTransferInstruction(
+    programId: PublicKey,
+    source: PublicKey,
+    destination: PublicKey,
+    owner: PublicKey,
+    multiSigners: Array<Account>,
+    amount: number | u64
+  ): TransactionInstruction {
+    const dataLayout = BufferLayout.struct([
+      BufferLayout.u8('instruction'),
+      Layout.uint64('amount'),
+    ])
+
+    const data = Buffer.alloc(dataLayout.span)
+    dataLayout.encode(
+      {
+        instruction: 3, // Transfer instruction
+        amount: new U64(amount).toBuffer(),
+      },
+      data
+    )
+
+    let keys = [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: destination, isSigner: false, isWritable: true },
+    ]
+    if (multiSigners.length === 0) {
+      keys.push({
+        pubkey: owner,
+        isSigner: true,
+        isWritable: false,
+      })
+    } else {
+      keys.push({ pubkey: owner, isSigner: false, isWritable: false })
+      multiSigners.forEach((signer) =>
+        keys.push({
+          pubkey: signer.publicKey,
+          isSigner: true,
+          isWritable: false,
+        })
+      )
+    }
+    return new TransactionInstruction({
+      keys,
+      programId: programId,
+      data,
+    })
+  }
+}

package/src/helpers/tokenTransfer.js

@@ -0,0 +1,72 @@
+import { Token } from './spl-token'
+import { PublicKey, TransactionInstruction, SystemProgram, SYSVAR_RENT_PUBKEY } from '../vendor'
+import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants'
+import { findAssociatedTokenAddress } from '../encode'
+
+// https://github.com/paul-schaaf/spl-token-ui/blob/main/src/solana/token/associatedToken.ts#L59
+export const createAssociatedTokenAccount = (
+  senderAddress: string,
+  tokenMintAddress: string,
+  ownerAddress: string // destination SOL address
+) => {
+  const associatedTokenAccountPublicKey = new PublicKey(
+    findAssociatedTokenAddress(ownerAddress, tokenMintAddress)
+  )
+
+  const feePayerPublicKey = new PublicKey(senderAddress)
+  const ownerPublicKey = new PublicKey(ownerAddress)
+  const tokenMintPublicKey = new PublicKey(tokenMintAddress)
+
+  const ix = createIx(
+    feePayerPublicKey, // feePayer
+    associatedTokenAccountPublicKey,
+    ownerPublicKey,
+    tokenMintPublicKey
+  )
+
+  return ix // returns the instruction
+}
+
+function createIx(
+  funderPubkey: PublicKey,
+  associatedTokenAccountPublicKey: PublicKey,
+  ownerPublicKey: PublicKey,
+  tokenMintPublicKey: PublicKey
+) {
+  return new TransactionInstruction({
+    programId: SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID,
+    data: Buffer.from([]),
+    keys: [
+      { pubkey: funderPubkey, isSigner: true, isWritable: true },
+      {
+        pubkey: associatedTokenAccountPublicKey,
+        isSigner: false,
+        isWritable: true,
+      },
+      { pubkey: ownerPublicKey, isSigner: false, isWritable: false },
+      { pubkey: tokenMintPublicKey, isSigner: false, isWritable: false },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+    ],
+  })
+}
+
+// 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(to)
+  console.log(`destination token address: ${destinationPubkey.toBase58()}`)
+  const ownerAccountOrWalletPublicKey = new PublicKey(owner) // the only native SOL address
+
+  const transferIx = Token.createTransferInstruction(
+    TOKEN_PROGRAM_ID,
+    sourcePubkey,
+    destinationPubkey,
+    ownerAccountOrWalletPublicKey,
+    [],
+    amount
+  )
+
+  return transferIx
+}

package/src/index.js

@@ -0,0 +1,9 @@
+// @flow
+
+export * from './constants'
+export * from './encode'
+export * from './keypair'
+export * from './tx'
+export { StakeInstruction } from './vendor'
+export { default as tokens } from './tokens'
+export { default as Transaction } from './transaction'

package/src/keypair.js

@@ -0,0 +1,32 @@
+// @flow
+import nacl from 'tweetnacl'
+
+export function getKeyPairFromPrivateKey(privateKey: string | Buffer): Object {
+  const { publicKey, secretKey } = nacl.sign.keyPair.fromSeed(
+    Buffer.from(privateKey, 'hex').slice(0, 32)
+  )
+
+  return {
+    secretKey: Buffer.from(secretKey, 'hex'), // secretKey
+    publicKey: Buffer.from(publicKey, 'hex'),
+  }
+}
+
+export function getPublicKey(privateKey: string | Buffer): Buffer {
+  return getKeyPairFromPrivateKey(privateKey).publicKey
+}
+
+export function sign(data: Buffer, privateKey: string | Buffer): Buffer {
+  return Buffer.from(
+    nacl.sign.detached(data, getKeyPairFromPrivateKey(Buffer.from(privateKey, 'hex')).secretKey),
+    'hex'
+  )
+}
+
+export function verifySignature(
+  data: Buffer,
+  signature: Buffer,
+  publicKey: string | Buffer
+): boolean {
+  return nacl.sign.detached.verify(data, signature, Buffer.from(publicKey, 'hex'))
+}

package/src/tokens.js

@@ -0,0 +1,19 @@
+// adapted from https://github.com/project-serum/spl-token-wallet/blob/master/src/utils/tokens/names.js
+
+const TOKENS = [
+  {
+    mintAddress: 'SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt',
+    tokenName: 'serum',
+    tokenProperName: 'Serum',
+    tokenSymbol: 'SRM',
+  },
+  {
+    mintAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+    tokenName: 'usdcoin_solana',
+    tokenProperName: 'USD Coin Solana',
+    tokenSymbol: 'USDCSOL',
+  },
+  // ....
+]
+
+export default TOKENS

package/src/transaction.js

@@ -0,0 +1,292 @@
+// @flow
+import assert from 'assert'
+import bs58 from 'bs58'
+import { get } from 'lodash'
+
+import { getKeyPairFromPrivateKey } from './keypair'
+import { findAssociatedTokenAddress, createStakeAddress } from './encode'
+import {
+  createAssociatedTokenAccount,
+  createTokenTransferInstruction,
+} from './helpers/tokenTransfer'
+import {
+  PublicKey,
+  Account,
+  Transaction,
+  SystemProgram,
+  StakeProgram,
+  StakeInstruction,
+  Authorized,
+  Lockup,
+} from './vendor'
+import { SEED, STAKE_PROGRAM_ID } from './constants'
+import TOKENS from './tokens'
+
+class Tx {
+  constructor({
+    from,
+    to,
+    amount,
+    recentBlockhash,
+    // fee, // (Fee per Signature: 5000 lamports)
+    // Tokens related:
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive, // true when recipient balance !== 0
+    fromTokenAddresses, // sender token addresses
+  } = {}) {
+    assert(from, 'from is required')
+    assert(to, 'to is required')
+    assert(amount, 'amount is required')
+    assert(typeof amount === 'number', 'amount must be a number')
+    assert(recentBlockhash, 'recentBlockhash is required')
+    if (tokenName) {
+      assert(
+        typeof destinationAddressType !== 'undefined',
+        'destinationAddressType is required when sending tokens'
+      )
+      assert(
+        typeof isAssociatedTokenAccountActive !== 'undefined',
+        'isAssociatedTokenAccountActive is required when sending tokens'
+      ) // needed to create the recipient account
+      assert(Array.isArray(fromTokenAddresses), 'fromTokenAddresses Array is required')
+    }
+
+    const token = TOKENS.find(({ tokenName: name }) => name === tokenName)
+    this.txObj = {
+      from,
+      to,
+      amount,
+      recentBlockhash,
+      token,
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAddresses,
+    }
+
+    if (token) {
+      // TOKEN transfer tx
+      this.buildTokenTransaction(this.txObj)
+    } else {
+      // SOL tx
+      this.buildSOLtransaction(this.txObj)
+    }
+  }
+
+  buildSOLtransaction({ from, to, amount, recentBlockhash }) {
+    const txInstruction = SystemProgram.transfer({
+      fromPubkey: new PublicKey(from),
+      toPubkey: new PublicKey(to),
+      lamports: amount,
+    })
+
+    this.transaction = new Transaction({
+      instructions: [txInstruction],
+      recentBlockhash,
+    })
+  }
+
+  buildTokenTransaction({
+    from,
+    to,
+    amount,
+    recentBlockhash,
+    token,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
+  }) {
+    this.transaction = new Transaction({
+      recentBlockhash,
+    })
+    const isUnknown = destinationAddressType === null
+    const isSOLaddress = destinationAddressType === 'solana'
+    // crete account instruction
+    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
+    let amountToSend
+    for (let { ticker, tokenAccountAddress, balance } of fromTokenAddresses) {
+      // need to add more of this instruction until we reach the desired balance (amount) to send
+      assert(ticker === token.tokenSymbol, `Got unexpected ticker ${ticker}`)
+      if (amountLeft === 0) break
+
+      balance = Number(balance)
+      if (balance >= amountLeft) {
+        amountToSend = amountLeft
+        amountLeft = 0
+      } else {
+        amountToSend = balance // not enough balance
+        amountLeft -= amountToSend
+      }
+
+      const dest = isSOLaddress ? findAssociatedTokenAddress(to, token.mintAddress) : to
+      // add transfer token instruction
+      this.transaction.add(
+        createTokenTransferInstruction(from, tokenAccountAddress, dest, amountToSend)
+      )
+    }
+
+    assert(amountLeft === 0, `Not enough balance to send ${amount} ${token.tokenSymbol}`)
+  }
+
+  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)]
+
+    let transaction = tx
+    if (tx instanceof Tx) transaction = tx.transaction
+
+    transaction.sign(...signers)
+    if (!transaction.signature) {
+      throw new Error('!signature') // should never happen
+    }
+  }
+
+  serialize() {
+    const wireTransaction = this.transaction.serialize()
+    return wireTransaction.toString('base64')
+  }
+
+  static serialize(tx) {
+    let transaction = tx
+    if (tx instanceof Tx) transaction = tx.transaction
+    return transaction.serialize().toString('base64')
+  }
+
+  static decodeStakingTx(serialized: string) {
+    // as base64
+    const wireTransaction = Buffer.from(serialized, 'base64')
+    const tx = Transaction.from(wireTransaction) // Transaction instance
+
+    const txId = bs58.encode(tx.signature)
+
+    const stakingInstructions = tx.instructions.filter(
+      (ix) => ix.programId.toString() === STAKE_PROGRAM_ID.toString()
+    )
+    const isStakingTx = !!stakingInstructions.length
+
+    if (!isStakingTx) return null // normal transfer tx
+
+    const info = {
+      txId,
+      owner: tx.feePayer.toString(), // SOL sender
+    }
+    const txDetails = stakingInstructions.reduce((info, ix) => {
+      const type = StakeInstruction.decodeInstructionType(ix)
+      switch (type) {
+        case 'Delegate':
+          info.type = 'Delegate'
+          info.stakeAddress = get(ix, 'keys[0].pubkey', '').toString()
+          info.validator = get(ix, 'keys[1].pubkey', '').toString() // pool
+          return info
+
+        case 'Deactivate': // undelegate
+          info.type = 'Deactivate'
+          info.stakeAddress = get(ix, 'keys[0].pubkey', '').toString()
+          // TODO: could have multiple addresses undelegating
+          return info
+
+        case 'Withdraw':
+          info.type = 'Withdraw'
+          info.stakeAddress = get(ix, 'keys[0].pubkey', '').toString()
+          const { lamports, toPubkey } = StakeInstruction.decodeWithdraw(ix)
+          info.to = toPubkey.toString()
+          info.lamports = lamports.toString()
+          return info
+
+        default:
+          // skip unknown instruction type
+          return info
+      }
+    }, info)
+
+    return txDetails
+  }
+
+  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-and-sign-tx.js

@@ -0,0 +1,8 @@
+import { createUnsignedTx } from './create-unsigned-tx'
+import { signUnsignedTx } from './sign-unsigned-tx'
+import type { ParsedTransaction, SignedTransaction } from '@exodus/models/lib/types'
+
+export function createAndSignTx(input: ParsedTransaction, privateKey: Buffer): SignedTransaction {
+  const unsignedTx = createUnsignedTx(input)
+  return signUnsignedTx(unsignedTx, privateKey)
+}