@exodus/solana-api 2.1.0 → 2.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -20,16 +20,19 @@
     "@exodus/fetch": "^1.2.0",
     "@exodus/models": "^8.7.2",
     "@exodus/nfts-core": "^0.5.0",
-    "@exodus/solana-lib": "^1.4.0",
+    "@exodus/solana-lib": "^1.4.2",
+    "@exodus/solana-web3.js": "1.31.0-exodus.3",
     "@ungap/url-search-params": "^0.2.2",
+    "bignumber.js": "^9.0.1",
     "bn.js": "^4.11.0",
     "debug": "^4.1.1",
     "lodash": "^4.17.11",
+    "tweetnacl": "^1.0.3",
     "url-join": "4.0.0",
     "wretch": "^1.5.2"
   },
   "devDependencies": {
     "node-fetch": "~2.6.0"
   },
-  "gitHead": "6ffded97383f994c21ccaebb2703c32d48aa70c5"
+  "gitHead": "1da3192650571fda10b61596dbc2eaf7cc8f439d"
 }

package/src/api.js

@@ -136,7 +136,7 @@ export class Api {
     ])
   }
 
-  async getFee(): number {
+  async getFee(): Promise<number> {
     const result = await this.rpcCall('getRecentBlockhash', [
       { commitment: 'finalized', encoding: 'jsonParsed' },
     ])
@@ -238,8 +238,14 @@ export class Api {
     tokenAccountsByOwner: ?Array,
     { includeUnparsed = false } = {}
   ): Object {
-    let { fee, preBalances, postBalances, preTokenBalances, postTokenBalances, innerInstructions } =
-      txDetails.meta
+    let {
+      fee,
+      preBalances,
+      postBalances,
+      preTokenBalances,
+      postTokenBalances,
+      innerInstructions,
+    } = txDetails.meta
     preBalances = preBalances || []
     postBalances = postBalances || []
     preTokenBalances = preTokenBalances || []
@@ -584,7 +590,7 @@ export class Api {
     return tokensMint
   }
 
-  async getTokenAccountsByOwner(address: string, tokenTicker: ?string): Array {
+  async getTokenAccountsByOwner(address: string, tokenTicker: ?string): Promise<Array> {
     const { value: accountsList } = await this.rpcCall(
       'getTokenAccountsByOwner',
       [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
@@ -926,13 +932,16 @@ export class Api {
    * Simulate transaction and return side effects
    */
   simulateAndRetrieveSideEffects = async (
-    transactionMessage: SolanaWeb3Message,
-    publicKey: string
+    message: SolanaWeb3Message,
+    publicKey: string,
+    transactionMessage?: any // decompiled TransactionMessage
   ) => {
-    const { config, accountAddresses } = getTransactionSimulationParams(transactionMessage)
-    const signatures = new Array(transactionMessage.header.numRequiredSignatures || 1).fill(null)
+    const { config, accountAddresses } = getTransactionSimulationParams(
+      transactionMessage || message
+    )
+    const signatures = new Array(message.header.numRequiredSignatures || 1).fill(null)
     const encodedTransaction = buildRawTransaction(
-      transactionMessage.serialize(),
+      Buffer.from(message.serialize()),
       signatures
     ).toString('base64')
     const futureAccountsState = await this.simulateTransaction(encodedTransaction, config)

package/src/pay/fetchTransaction.js

@@ -0,0 +1,139 @@
+// @flow
+import nacl from 'tweetnacl'
+import { fetchival } from '@exodus/fetch'
+import ms from 'ms'
+import { SystemInstruction, Transaction, PublicKey } from '@exodus/solana-web3.js'
+import api from '..'
+import BigNumber from 'bignumber.js'
+import {
+  TOKEN_PROGRAM_ID,
+  decodeTokenProgramInstruction,
+  SYSTEM_PROGRAM_ID,
+} from '@exodus/solana-lib'
+
+export class FetchTransactionError extends Error {
+  name = 'FetchTransactionError'
+}
+
+export class ParseTransactionError extends Error {
+  name = 'ParseTransactionError'
+}
+
+const isTransferCheckedInstruction = (decodedInstruction) =>
+  decodedInstruction.type === 'transferChecked'
+const isTransferInstruction = (decodedInstruction) => decodedInstruction.type === 'transfer'
+const isSplAccount = (account) =>
+  account && account.owner === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+
+export async function fetchTransaction({
+  account,
+  link,
+  commitment,
+}: {
+  account: string,
+  link: string | URL,
+  commitment?: string,
+}) {
+  const response = await fetchival(String(link), {
+    mode: 'cors',
+    cache: 'no-cache',
+    credentials: 'omit',
+    timeout: ms('10s'),
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+  }).post({ account })
+  if (!response || !response.transaction) throw new FetchTransactionError('missing transaction')
+  const { transaction: txString } = response
+  if (typeof txString !== 'string') throw new FetchTransactionError('invalid transaction')
+  const transaction = Transaction.from(Buffer.from(txString, 'base64'))
+
+  const { signatures, feePayer, recentBlockhash } = transaction
+  if (signatures.length) {
+    if (!feePayer) throw new FetchTransactionError('missing fee payer')
+    if (!feePayer.equals(signatures[0].publicKey))
+      throw new FetchTransactionError('invalid fee payer')
+    if (!recentBlockhash) throw new FetchTransactionError('missing recent blockhash')
+
+    // A valid signature for everything except `account` must be provided.
+    const message = transaction.serializeMessage()
+    for (const { signature, publicKey } of signatures) {
+      if (signature) {
+        if (!nacl.sign.detached.verify(message, signature, publicKey.toBuffer()))
+          throw new FetchTransactionError('invalid signature')
+      } else if (publicKey.equals(new PublicKey(account))) {
+        // If the only signature expected is for `account`, ignore the recent blockhash in the transaction.
+        if (signatures.length === 1) {
+          transaction.recentBlockhash = await api.getRecentBlockHash(commitment)
+        }
+      } else {
+        throw new FetchTransactionError('missing signature')
+      }
+    }
+  } else {
+    // Ignore the fee payer and recent blockhash in the transaction and initialize them.
+    transaction.feePayer = account
+    transaction.recentBlockhash = await api.getRecentBlockHash(commitment)
+  }
+
+  return parseInstructions(transaction)
+}
+
+async function parseInstructions(transaction: Transaction) {
+  // Make a copy of the instructions we're going to mutate it.
+  const instructions = transaction.instructions.slice()
+
+  if (!instructions || !Array.isArray(instructions) || instructions.length !== 1)
+    throw new ParseTransactionError('Invalid transaction instructions')
+
+  // Transfer instruction must be the last instruction
+  const instruction = instructions.pop()
+  if (!instruction) throw new ParseTransactionError('missing transfer instruction')
+
+  const isTokenTransfer = instruction.programId.equals(TOKEN_PROGRAM_ID)
+  const isSolNativeTransfer = instruction.programId.equals(SYSTEM_PROGRAM_ID)
+
+  if (isTokenTransfer) {
+    const decodedInstruction = decodeTokenProgramInstruction(instruction)
+    if (
+      !isTransferCheckedInstruction(decodedInstruction) &&
+      !isTransferInstruction(decodedInstruction)
+    )
+      throw new ParseTransactionError('invalid token transfer')
+
+    const [, mint, destination, owner] = instruction.keys
+
+    const splToken = mint.pubkey.toBase58()
+    let asset
+    let recipient = destination.pubkey.toBase58()
+    if (splToken) {
+      if (!api.isTokenSupported(splToken))
+        throw new ParseTransactionError(`spl-token ${splToken} is not supported`)
+      asset = api.getTokenByAddress(splToken)
+
+      const account = await api.getAccountInfo(recipient)
+      if (isSplAccount(account)) recipient = account.data.parsed.info.owner
+    }
+
+    return {
+      amount: asset.currency
+        .baseUnit(new BigNumber(decodedInstruction.data.amount).toString())
+        .toDefaultString(),
+      decimals: decodedInstruction.data.decimals,
+      recipient,
+      sender: owner.pubkey.toBase58(),
+      splToken,
+      asset,
+    }
+  } else if (isSolNativeTransfer) {
+    const decodedTransaction = SystemInstruction.decodeTransfer(instruction)
+    return {
+      sender: decodedTransaction.fromPubkey.toString(),
+      amount: decodedTransaction.lamports.toString(),
+      recipient: decodedTransaction.toPubkey.toString(),
+    }
+  }
+
+  throw new Error('Invalid transfer instruction')
+}

package/src/pay/index.js

@@ -1,3 +1,4 @@
 export * from './parseURL.js'
 export * from './prepareSendData.js'
 export * from './validateBeforePay'
+export * from './fetchTransaction'