@exodus/solana-api 2.5.16 → 2.5.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.16",
+  "version": "2.5.17",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -16,14 +16,14 @@
   },
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
-    "@exodus/asset-lib": "^3.7.1",
-    "@exodus/assets": "^8.0.85",
-    "@exodus/basic-utils": "^1.3.0",
+    "@exodus/asset-lib": "^4.0.0",
+    "@exodus/assets": "^9.0.1",
+    "@exodus/basic-utils": "^2.1.0",
     "@exodus/fetch": "^1.2.0",
-    "@exodus/models": "^8.10.4",
+    "@exodus/models": "^10.1.0",
     "@exodus/nfts-core": "^0.5.0",
     "@exodus/simple-retry": "^0.0.6",
-    "@exodus/solana-lib": "^1.6.7",
+    "@exodus/solana-lib": "^1.6.8",
     "@exodus/solana-meta": "^1.0.3",
     "bn.js": "^4.11.0",
     "debug": "^4.1.1",
@@ -31,5 +31,8 @@
     "url-join": "4.0.0",
     "wretch": "^1.5.2"
   },
-  "gitHead": "9ec7084bcdfe14f1c6f11df393351885773046a6"
+  "devDependencies": {
+    "@exodus/assets-testing": "file:../../../__testing__"
+  },
+  "gitHead": "846ed76714355879216f43c6be8ec2b072169635"
 }

package/src/api.js

@@ -1,4 +1,3 @@
-// @flow
 import BN from 'bn.js'
 import createApi from '@exodus/asset-json-rpc'
 import { retry } from '@exodus/simple-retry'
@@ -12,13 +11,12 @@ import {
   TOKEN_PROGRAM_ID,
   SOL_DECIMAL,
   computeBalance,
-  SolanaWeb3Message,
   buildRawTransaction,
 } from '@exodus/solana-lib'
 import assert from 'assert'
 import lodash from 'lodash'
 import urljoin from 'url-join'
-import wretch, { Wretcher } from 'wretch'
+import wretch from 'wretch'
 import { magicEden } from '@exodus/nfts-core'
 import { Connection } from './connection'
 
@@ -51,7 +49,7 @@ export class Api {
     this.tokens = new Map(Object.values(solTokens).map((v) => [v.mintAddress, v]))
   }
 
-  request(path, contentType = 'application/json'): Wretcher {
+  request(path, contentType = 'application/json') {
     return wretch(urljoin(this.rpcUrl, path)).headers({
       'Content-type': contentType,
     })
@@ -101,25 +99,25 @@ export class Api {
     return this.api.post({ method, params })
   }
 
-  getTokenByAddress(mint: string) {
+  getTokenByAddress(mint) {
     return this.tokens.get(mint)
   }
 
-  isTokenSupported(mint: string) {
+  isTokenSupported(mint) {
     return this.tokens.has(mint)
   }
 
-  async getEpochInfo(): number {
+  async getEpochInfo() {
     const { epoch } = await this.rpcCall('getEpochInfo')
     return Number(epoch)
   }
 
-  async getStakeActivation(address): string {
+  async getStakeActivation(address) {
     const { state } = await this.rpcCall('getStakeActivation', [address])
     return state
   }
 
-  async getRecentBlockHash(commitment?: string): Promise<string> {
+  async getRecentBlockHash(commitment?) {
     const result = await this.rpcCall(
       'getRecentBlockhash',
       [{ commitment: commitment || 'finalized', encoding: 'jsonParsed' }],
@@ -129,33 +127,33 @@ export class Api {
   }
 
   // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
-  async getTransactionById(id: string) {
+  async getTransactionById(id) {
     return this.rpcCall('getTransaction', [
       id,
       { encoding: 'jsonParsed', maxSupportedTransactionVersion: 0 },
     ])
   }
 
-  async getFee(): Promise<number> {
+  async getFee() {
     const result = await this.rpcCall('getRecentBlockhash', [
       { commitment: 'finalized', encoding: 'jsonParsed' },
     ])
     return lodash.get(result, 'value.feeCalculator.lamportsPerSignature')
   }
 
-  async getBalance(address: string): number {
+  async getBalance(address) {
     const result = await this.rpcCall('getBalance', [address, { encoding: 'jsonParsed' }], {
       address,
     })
     return lodash.get(result, 'value', 0)
   }
 
-  async getBlockTime(slot: number) {
+  async getBlockTime(slot) {
     // might result in error if executed on a validator with partial ledger (https://github.com/solana-labs/solana/issues/12413)
     return this.rpcCall('getBlockTime', [slot])
   }
 
-  async getConfirmedSignaturesForAddress(address: string, { until, before, limit } = {}): any {
+  async getConfirmedSignaturesForAddress(address, { until, before, limit } = {}) {
     until = until || undefined
     return this.rpcCall('getSignaturesForAddress', [address, { until, before, limit }], { address })
   }
@@ -163,10 +161,7 @@ export class Api {
   /**
    * Get transactions from an address
    */
-  async getTransactions(
-    address: string,
-    { cursor, before, limit, includeUnparsed = false } = {}
-  ): any {
+  async getTransactions(address, { cursor, before, limit, includeUnparsed = false } = {}) {
     let transactions = []
     // cursor is a txHash
 
@@ -233,11 +228,11 @@ export class Api {
   }
 
   parseTransaction(
-    ownerAddress: string,
-    txDetails: Object,
-    tokenAccountsByOwner: ?Array,
+    ownerAddress,
+    txDetails,
+    tokenAccountsByOwner,
     { includeUnparsed = false } = {}
-  ): Object {
+  ) {
     let {
       fee,
       preBalances,
@@ -563,7 +558,7 @@ export class Api {
     }
   }
 
-  async getSupply(mintAddress: string): string {
+  async getSupply(mintAddress) {
     const result = await this.rpcCall('getTokenSupply', [mintAddress])
     return lodash.get(result, 'value.amount')
   }
@@ -590,7 +585,7 @@ export class Api {
     return tokensMint
   }
 
-  async getTokenAccountsByOwner(address: string, tokenTicker: ?string): Promise<Array> {
+  async getTokenAccountsByOwner(address, tokenTicker) {
     const { value: accountsList } = await this.rpcCall(
       'getTokenAccountsByOwner',
       [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
@@ -637,7 +632,7 @@ export class Api {
     return tokensBalance
   }
 
-  async isAssociatedTokenAccountActive(tokenAddress: string) {
+  async isAssociatedTokenAccountActive(tokenAddress) {
     // Returns the token balance of an SPL Token account.
     try {
       await this.rpcCall('getTokenAccountBalance', [tokenAddress])
@@ -648,40 +643,40 @@ export class Api {
   }
 
   // Returns account balance of a SPL Token account.
-  async getTokenBalance(tokenAddress: string) {
+  async getTokenBalance(tokenAddress) {
     const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress])
     return lodash.get(result, 'value.amount')
   }
 
-  async getAccountInfo(address: string) {
+  async getAccountInfo(address, encoding = 'jsonParsed') {
     const { value } = await this.rpcCall(
       'getAccountInfo',
-      [address, { encoding: 'jsonParsed', commitment: 'single' }],
+      [address, { encoding, commitment: 'single' }],
       { address }
     )
     return value
   }
 
-  async isSpl(address: string) {
+  async isSpl(address) {
     const { owner } = await this.getAccountInfo(address)
     return owner === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
   }
 
-  async getMetaplexMetadata(tokenMintAddress: string) {
+  async getMetaplexMetadata(tokenMintAddress) {
     const metaplexPDA = getMetadataAccount(tokenMintAddress)
-    const res = await this.getAccountInfo(metaplexPDA)
+    const res = await this.getAccountInfo(metaplexPDA, 'base64')
     const data = lodash.get(res, 'data[0]')
     if (!data) return null
 
     return deserializeMetaplexMetadata(Buffer.from(data, 'base64'))
   }
 
-  async getDecimals(tokenMintAddress: string) {
+  async getDecimals(tokenMintAddress) {
     const result = await this.rpcCall('getTokenSupply', [tokenMintAddress])
     return lodash.get(result, 'value.decimals', null)
   }
 
-  async getAddressType(address: string) {
+  async getAddressType(address) {
     // solana, token or null (unknown), meaning address has never been initialized
     const value = await this.getAccountInfo(address)
     if (value === null) return null
@@ -699,7 +694,7 @@ export class Api {
       : null
   }
 
-  async getTokenAddressOwner(address: string) {
+  async getTokenAddressOwner(address) {
     const value = await this.getAccountInfo(address)
     const owner = lodash.get(value, 'data.parsed.info.owner', null)
     return owner
@@ -711,17 +706,17 @@ export class Api {
     return mintAddress
   }
 
-  async isTokenAddress(address: string) {
+  async isTokenAddress(address) {
     const type = await this.getAddressType(address)
     return type === 'token'
   }
 
-  async isSOLaddress(address: string) {
+  async isSOLaddress(address) {
     const type = await this.getAddressType(address)
     return type === 'solana'
   }
 
-  async getStakeAccountsInfo(address: string) {
+  async getStakeAccountsInfo(address) {
     const params = [
       STAKE_PROGRAM_ID.toBase58(),
       {
@@ -785,15 +780,15 @@ export class Api {
     return earnings
   }
 
-  async getMinimumBalanceForRentExemption(size: number) {
+  async getMinimumBalanceForRentExemption(size) {
     return this.rpcCall('getMinimumBalanceForRentExemption', [size])
   }
 
-  async getProgramAccounts(programId: string, config) {
+  async getProgramAccounts(programId, config) {
     return this.rpcCall('getProgramAccounts', [programId, config])
   }
 
-  async getMultipleAccounts(pubkeys: string[], config) {
+  async getMultipleAccounts(pubkeys, config) {
     const response = await this.rpcCall('getMultipleAccounts', [pubkeys, config])
     return response && response.value ? response.value : []
   }
@@ -801,7 +796,7 @@ export class Api {
   /**
    * Broadcast a signed transaction
    */
-  broadcastTransaction = async (signedTx: string, options): string => {
+  broadcastTransaction = async (signedTx, options) => {
     console.log('Solana broadcasting TX:', signedTx) // base64
     const defaultOptions = { encoding: 'base64', preflightCommitment: 'finalized' }
 
@@ -955,9 +950,9 @@ export class Api {
    * Simulate transaction and return side effects
    */
   simulateAndRetrieveSideEffects = async (
-    message: SolanaWeb3Message,
-    publicKey: string,
-    transactionMessage?: any // decompiled TransactionMessage
+    message,
+    publicKey,
+    transactionMessage? // decompiled TransactionMessage
   ) => {
     const { config, accountAddresses } = getTransactionSimulationParams(
       transactionMessage || message

package/src/index.js

@@ -8,6 +8,7 @@ export { default as SolanaFeeMonitor } from './fee-monitor'
 export * from './api'
 export * from './tx-log'
 export * from './account-state'
+export * from './tx-send'
 
 // 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()

package/src/tx-log/solana-monitor.js

@@ -134,6 +134,7 @@ export class SolanaMonitor extends BaseMonitor {
       const assetName = _.get(tx, 'token.tokenName', baseAsset.name)
       const asset = this.assets[assetName]
       if (assetName === 'unknown' || !asset) continue // skip unknown tokens
+      const feeAsset = asset.feeAsset
 
       const coinAmount = asset.currency.baseUnit(tx.amount).toDefault()
 
@@ -150,6 +151,7 @@ export class SolanaMonitor extends BaseMonitor {
           unparsed: !!tx.unparsed,
           swapTx: !!(tx.data && tx.data.inner),
         },
+        currencies: { [assetName]: asset.currency, [feeAsset.name]: feeAsset.currency },
       }
 
       if (tx.owner === address) {
@@ -172,7 +174,6 @@ export class SolanaMonitor extends BaseMonitor {
         item.data.meta = tx.data.meta
       }
       if (asset.assetType === 'SOLANA_TOKEN' && item.feeAmount && item.feeAmount.isPositive) {
-        const feeAsset = asset.feeAsset
         const feeItem = {
           ..._.clone(item),
           coinName: feeAsset.name,

package/src/tx-send.js

@@ -0,0 +1,202 @@
+import { createUnsignedTx, findAssociatedTokenAddress } from '@exodus/solana-lib'
+import assert from 'minimalistic-assert'
+
+export const createAndBroadcastTXFactory = (api) => async (
+  { asset, walletAccount, address, amount, options = {} },
+  { assetClientInterface }
+) => {
+  const assetName = asset.name
+  assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${assetName}`)
+
+  const {
+    feeAmount,
+    shouldLog = true,
+    method,
+    stakeAddresses,
+    seed,
+    pool,
+    customMintAddress,
+    tokenStandard,
+    // <MagicEden>
+    initializerAddress,
+    initializerDepositTokenAddress,
+    takerAmount,
+    escrowAddress,
+    escrowBump,
+    pdaAddress,
+    takerAddress,
+    expectedTakerAmount,
+    expectedMintAddress,
+    metadataAddress,
+    creators,
+    // </MagicEden>
+    reference,
+    memo,
+  } = options
+  let { recentBlockhash } = options
+  const { baseAsset } = asset
+  const from = await assetClientInterface.getReceiveAddress({
+    assetName: baseAsset.name,
+    walletAccount,
+  })
+  const currentAccountState = await assetClientInterface.getAccountState({
+    assetName: baseAsset.name,
+    walletAccount,
+  })
+
+  recentBlockhash = recentBlockhash || (await api.getRecentBlockHash())
+
+  let tokenParams = {}
+  if (asset.assetType === 'SOLANA_TOKEN' || customMintAddress) {
+    const tokenMintAddress = customMintAddress || asset.mintAddress
+    const tokenAddress = findAssociatedTokenAddress(address, tokenMintAddress)
+    const [
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAccountAddresses,
+    ] = await Promise.all([
+      api.getAddressType(address),
+      api.isAssociatedTokenAccountActive(tokenAddress),
+      api.getTokenAccountsByOwner(from),
+    ])
+
+    const fromTokenAddresses = fromTokenAccountAddresses.filter(
+      ({ mintAddress }) => mintAddress === tokenMintAddress
+    )
+
+    tokenParams = {
+      tokenMintAddress,
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAddresses,
+      tokenStandard,
+    }
+  }
+
+  const stakingParams = {
+    method,
+    stakeAddresses,
+    seed,
+    pool,
+  }
+
+  const magicEdenParams = {
+    method,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    takerAmount,
+    escrowAddress,
+    escrowBump,
+    pdaAddress,
+    takerAddress,
+    expectedTakerAmount,
+    expectedMintAddress,
+    metadataAddress,
+    creators,
+  }
+
+  const unsignedTransaction = await createUnsignedTx({
+    asset,
+    from,
+    to: address,
+    amount,
+    fee: feeAmount,
+    recentBlockhash,
+    reference,
+    memo,
+    ...tokenParams,
+    ...stakingParams,
+    ...magicEdenParams,
+  })
+
+  const { txId, rawTx } = await assetClientInterface.signTransaction({
+    assetName: baseAsset.name,
+    unsignedTx: unsignedTransaction,
+    walletAccount,
+  })
+
+  await baseAsset.api.broadcastTx(rawTx)
+
+  const selfSend = from === address
+  const coinAmount = selfSend ? asset.currency.ZERO : amount.abs().negate()
+
+  if (shouldLog) {
+    const tx = {
+      txId,
+      confirmations: 0,
+      coinName: assetName,
+      coinAmount,
+      feeAmount,
+      feeCoinName: asset.feeAsset.name,
+      selfSend,
+      to: address,
+      data: {
+        // note
+      },
+      currencies: { [assetName]: asset.currency, [asset.feeAsset.name]: asset.feeAsset.currency },
+    }
+    await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
+  }
+
+  const changes = {}
+  if (asset.assetType === 'SOLANA_TOKEN') {
+    Object.assign(changes, {
+      balance: currentAccountState.balance.sub(feeAmount), // solana balance
+      tokenBalances: {
+        ...currentAccountState.tokenBalances,
+        [assetName]: currentAccountState.tokenBalances[assetName].sub(coinAmount.abs()),
+      }, // SPL token balance
+    })
+    // write tx entry in solana for token fee
+    const tx = {
+      txId,
+      coinName: baseAsset.name,
+      coinAmount: baseAsset.currency.ZERO,
+      tokens: [assetName],
+      feeAmount,
+      feeCoinName: baseAsset.feeAsset.name,
+      to: address,
+      selfSend,
+      currencies: {
+        [baseAsset.name]: baseAsset.currency,
+        [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+      },
+    }
+    await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
+  } else if (customMintAddress) {
+    Object.assign(changes, {
+      balance: currentAccountState.balance.sub(feeAmount), // solana balance
+    })
+  } else if (method) {
+    // staking: no changes
+  } else {
+    // SOL transfer
+    Object.assign(changes, {
+      balance: currentAccountState.balance.sub(coinAmount.abs()).sub(feeAmount),
+    })
+  }
+
+  if (method) {
+    const stakingData = { ...currentAccountState.mem }
+    switch (method) {
+      case 'delegate':
+        stakingData.isDelegating = true
+        stakingData.locked = stakingData.locked.add(amount)
+        break
+      case 'undelegate':
+        stakingData.isDelegating = false
+        stakingData.pending = stakingData.pending.add(stakingData.locked)
+        stakingData.locked = asset.currency.ZERO
+        break
+      case 'withdraw':
+        stakingData.withdrawable = asset.currency.ZERO
+        break
+    }
+
+    Object.assign(changes, { mem: stakingData })
+  }
+
+  await assetClientInterface.updateAccountState({ assetName, walletAccount, newData: changes })
+
+  return { txId }
+}