@exodus/solana-api 2.5.20 → 2.5.21

package/lib/pay/validateBeforePay.js

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ValidateError = void 0;
-exports.validateBeforePay = validateBeforePay;
-
-var _ = _interopRequireDefault(require(".."));
-
-var _currency = _interopRequireDefault(require("@exodus/currency"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class ValidateError extends Error {
-  constructor(...args) {
-    super(...args);
-    this.name = 'ValidateError';
-  }
-
-}
-
-exports.ValidateError = ValidateError;
-
-async function validateBeforePay({
-  asset,
-  senderInfo,
-  amount,
-  feeAmount = 0,
-  recipient,
-  checkEnoughBalance = true
-}) {
-  const isNative = asset.name === asset.baseAsset.name;
-  const recipientInfo = await _.default.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;
-}

package/lib/tx-log/index.js

@@ -1,18 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _solanaMonitor = require("./solana-monitor");
-
-Object.keys(_solanaMonitor).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _solanaMonitor[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _solanaMonitor[key];
-    }
-  });
-});

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

@@ -1,354 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SolanaMonitor = void 0;
-
-var _assetLib = require("@exodus/asset-lib");
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _minimalisticAssert = _interopRequireDefault(require("minimalistic-assert"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const DEFAULT_POOL_ADDRESS = '9QU2QSxhb24FUX3Tu2FpczXjpK3VYrvRudywSZaM29mF'; // Everstake
-
-const DEFAULT_REMOTE_CONFIG = {
-  rpcs: [],
-  ws: [],
-  staking: {
-    enabled: true,
-    pool: DEFAULT_POOL_ADDRESS
-  }
-};
-
-class SolanaMonitor extends _assetLib.BaseMonitor {
-  constructor({
-    api,
-    includeUnparsed = false,
-    ...args
-  }) {
-    super(args);
-    (0, _minimalisticAssert.default)(api, 'api is required');
-    this.api = api;
-    this.cursors = {};
-    this.assets = {};
-    this.includeUnparsed = includeUnparsed;
-    this.addHook('before-stop', (...args) => this.beforeStop(...args));
-  }
-
-  async beforeStop() {
-    const walletAccounts = await this.aci.getWalletAccounts({
-      assetName: this.asset.name
-    });
-    return Promise.all(walletAccounts.map(walletAccount => this.stopListener({
-      walletAccount
-    })));
-  }
-
-  async initWalletAccount({
-    walletAccount
-  }) {
-    if (this.tickCount[walletAccount] === 0) {
-      await this.startListener({
-        walletAccount
-      });
-    }
-  }
-
-  async startListener({
-    walletAccount
-  }) {
-    const address = await this.aci.getReceiveAddress({
-      assetName: this.asset.name,
-      walletAccount
-    });
-    return this.api.watchAddress({
-      address
-      /*
-      // OPTIONAL. Relying on polling through ws
-      tokensAddresses: [], // needed for ASA subs
-      handleAccounts: (updates) => this.accountsCallback({ updates, walletAccount }),
-      handleTransfers: (txs) => {
-        // new SOL tx, ticking monitor
-        this.tick({ walletAccount }) // it will cause refresh for both sender/receiver. Without necessarily fetching the tx if it's not finalized in the node.
-      },
-      */
-
-    });
-  }
-
-  async stopListener({
-    walletAccount
-  }) {
-    const address = await this.aci.getReceiveAddress({
-      assetName: this.asset.name,
-      walletAccount
-    });
-    return this.api.unwatchAddress({
-      address
-    });
-  }
-
-  setServer(config = {}) {
-    const {
-      rpcs,
-      ws,
-      staking = {}
-    } = { ...DEFAULT_REMOTE_CONFIG,
-      ...config
-    };
-    this.api.setServer(rpcs[0]);
-    this.api.setWsEndpoint(ws[0]);
-    this.staking = staking;
-  }
-
-  hasNewCursor({
-    walletAccount,
-    cursorState
-  }) {
-    const {
-      cursor
-    } = cursorState;
-    return this.cursors[walletAccount] !== cursor;
-  }
-
-  async emitUnknownTokensEvent({
-    tokenAccounts
-  }) {
-    const tokensList = await this.api.getWalletTokensList({
-      tokenAccounts
-    });
-
-    if (tokensList.length > 0) {
-      this.emit('unknown-tokens', tokensList);
-    }
-  }
-
-  async tick({
-    walletAccount,
-    refresh
-  }) {
-    // Check for new wallet account
-    await this.initWalletAccount({
-      walletAccount
-    });
-    const assetName = this.asset.name;
-    this.assets = await this.aci.getAssetsForNetwork({
-      baseAssetName: assetName
-    });
-    this.api.setTokens(this.assets);
-    const accountState = await this.aci.getAccountState({
-      assetName,
-      walletAccount
-    });
-    const address = await this.aci.getReceiveAddress({
-      assetName,
-      walletAccount
-    });
-    const {
-      logItemsByAsset,
-      hasNewTxs,
-      cursorState
-    } = await this.getHistory({
-      address,
-      accountState,
-      walletAccount,
-      refresh
-    });
-    let staking = accountState.mem;
-    const cursorChanged = this.hasNewCursor({
-      walletAccount,
-      cursorState
-    });
-
-    if (refresh || cursorChanged) {
-      staking = await this.updateStakingInfo({
-        walletAccount,
-        address
-      });
-      this.cursors[walletAccount] = cursorState.cursor;
-    }
-
-    await this.updateTxLogByAsset({
-      walletAccount,
-      logItemsByAsset,
-      refresh
-    });
-
-    if (refresh || hasNewTxs || cursorChanged) {
-      const tokenAccounts = await this.api.getTokenAccountsByOwner(address);
-      await this.emitUnknownTokensEvent({
-        tokenAccounts
-      });
-      const account = await this.getAccount({
-        address,
-        staking,
-        tokenAccounts
-      });
-      await this.updateState({
-        account,
-        cursorState,
-        walletAccount
-      });
-    }
-  }
-
-  async getHistory({
-    address,
-    accountState,
-    refresh
-  } = {}) {
-    let cursor = refresh ? '' : accountState.cursor;
-    const baseAsset = this.asset;
-    const {
-      transactions,
-      newCursor
-    } = await this.api.getTransactions(address, {
-      cursor,
-      includeUnparsed: this.includeUnparsed
-    });
-    const mappedTransactions = [];
-
-    for (const tx of transactions) {
-      const assetName = _lodash.default.get(tx, 'token.tokenName', baseAsset.name);
-
-      const asset = this.assets[assetName];
-      if (assetName === 'unknown' || !asset) continue; // skip unknown tokens
-
-      const coinAmount = asset.currency.baseUnit(tx.amount).toDefault();
-      const item = {
-        coinName: assetName,
-        txId: tx.id,
-        from: [tx.from],
-        coinAmount,
-        confirmations: 1,
-        // tx.confirmations, // avoid multiple notifications
-        date: tx.date,
-        error: tx.error,
-        data: {
-          staking: tx.staking || null,
-          unparsed: !!tx.unparsed,
-          swapTx: !!(tx.data && tx.data.inner)
-        }
-      };
-
-      if (tx.owner === address) {
-        // send transaction
-        item.to = tx.to;
-        item.feeAmount = baseAsset.currency.baseUnit(tx.fee).toDefault(); // in SOL
-
-        item.coinAmount = item.coinAmount.negate();
-
-        if (tx.to === tx.owner) {
-          item.selfSend = true;
-          item.coinAmount = asset.currency.ZERO;
-        }
-      } else if (tx.unparsed) {
-        if (tx.fee !== 0) item.feeAmount = baseAsset.currency.baseUnit(tx.fee).toDefault(); // in SOL
-
-        item.data.meta = tx.data.meta;
-      }
-
-      if (asset.assetType === 'SOLANA_TOKEN' && item.feeAmount && item.feeAmount.isPositive) {
-        const feeAsset = asset.feeAsset;
-        const feeItem = { ..._lodash.default.clone(item),
-          coinName: feeAsset.name,
-          tokens: [asset.name],
-          coinAmount: feeAsset.currency.ZERO
-        };
-        mappedTransactions.push(feeItem);
-      }
-
-      mappedTransactions.push(item);
-    } // logItemsByAsset = { 'solana:': [...], 'serum': [...] }
-
-
-    return {
-      logItemsByAsset: _lodash.default.groupBy(mappedTransactions, item => item.coinName),
-      hasNewTxs: transactions.length > 0,
-      cursorState: {
-        cursor: newCursor
-      }
-    };
-  }
-
-  async getAccount({
-    address,
-    staking,
-    tokenAccounts
-  }) {
-    const tokens = Object.keys(this.assets).filter(name => name !== this.asset.name);
-    const [solBalance, splBalances] = await Promise.all([this.api.getBalance(address), this.api.getTokensBalance({
-      address,
-      filterByTokens: tokens,
-      tokenAccounts
-    })]);
-    const stakedBalance = this.asset.currency.baseUnit(staking.locked).toDefault();
-    const withdrawableBalance = this.asset.currency.baseUnit(staking.withdrawable).toDefault();
-    const pendingBalance = this.asset.currency.baseUnit(staking.pending).toDefault();
-    const balance = this.asset.currency.baseUnit(solBalance).toDefault().add(stakedBalance).add(withdrawableBalance).add(pendingBalance);
-
-    const tokenBalances = _lodash.default.mapValues(splBalances, (balance, name) => this.assets[name].currency.baseUnit(balance).toDefault());
-
-    return {
-      balance,
-      tokenBalances
-    };
-  }
-
-  async updateState({
-    account,
-    cursorState,
-    walletAccount
-  }) {
-    const {
-      balance,
-      tokenBalances
-    } = account;
-    const newData = {
-      balance,
-      tokenBalances,
-      ...cursorState
-    };
-    return this.updateAccountState({
-      newData,
-      walletAccount
-    });
-  }
-
-  async updateStakingInfo({
-    walletAccount,
-    address
-  }) {
-    const stakingInfo = await this.api.getStakeAccountsInfo(address);
-    const rewards = await this.api.getRewards(Object.keys(stakingInfo.accounts));
-    const mem = {
-      loaded: true,
-      staking: this.staking,
-      isDelegating: Object.values(stakingInfo.accounts).some(({
-        state
-      }) => ['active', 'activating', 'inactive'].includes(state)),
-      // true if at least 1 account is delegating
-      locked: this.asset.currency.baseUnit(stakingInfo.locked).toDefault(),
-      withdrawable: this.asset.currency.baseUnit(stakingInfo.withdrawable).toDefault(),
-      pending: this.asset.currency.baseUnit(stakingInfo.pending).toDefault(),
-      // still undelegating (not yet available for withdraw)
-      earned: this.asset.currency.baseUnit(rewards).toDefault(),
-      accounts: stakingInfo.accounts // Obj
-
-    };
-    await this.updateAccountState({
-      walletAccount,
-      newData: {
-        mem
-      }
-    });
-    return mem;
-  }
-
-}
-
-exports.SolanaMonitor = SolanaMonitor;

package/src/__tests__/api.test.js

@@ -1,286 +0,0 @@
-import lodash from 'lodash'
-import { fetch } from '@exodus/fetch'
-import wretch from 'wretch'
-import * as splToken from '@exodus/solana-spl-token'
-import {
-  generateKeyPair,
-  PublicKey,
-  LAMPORTS_PER_SOL,
-  TOKEN_PROGRAM_ID,
-  SystemProgram,
-  U64,
-  SolanaWeb3Transaction as Transaction,
-} from '@exodus/solana-lib'
-import { Api } from '../index'
-import { SOL_TRANSFER_TX } from './fixtures'
-import assets from './assets'
-
-const api = new Api({ assets })
-
-wretch().polyfills({
-  fetch,
-})
-
-const SECONDS = 1000
-jest.setTimeout(60 * SECONDS)
-
-const ADDRESS_WITH_HISTORY = 'Cd1uLoQwGZiDSyJxrwbpYmuDZM2tDftkowPjWv5YE5Z7'
-const ADDRESS_FRESH = '3bbnZt1mzp1EBRR9Rm6TX2cXzZYbVvM9THutWL8bCmVH' // no txs history
-const TXID =
-  '4AwqVmXFzciF89JyzMrTr5FT2tX1iMg7ypzCzUsGMD54dwjrE8w4GLNTbXXRpNcE8JkTSGRbZ8SzEc5umQJNFS3m'
-const SRM_TOKEN_TXID =
-  '2zJ7dnXMZYUhw4uaeLaBRcoDsgfM9HZ1GSbfjJp4SxWrFhzEdwNKFfFFJ8LL6ckKwh5Xg5ik5pUuRtjMkGMDZpgV'
-
-beforeAll(() => {
-  return api.watchAddress({ address: ADDRESS_WITH_HISTORY }) // Open WS connection
-})
-
-test('Solana: getRecentBlockHash', async () => {
-  const blockHash = await api.getRecentBlockHash()
-  expect(typeof blockHash).toEqual('string')
-  expect(blockHash.length > 40).toEqual(true)
-})
-
-test('Solana: getTransactionById', async () => {
-  const result = await api.getTransactionById(TXID)
-  expect(result.transaction.signatures[0]).toEqual(TXID) // string
-  expect(result.meta.fee > 0).toEqual(true)
-  expect(Array.isArray(result.meta.preBalances)).toEqual(true)
-  expect(Array.isArray(result.meta.postBalances)).toEqual(true)
-  expect(result.transaction.message.accountKeys.length > 1).toEqual(true)
-  expect(result.transaction.message.accountKeys[0].pubkey).toEqual(
-    'Bnjx2F242ZK6LsKbAvRwDoeKczJTK8LFM918p8sZCb69'
-  )
-})
-
-test('Solana: getFee', async () => {
-  const fee = await api.getFee()
-  expect(fee >= 4000).toEqual(true) // usually 5000 lamports
-})
-
-test('Solana: getBalance', async () => {
-  const [balance1, balance2] = await Promise.all([
-    api.getBalance(ADDRESS_WITH_HISTORY),
-    api.getBalance(ADDRESS_FRESH),
-  ])
-  expect(typeof balance1 === 'number').toEqual(true)
-  expect(typeof balance2 === 'number').toEqual(true)
-  expect(balance2).toEqual(0)
-})
-
-test('Solana: getBlockTime', async () => {
-  const ts = await api.getBlockTime(49901505)
-  expect(ts) // if null the backend started pruning old tx entries and has partial ledger!
-})
-
-test('Solana: getConfirmedSignaturesForAddress', async () => {
-  const addrTxs = await api.getConfirmedSignaturesForAddress(ADDRESS_WITH_HISTORY)
-  expect(addrTxs.length > 4)
-  const addrTxs2 = await api.getConfirmedSignaturesForAddress(ADDRESS_WITH_HISTORY, { until: '' })
-  expect(addrTxs2.length > 4).toEqual(true)
-})
-
-describe('getTransactions', () => {
-  test('Solana: Returns empty transactions if account is not created', async () => {
-    const { transactions } = await api.getTransactions(ADDRESS_FRESH)
-    expect(transactions.length === 0).toBeTruthy()
-  })
-
-  test('Solana: Returns correct transactions if account is created', async () => {
-    const { transactions, newCursor } = await api.getTransactions(ADDRESS_WITH_HISTORY)
-    expect(transactions.length >= 1).toBeTruthy()
-    expect(typeof newCursor).toEqual('string')
-    // check tokens txs returned as well
-    const tokenTx = transactions.find(({ id }) => id === SRM_TOKEN_TXID)
-    // console.log('tokenTx:', tokenTx)
-    expect(tokenTx.timestamp).toEqual(1608598478000)
-    expect(tokenTx.id).toEqual(SRM_TOKEN_TXID)
-    expect(tokenTx.token.tokenName).toEqual('serum')
-    expect(tokenTx.owner).toEqual(null)
-    expect(tokenTx.from).toEqual('71GbXnJkHz15kzjagB2f7N9H7HPA99v6BFuqfdYL5qtf')
-    expect(tokenTx.amount).toEqual(1000)
-    expect(tokenTx.fee).toEqual(0)
-  })
-
-  test('Solana: Returns expected transactions with cursor', async () => {
-    const OLD_TXID =
-      '3qFUz73ZPiexM8yHyTFhnEhXgVinzXCQMieJbTsfZKcW5V3vPSJJvRCSKjCHJDYtWqReeBrFV98hcCFaAznpjgUC' // existing old txid that should not be returned in txs history after cursor date.
-    const { transactions } = await api.getTransactions(ADDRESS_WITH_HISTORY, {
-      cursor:
-        '4kzJjAbaT1PVSuk7JDh6697Y63MrGGMwDgi8CKRtctHbXWRjPtrzY1RnbMuedPDefru2hrGeLfRDpqtdFmQQAMXm',
-    })
-    expect(transactions.length >= 1).toBeTruthy()
-    expect(lodash.find(transactions, { id: OLD_TXID })).toBeFalsy()
-    expect(
-      lodash.find(transactions, {
-        id:
-          '3V7eDr5BbgZfgiADpUxM2fHQ1ZAoJHddxxfFRd8KtDQeTqLsv9wkfeg6NrVHzQc7wnEmVRQPdsYBT3RKLztL6Suf',
-      })
-    ).toBeTruthy()
-  })
-})
-
-test('Solana: parseTransaction on a SOL tx', async () => {
-  const owner = 'Bnjx2F242ZK6LsKbAvRwDoeKczJTK8LFM918p8sZCb69'
-  const tx = await api.parseTransaction(owner, SOL_TRANSFER_TX)
-  // console.log(tx)
-  expect(tx.id).toEqual(
-    '4AwqVmXFzciF89JyzMrTr5FT2tX1iMg7ypzCzUsGMD54dwjrE8w4GLNTbXXRpNcE8JkTSGRbZ8SzEc5umQJNFS3m'
-  )
-  expect(tx.slot).toEqual(36446581)
-  expect(tx.error).toEqual(false)
-  expect(tx.from).toEqual('Bnjx2F242ZK6LsKbAvRwDoeKczJTK8LFM918p8sZCb69')
-  expect(tx.to).toEqual('84HuMpN8JPy9DLerT5nRcEHjkb1UQS3TD4CvR9y8MqgD')
-  expect(tx.amount).toEqual(2e13)
-  expect(tx.fee).toEqual(5e3)
-})
-
-test('Solana: getMinimumBalanceForRentExemption', async () => {
-  const minimumBalance = await api.getMinimumBalanceForRentExemption(80)
-  expect(typeof minimumBalance === 'number').toEqual(true)
-})
-
-test('Solana: getMetaplexMetadata', async () => {
-  const MANGO_SPL_TOKEN = 'MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac'
-
-  const metadata = await api.getMetaplexMetadata(MANGO_SPL_TOKEN)
-  // console.log('metadata', metadata)
-  expect(metadata.name).toEqual('Mango')
-  expect(metadata.symbol).toEqual('MNGO')
-})
-
-test('Solana: getMetaplexMetadata of invalid address returns null', async () => {
-  const RANDOM_SPL_TOKEN = 'Dhg9XnzJWzSQqH2aAnhPTEJHGQAkALDfD98MA499A7pa' // doesn't have metaplex data
-
-  const metadata = await api.getMetaplexMetadata(RANDOM_SPL_TOKEN)
-  expect(metadata).toEqual(null)
-})
-
-test('Solana: broadcastTransaction', async () => {
-  // execute setTimeout callback immediately (no wait)
-  jest.spyOn(global, 'setTimeout')
-  global.setTimeout.mockImplementation((callback) => {
-    return callback()
-  })
-
-  try {
-    // send transaction
-    const signedTx =
-      'AVXo5X7UNzpuOmYzkZ+fqHDGiRLTSMlWlUCcZKzEV5CIKlrdvZa3/2GrJJfPrXgZqJbYDaGiOnP99tI/sRJfiwwBAAEDRQ/n5E5CLbMbHanUG3+iVvBAWZu0WFM6NoB5xfybQ7kNwwgfIhv6odn2qTUu/gOisDtaeCW1qlwW/gx3ccr/4wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvsInicc+E3IZzLqeA+iM5cn9kSaeFzOuClz1Z2kZQy0BAgIAAQwCAAAAAPIFKgEAAAA='
-    await api.broadcastTransaction(signedTx)
-    expect('To Fail').toEqual(true)
-  } catch (err) {
-    expect(err.message.match(/Blockhash not found/)).toBeTruthy()
-  } finally {
-    global.setTimeout.mockRestore()
-  }
-})
-
-describe('Solana: getDecimals', () => {
-  test('returns decimals if valid SPL address', async () => {
-    const decimals = await api.getDecimals('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v') // USDC
-    expect(decimals).toEqual(6)
-  })
-
-  test('Solana: getDecimals: errors if invalid SPL address', async () => {
-    try {
-      await api.getDecimals('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1w')
-      expect('To Fail').toEqual(true)
-    } catch (err) {
-      expect(err.message.match(/could not find account/)).toBeTruthy()
-    }
-
-    try {
-      await api.getDecimals('EPjFWdd5ZwTDt1')
-      expect('To Fail').toEqual(true)
-    } catch (err) {
-      expect(err.message.match(/WrongSize/)).toBeTruthy()
-    }
-  })
-})
-
-describe('Solana: getAccountInfo', () => {
-  test('returns parsed data', async () => {
-    const value = await api.getAccountInfo('26EA6FxEfryse9iJbZrtYCUwhAwxmqG1GurrfbJarmem')
-    expect(typeof value?.data?.parsed === 'object').toBeTruthy()
-  })
-
-  test('returns base64 data', async () => {
-    const value = await api.getAccountInfo('26EA6FxEfryse9iJbZrtYCUwhAwxmqG1GurrfbJarmem', 'base64')
-    expect(Array.isArray(value.data)).toBeTruthy()
-    expect(Buffer.from(value.data[0], 'base64').length).toEqual(8184)
-  })
-})
-
-describe('Solana: isSpl', () => {
-  test('returns true for addresses owned by the Token Program', async () => {
-    expect(await api.isSpl('BmxZ1pghpcoyT7aykj7D1o4AxWirTqvD7zD2tNngjirT')).toBeTruthy()
-    expect(await api.isSpl('buMnhMd5xSyXBssTQo15jouu8VhuEZJCfbtBUZgRcuW')).toBeTruthy()
-    expect(await api.isSpl('MAPS41MDahZ9QdKXhVa4dWB9RuyfV4XqhyAZ8XcYepb')).toBeTruthy()
-  })
-
-  test('returns false for addresses not owned by the Token Program', async () => {
-    expect(await api.isSpl('9zyPU1mjgzaVyQsYwKJJ7AhVz5bgx5uc1NPABvAcUXsT')).toBeFalsy()
-  })
-})
-
-describe('Solana: simulateAndRetrieveSideEffects', () => {
-  const ownerSolAccount = new PublicKey('3b1rT3knyRnZHKHCCxKWnJDWo8k6SDdSTvYzqyXUYwxL') // 1 SOL
-  const ownerTokenAddress = new PublicKey('FRaWiAGc3bvQKAkqqAxwmLvCVH7AaUGo6MrBUYhCmojK') // 0 Wrapped SOL (Token)
-
-  const secondarySolAccount = new PublicKey('41TDiDgCLz2eh5vPMhWCdNeaoMfrs3tM4rGdZgX4jL56') // 1 SOL
-  const secondaryTokenAddress = new PublicKey('8HPbjj4QVnYGUcRrfeZ3XdMhq36RnaJqvUHjHZYZ2p65') // 1 Wrapped SOL (Token)
-
-  // Use solana devnet since we need actual accounts with available balance for simulation
-  const testApi = new Api({ rpcUrl: 'https://api.devnet.solana.com', assets })
-
-  test('returns willSend and willReceive account changes', async () => {
-    const SOL_SEND_AMOUNT = LAMPORTS_PER_SOL * 0.1
-    const TOKEN_SEND_AMOUNT = LAMPORTS_PER_SOL * 0.531
-
-    const txFee = await api.getFee()
-    const transaction = new Transaction()
-    // Owner sends SOL
-    transaction.add(
-      SystemProgram.transfer({
-        fromPubkey: ownerSolAccount,
-        toPubkey: generateKeyPair().publicKey,
-        lamports: SOL_SEND_AMOUNT,
-      })
-    )
-    // Owner receives Wrapped SOL token
-    transaction.add(
-      splToken.Token.createTransferInstruction(
-        TOKEN_PROGRAM_ID,
-        secondaryTokenAddress,
-        ownerTokenAddress,
-        secondarySolAccount,
-        [],
-        TOKEN_SEND_AMOUNT
-      )
-    )
-    transaction.recentBlockhash = await testApi.getRecentBlockHash()
-    transaction.feePayer = ownerSolAccount
-    transaction.signatures = [
-      { signature: null, publicKey: ownerSolAccount },
-      { signature: null, publicKey: secondarySolAccount },
-    ]
-
-    const result = await testApi.simulateAndRetrieveSideEffects(
-      transaction.compileMessage(),
-      ownerSolAccount.toString()
-    )
-
-    expect(result.willSend.length === 1).toBeTruthy()
-    expect(result.willSend[0].type).toEqual('SOL')
-    expect(result.willSend[0].balance).toEqual(new U64((SOL_SEND_AMOUNT + txFee * 2) * -1)) // two tx and will send would be negative
-
-    expect(result.willReceive.length === 1).toBeTruthy()
-    expect(result.willReceive[0].type).toEqual('TOKEN')
-    expect(result.willReceive[0].balance).toEqual(new U64(TOKEN_SEND_AMOUNT))
-  })
-})
-
-afterAll(async () => {
-  return api.unwatchAddress({ address: ADDRESS_WITH_HISTORY })
-})

package/src/__tests__/assets.js

@@ -1,7 +0,0 @@
-import { keyBy } from '@exodus/basic-utils'
-import { connectAssets } from '@exodus/assets'
-import assetsList from '@exodus/solana-meta'
-
-const assets = connectAssets(keyBy(assetsList, (asset) => asset.name))
-
-export default assets