@exodus/solana-api 2.4.0 → 2.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.4.0",
+  "version": "2.5.2",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -15,22 +15,19 @@
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
     "@exodus/asset-lib": "^3.7.1",
-    "@exodus/assets": "^8.0.74",
-    "@exodus/assets-base": "^8.0.157",
+    "@exodus/assets": "^8.0.85",
+    "@exodus/basic-utils": "^1.3.0",
     "@exodus/fetch": "^1.2.0",
     "@exodus/models": "^8.10.4",
     "@exodus/nfts-core": "^0.5.0",
     "@exodus/simple-retry": "^0.0.6",
-    "@exodus/solana-lib": "^1.6.0",
-    "@exodus/solana-web3.js": "1.31.0-exodus.5",
-    "@ungap/url-search-params": "^0.2.2",
-    "bignumber.js": "^9.0.1",
+    "@exodus/solana-lib": "^1.6.3",
+    "@exodus/solana-meta": "^1.0.2",
     "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"
   },
-  "gitHead": "301d6e9222b3c0828c73cea460c94c9bbce878e6"
+  "gitHead": "a7b27e4f299057c16dda446f006fa61a945a6cbf"
 }

package/src/account-state.js

@@ -1,9 +1,6 @@
-import assets from '@exodus/assets'
+import { asset, tokens } from '@exodus/solana-meta'
 import { AccountState } from '@exodus/models'
 
-const asset = assets.solana
-const solTokens = Object.values(assets).filter((asset) => asset.assetType === 'SOLANA_TOKEN')
-
 export class SolanaAccountState extends AccountState {
   static defaults = {
     cursor: '',
@@ -24,7 +21,7 @@ export class SolanaAccountState extends AccountState {
       accounts: {}, // stake accounts
     },
   }
-  static _tokens = [asset, ...solTokens] // deprecated - will be removed
+  static _tokens = [asset, ...tokens] // deprecated - will be removed
 
   static _postParse(data) {
     return { ...data, tokenBalances: {} }

package/src/api.js

@@ -15,7 +15,6 @@ import {
   SolanaWeb3Message,
   buildRawTransaction,
 } from '@exodus/solana-lib'
-import assets from '@exodus/assets'
 import assert from 'assert'
 import lodash from 'lodash'
 import urljoin from 'url-join'
@@ -30,7 +29,7 @@ const WS_ENDPOINT = 'wss://solana.a.exodus.io/ws'
 
 // Tokens + SOL api support
 export class Api {
-  constructor(rpcUrl, wsUrl) {
+  constructor({ rpcUrl, wsUrl, assets }) {
     this.setServer(rpcUrl)
     this.setWsEndpoint(wsUrl)
     this.setTokens(assets)
@@ -603,7 +602,7 @@ export class Api {
       const { pubkey, account } = entry
 
       const mint = lodash.get(account, 'data.parsed.info.mint')
-      const token = this.tokens[mint] || {
+      const token = this.getTokenByAddress(mint) || {
         name: 'unknown',
         ticker: 'UNKNOWN',
       }

package/src/connection.js

@@ -186,7 +186,8 @@ export class Connection {
         delete this.rpcQueue[id]
         debug(`ws timeout command: ${method} - ${JSON.stringify(params)} - ${id}`)
         reject(new Error('solana ws: reply timeout'))
-      }, TIMEOUT).unref()
+      }, TIMEOUT)
+      if (typeof this.rpcQueue[id].timeout.unref === 'function') this.rpcQueue[id].timeout.unref()
       this.ws.send(JSON.stringify({ jsonrpc: '2.0', method, params, id }))
     })
   }

package/src/index.js

@@ -1,10 +1,18 @@
+import { keyBy } from '@exodus/basic-utils'
+import { connectAssets } from '@exodus/assets'
+import assetsList from '@exodus/solana-meta'
+
 import { Api } from './api'
+
 export * from './api'
 export * from './tx-log'
 export * from './account-state'
-export * from './pay'
+
+// These are not the same asset objects as the wallet creates, so they should never be returned to the wallet.
+// Initially this may be violated by the Solana code until the first monitor tick updates assets with setTokens()
+const assets = connectAssets(keyBy(assetsList, (asset) => asset.name))
 
 // At some point we would like to exclude this export. Default export should be the whole asset "plugin" ready to be injected.
 // Clients should not call an specific server api directly.
-const serverApi = new Api()
+const serverApi = new Api({ assets })
 export default serverApi

package/src/pay/fetchTransaction.js

@@ -1,139 +0,0 @@
-// @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,4 +0,0 @@
-export * from './parseURL.js'
-export * from './prepareSendData.js'
-export * from './validateBeforePay'
-export * from './fetchTransaction'

package/src/pay/parseURL.js

@@ -1,117 +0,0 @@
-// @flow
-import { PublicKey } from '@exodus/solana-lib'
-import BigNumber from 'bignumber.js'
-import assets from '@exodus/assets'
-import URLSearchParams from '@ungap/url-search-params'
-import api from '..'
-
-const SOLANA_PROTOCOL = 'solana:'
-const HTTPS_PROTOCOL = 'https:'
-
-export class ParseURLError extends Error {
-  name = 'ParseURLError'
-}
-
-export type TransactionRequestURL = {
-  link: URL,
-  label?: string,
-  message?: string,
-}
-
-export type TransferRequestURL = {
-  recipient: string,
-  reference?: Array<string>,
-  amount?: string,
-  splToken?: string,
-  message?: string,
-  memo?: string,
-}
-
-export type ParsedURL = TransactionRequestURL | TransferRequestURL
-
-export function parseURL(url: string | URL): ParsedURL {
-  if (typeof url === 'string') {
-    if (url.length > 2048) throw new ParseURLError('length invalid')
-    url = new URL(url)
-  }
-  if (url.protocol !== SOLANA_PROTOCOL) throw new ParseURLError('protocol invalid')
-  if (!url.pathname) throw new ParseURLError('pathname missing')
-  return /[:%]/.test(url.pathname) ? parseTransactionRequestURL(url) : parseTransferRequestURL(url)
-}
-
-function parseTransactionRequestURL(url: URL): TransactionRequestURL {
-  const link = new URL(decodeURIComponent(url.pathname))
-  const searchParams = new URLSearchParams(url.search)
-  if (link.protocol !== HTTPS_PROTOCOL) throw new ParseURLError('link invalid')
-
-  const label = searchParams.get('label') || undefined
-  const message = searchParams.get('message') || undefined
-
-  return {
-    link,
-    label,
-    message,
-  }
-}
-
-function parseTransferRequestURL(url: URL): TransferRequestURL {
-  let recipient: PublicKey
-  try {
-    recipient = new PublicKey(url.pathname)
-  } catch (error) {
-    throw new Error('ParseURLError: recipient invalid')
-  }
-
-  const searchParams = new URLSearchParams(url.search)
-
-  let amount: BigNumber
-  const amountParam = searchParams.get('amount')
-  if (amountParam) {
-    if (!/^\d+(\.\d+)?$/.test(amountParam)) throw new Error('ParseURLError: amount invalid')
-    amount = new BigNumber(amountParam)
-    if (amount.isNaN()) throw new Error('ParseURLError: amount NaN')
-    if (amount.isNegative()) throw new Error('ParseURLError: amount negative')
-  }
-
-  let splToken: PublicKey
-  const splTokenParam = searchParams.get('spl-token')
-  if (splTokenParam) {
-    try {
-      splToken = new PublicKey(splTokenParam)
-    } catch (error) {
-      throw new ParseURLError('spl-token invalid')
-    }
-  }
-
-  let asset = assets.solana
-  if (splToken) {
-    if (!api.isTokenSupported(splToken))
-      throw new ParseURLError(`spl-token ${splToken} is not supported`)
-    asset = api.getTokenByAddress(splToken)
-  }
-
-  let reference: PublicKey[]
-  const referenceParams = searchParams.getAll('reference')
-  if (referenceParams.length) {
-    try {
-      reference = referenceParams.map((reference) => new PublicKey(reference))
-    } catch (error) {
-      throw new ParseURLError('reference invalid')
-    }
-  }
-
-  const label = searchParams.get('label') || undefined
-  const message = searchParams.get('message') || undefined
-  const memo = searchParams.get('memo') || undefined
-
-  return {
-    asset,
-    recipient: recipient.toString(),
-    amount: amount ? amount.toString(10) : undefined,
-    splToken: splToken ? splToken.toString() : undefined,
-    reference,
-    label,
-    message,
-    memo,
-  }
-}

package/src/pay/prepareSendData.js

@@ -1,26 +0,0 @@
-// @flow
-import assert from 'assert'
-
-import type { ParsedURL } from './parseURL'
-
-export function prepareSendData(parsedData: ParsedURL, { asset, feeAmount, walletAccount }) {
-  const { amount: amountStr, recipient, splToken, ...options } = parsedData
-
-  assert(amountStr, 'PrepareTxError: Missing amount')
-  assert(recipient, 'PrepareTxError: Missing recipient')
-
-  const amount = asset.currency.defaultUnit(amountStr)
-
-  return {
-    asset: asset.name,
-    baseAsset: asset.baseAsset,
-    customMintAddress: splToken,
-    feeAmount,
-    receiver: {
-      address: recipient,
-      amount,
-    },
-    walletAccount,
-    ...options,
-  }
-}

package/src/pay/validateBeforePay.js

@@ -1,37 +0,0 @@
-// @flow
-import api from '..'
-import NumberUnit from '@exodus/currency'
-
-export class ValidateError extends Error {
-  name = 'ValidateError'
-}
-
-type PaymentRequest = {
-  asset: Object,
-  senderInfo: Object,
-  feeAmount: NumberUnit,
-  recipient: string,
-  amount: number,
-  checkEnoughBalance?: boolean,
-}
-
-export async function validateBeforePay({
-  asset,
-  senderInfo,
-  amount,
-  feeAmount = 0,
-  recipient,
-  checkEnoughBalance = true,
-}: PaymentRequest) {
-  const isNative = asset.name === asset.baseAsset.name
-  const recipientInfo = await api.getAccountInfo(recipient)
-  if (!recipientInfo) throw new ValidateError(`recipient ${recipient} not found`)
-
-  if (checkEnoughBalance) {
-    const totalAmountMustPay = asset.currency.defaultUnit(amount).add(feeAmount)
-    const currentBalance = isNative ? senderInfo.balance : senderInfo.tokenBalances[asset.name]
-    if (totalAmountMustPay.gt(currentBalance)) throw new ValidateError(`insufficient funds`)
-  }
-
-  return true
-}