@exodus/solana-lib 1.2.8 → 1.2.9-build

package/src/transaction.js

@@ -1,240 +0,0 @@
-// @flow
-import assert from 'assert'
-
-import { getKeyPairFromPrivateKey } from './keypair'
-import { findAssociatedTokenAddress, createStakeAddress } from './encode'
-import {
-  createAssociatedTokenAccount,
-  createTokenTransferInstruction,
-} from './helpers/tokenTransfer'
-import {
-  PublicKey,
-  Account,
-  Transaction,
-  SystemProgram,
-  StakeProgram,
-  Authorized,
-  Lockup,
-} from './vendor'
-import { SEED } from './constants'
-import TOKENS from './tokens'
-import bs58 from 'bs58'
-
-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')
-  }
-
-  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

@@ -1,8 +0,0 @@
-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)
-}

package/src/tx/index.js

@@ -1,4 +0,0 @@
-export * from './sign-unsigned-tx'
-export * from './parse-unsigned-tx'
-export * from './create-unsigned-tx'
-export * from './create-and-sign-tx'

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

@@ -1,39 +0,0 @@
-import assets from '@exodus/assets'
-import type { UnsignedTransaction, ParsedTransaction } from '@exodus/models/lib/types'
-
-export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransaction {
-  const asset = assets.solana
-  const {
-    from,
-    to,
-    recentBlockhash,
-    tokenName,
-    destinationAddressType,
-    isAssociatedTokenAccountActive,
-    fromTokenAddresses,
-    method,
-    stakeAddresses,
-    seed,
-    pool,
-    ...txData
-  } = unsignedTx.txData
-
-  const amount = asset.currency.baseUnit(txData.amount)
-  return {
-    asset,
-    from: [from],
-    to,
-    amount,
-    recentBlockhash,
-    // token related
-    tokenName,
-    destinationAddressType,
-    isAssociatedTokenAccountActive,
-    fromTokenAddresses,
-    // staking related
-    method,
-    stakeAddresses,
-    seed,
-    pool,
-  }
-}

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

@@ -1,78 +0,0 @@
-import assets from '@exodus/assets'
-import type { UnsignedTransaction, SignedTransaction } from '@exodus/models/lib/types'
-import { Transaction } from '../'
-
-export function signUnsignedTx(
-  unsignedTx: UnsignedTransaction,
-  privateKey: Buffer
-): SignedTransaction {
-  const {
-    from,
-    to,
-    amount: unitAmount,
-    recentBlockhash,
-    // tokens related
-    tokenName,
-    destinationAddressType,
-    isAssociatedTokenAccountActive,
-    fromTokenAddresses,
-    // staking related
-    stakeAddresses,
-    method,
-    seed,
-    pool,
-  } = unsignedTx.txData
-
-  const asset = assets.solana
-
-  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 = Transaction.serialize(tx)
-  const txId = Transaction.getTxId(tx)
-
-  return { txId, rawTx }
-}

package/src/vendor/account.js

@@ -1,38 +0,0 @@
-// @flow
-import type { KeyPair } from 'tweetnacl'
-import { PublicKey } from './publickey'
-import { getKeyPairFromPrivateKey } from '../keypair'
-
-/**
- * An account key pair (public and secret keys).
- */
-export class Account {
-  _keypair: KeyPair
-
-  /**
-   * Create a new Account object
-   *
-   * @param secretKey Secret key for the account
-   */
-  constructor(secretKey: Buffer | Uint8Array | Array<number>) {
-    if (secretKey) {
-      this._keypair = getKeyPairFromPrivateKey(Buffer.from(secretKey, 'hex'))
-    } else {
-      throw new Error('Please provide a secretKey')
-    }
-  }
-
-  /**
-   * The public key for this account
-   */
-  get publicKey(): PublicKey {
-    return new PublicKey(this._keypair.publicKey)
-  }
-
-  /**
-   * The **unencrypted** secret key for this account
-   */
-  get secretKey(): Buffer {
-    return this._keypair.secretKey
-  }
-}

package/src/vendor/index.js

@@ -1,9 +0,0 @@
-export * from './account'
-export * from './instruction'
-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/instruction.js

@@ -1,46 +0,0 @@
-// @flow
-
-import * as BufferLayout from '@exodus/buffer-layout'
-
-import * as Layout from './utils/layout'
-
-/**
- * @typedef {Object} InstructionType
- * @property (index} The Instruction index (from solana upstream program)
- * @property (BufferLayout} The BufferLayout to use to build data
- */
-export type InstructionType = {|
-  index: number,
-  layout: typeof BufferLayout,
-|}
-
-/**
- * Populate a buffer of instruction data using an InstructionType
- */
-export function encodeData(type: InstructionType, fields: Object): Buffer {
-  const allocLength = type.layout.span >= 0 ? type.layout.span : Layout.getAlloc(type, fields)
-  const data = Buffer.alloc(allocLength)
-  const layoutFields = Object.assign({ instruction: type.index }, fields)
-  type.layout.encode(layoutFields, data)
-  return data
-}
-
-/**
- * Decode instruction data buffer using an InstructionType
- */
-export function decodeData(type: InstructionType, buffer: Buffer): Object {
-  let data
-  try {
-    data = type.layout.decode(buffer)
-  } catch (err) {
-    throw new Error('invalid instruction; ' + err)
-  }
-
-  if (data.instruction !== type.index) {
-    throw new Error(
-      `invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`
-    )
-  }
-
-  return data
-}

package/src/vendor/message.js

@@ -1,216 +0,0 @@
-// @flow
-
-import bs58 from 'bs58'
-import * as BufferLayout from '@exodus/buffer-layout'
-
-import { PublicKey } from './publickey'
-import type { Blockhash } from './utils/blockhash'
-import * as Layout from './utils/layout'
-import { PACKET_DATA_SIZE } from './transaction'
-import * as shortvec from './utils/shortvec-encoding'
-
-/**
- * The message header, identifying signed and read-only account
- *
- * @typedef {Object} MessageHeader
- * @property {number} numRequiredSignatures The number of signatures required for this message to be considered valid. The
- * signatures must match the first `numRequiredSignatures` of `accountKeys`.
- * @property {number} numReadonlySignedAccounts: The last `numReadonlySignedAccounts` of the signed keys are read-only accounts
- * @property {number} numReadonlyUnsignedAccounts The last `numReadonlySignedAccounts` of the unsigned keys are read-only accounts
- */
-export type MessageHeader = {
-  numRequiredSignatures: number,
-  numReadonlySignedAccounts: number,
-  numReadonlyUnsignedAccounts: number,
-}
-
-/**
- * An instruction to execute by a program
- *
- * @typedef {Object} CompiledInstruction
- * @property {number} programIdIndex Index into the transaction keys array indicating the program account that executes this instruction
- * @property {number[]} accounts Ordered indices into the transaction keys array indicating which accounts to pass to the program
- * @property {string} data The program input data encoded as base 58
- */
-export type CompiledInstruction = {
-  programIdIndex: number,
-  accounts: number[],
-  data: string,
-}
-
-/**
- * Message constructor arguments
- *
- * @typedef {Object} MessageArgs
- * @property {MessageHeader} header The message header, identifying signed and read-only `accountKeys`
- * @property {string[]} accounts All the account keys used by this transaction
- * @property {Blockhash} recentBlockhash The hash of a recent ledger block
- * @property {CompiledInstruction[]} instructions Instructions that will be executed in sequence and committed in one atomic transaction if all succeed.
- */
-type MessageArgs = {
-  header: MessageHeader,
-  accountKeys: string[],
-  recentBlockhash: Blockhash,
-  instructions: CompiledInstruction[],
-}
-
-const PUBKEY_LENGTH = 32
-
-/**
- * List of instructions to be processed atomically
- */
-export class Message {
-  header: MessageHeader
-  accountKeys: PublicKey[]
-  recentBlockhash: Blockhash
-  instructions: CompiledInstruction[]
-
-  constructor(args: MessageArgs) {
-    this.header = args.header
-    this.accountKeys = args.accountKeys.map((account) => new PublicKey(account))
-    this.recentBlockhash = args.recentBlockhash
-    this.instructions = args.instructions
-  }
-
-  isAccountWritable(index: number): boolean {
-    return (
-      index < this.header.numRequiredSignatures - this.header.numReadonlySignedAccounts ||
-      (index >= this.header.numRequiredSignatures &&
-        index < this.accountKeys.length - this.header.numReadonlyUnsignedAccounts)
-    )
-  }
-
-  findSignerIndex(signer: PublicKey): number {
-    const index = this.accountKeys.findIndex((accountKey) => {
-      return accountKey.equals(signer)
-    })
-    if (index < 0) {
-      throw new Error(`unknown signer: ${signer.toString()}`)
-    }
-    return index
-  }
-
-  serialize(): Buffer {
-    const numKeys = this.accountKeys.length
-
-    let keyCount = []
-    shortvec.encodeLength(keyCount, numKeys)
-
-    const instructions = this.instructions.map((instruction) => {
-      const { accounts, programIdIndex } = instruction
-      const data = bs58.decode(instruction.data)
-
-      let keyIndicesCount = []
-      shortvec.encodeLength(keyIndicesCount, accounts.length)
-
-      let dataCount = []
-      shortvec.encodeLength(dataCount, data.length)
-
-      return {
-        programIdIndex,
-        keyIndicesCount: Buffer.from(keyIndicesCount),
-        keyIndices: Buffer.from(accounts),
-        dataLength: Buffer.from(dataCount),
-        data,
-      }
-    })
-
-    let instructionCount = []
-    shortvec.encodeLength(instructionCount, instructions.length)
-    let instructionBuffer = Buffer.alloc(PACKET_DATA_SIZE)
-    Buffer.from(instructionCount).copy(instructionBuffer)
-    let instructionBufferLength = instructionCount.length
-
-    instructions.forEach((instruction) => {
-      const instructionLayout = BufferLayout.struct([
-        BufferLayout.u8('programIdIndex'),
-
-        BufferLayout.blob(instruction.keyIndicesCount.length, 'keyIndicesCount'),
-        BufferLayout.seq(BufferLayout.u8('keyIndex'), instruction.keyIndices.length, 'keyIndices'),
-        BufferLayout.blob(instruction.dataLength.length, 'dataLength'),
-        BufferLayout.seq(BufferLayout.u8('userdatum'), instruction.data.length, 'data'),
-      ])
-      const length = instructionLayout.encode(
-        instruction,
-        instructionBuffer,
-        instructionBufferLength
-      )
-      instructionBufferLength += length
-    })
-    instructionBuffer = instructionBuffer.slice(0, instructionBufferLength)
-
-    const signDataLayout = BufferLayout.struct([
-      BufferLayout.blob(1, 'numRequiredSignatures'),
-      BufferLayout.blob(1, 'numReadonlySignedAccounts'),
-      BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'),
-      BufferLayout.blob(keyCount.length, 'keyCount'),
-      BufferLayout.seq(Layout.publicKey('key'), numKeys, 'keys'),
-      Layout.publicKey('recentBlockhash'),
-    ])
-
-    const transaction = {
-      numRequiredSignatures: Buffer.from([this.header.numRequiredSignatures]),
-      numReadonlySignedAccounts: Buffer.from([this.header.numReadonlySignedAccounts]),
-      numReadonlyUnsignedAccounts: Buffer.from([this.header.numReadonlyUnsignedAccounts]),
-      keyCount: Buffer.from(keyCount),
-      keys: this.accountKeys.map((key) => key.toBuffer()),
-      recentBlockhash: bs58.decode(this.recentBlockhash),
-    }
-
-    let signData = Buffer.alloc(2048)
-    const length = signDataLayout.encode(transaction, signData)
-    instructionBuffer.copy(signData, length)
-    return signData.slice(0, length + instructionBuffer.length)
-  }
-
-  /**
-   * Decode a compiled message into a Message object.
-   */
-  static from(buffer: Buffer | Uint8Array | Array<number>): Message {
-    // Slice up wire data
-    let byteArray = [...buffer]
-
-    const numRequiredSignatures = byteArray.shift()
-    const numReadonlySignedAccounts = byteArray.shift()
-    const numReadonlyUnsignedAccounts = byteArray.shift()
-
-    const accountCount = shortvec.decodeLength(byteArray)
-    let accountKeys = []
-    for (let i = 0; i < accountCount; i++) {
-      const account = byteArray.slice(0, PUBKEY_LENGTH)
-      byteArray = byteArray.slice(PUBKEY_LENGTH)
-      accountKeys.push(bs58.encode(Buffer.from(account)))
-    }
-
-    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH)
-    byteArray = byteArray.slice(PUBKEY_LENGTH)
-
-    const instructionCount = shortvec.decodeLength(byteArray)
-    let instructions = []
-    for (let i = 0; i < instructionCount; i++) {
-      let instruction = {}
-      instruction.programIdIndex = byteArray.shift()
-      const accountCount = shortvec.decodeLength(byteArray)
-      instruction.accounts = byteArray.slice(0, accountCount)
-      byteArray = byteArray.slice(accountCount)
-      const dataLength = shortvec.decodeLength(byteArray)
-      const data = byteArray.slice(0, dataLength)
-      instruction.data = bs58.encode(Buffer.from(data))
-      byteArray = byteArray.slice(dataLength)
-      instructions.push(instruction)
-    }
-
-    const messageArgs = {
-      header: {
-        numRequiredSignatures,
-        numReadonlySignedAccounts,
-        numReadonlyUnsignedAccounts,
-      },
-      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
-      accountKeys,
-      instructions,
-    }
-
-    return new Message(messageArgs)
-  }
-}