Untrusted assets should not block the addition of custom tokens

background/main.ts

@@ -188,6 +188,7 @@ import {
  OneTimeAnalyticsEvent,
 } from "./lib/posthog"
 import {
+ isVerifiedAsset,
  isBuiltInNetworkBaseAsset,
  isSameAsset,
 } from "./redux-slices/utils/asset-utils"
@@ -1894,14 +1895,17 @@ export default class Main extends BaseService<never> {
  const mainCurrencyAmount = convertedAssetAmount
  ? assetAmountToDesiredDecimals(convertedAssetAmount, 2)
  : undefined
+ // Existing assets are those that are verified by default or by the user.
+ // This check allows the user to add an asset that is on the unverified list.
+ const exists = cachedAsset ? isVerifiedAsset(cachedAsset) : false
 
  return {
  ...assetData,
  balance: Number.parseFloat(
  utils.formatUnits(assetData.amount, assetData.asset.decimals)
  ),
  mainCurrencyAmount,
- exists: !!cachedAsset,
+ exists,
  }
  }
 

background/redux-slices/selectors/0xSwapSelectors.ts

@@ -3,7 +3,7 @@ import { selectCurrentNetwork } from "./uiSelectors"
 import { SwappableAsset, isSmartContractFungibleAsset } from "../../assets"
 import { sameNetwork } from "../../networks"
 import {
- canBeUsedForTransaction,
+ isVerifiedAsset,
  isBuiltInNetworkBaseAsset,
 } from "../utils/asset-utils"
 import { RootState } from ".."
@@ -29,7 +29,7 @@ export const selectSwapBuyAssets = createSelector(
  ): asset is SwappableAsset & {
  recentPrices: SingleAssetState["recentPrices"]
  } => {
- if (!canBeUsedForTransaction(asset)) {
+ if (!isVerifiedAsset(asset)) {
  return false
  }
  if (isSmartContractFungibleAsset(asset)) {

background/redux-slices/utils/asset-utils.ts

@@ -377,6 +377,23 @@ export function isUnverifiedAssetByUser(asset: AnyAsset | undefined): boolean {
  return false
 }
 
+/**
+ * Check if an asset is verified.
+ * The asset can be verified by us when it is trusted by default.
+ * Untrusted asset can be manually verified by the user.
+ *
+ * Only verified assets can take part in wallet actions.
+ * By actions is meant:
+ * - doing an swap with this asset
+ * - sending this asset to another address
+ */
+export function isVerifiedAsset(asset: AnyAsset): boolean {
+ if (!isEnabled(FeatureFlags.SUPPORT_UNVERIFIED_ASSET)) {
+ return true
+ }
+ return isUntrustedAsset(asset) ? !isUnverifiedAssetByUser(asset) : true
+}
+
 type AssetType = "base" | "erc20"
 
 export type AssetID = `${AssetType}/${string}`
@@ -391,17 +408,6 @@ export const getAssetID = (
  return `erc20/${asset.contractAddress}`
 }
 
-/**
- * Assets that are untrusted and have not been verified by the user
- * should not be swapped or sent.
- */
-export function canBeUsedForTransaction(asset: AnyAsset): boolean {
- if (!isEnabled(FeatureFlags.SUPPORT_UNVERIFIED_ASSET)) {
- return true
- }
- return isUntrustedAsset(asset) ? !isUnverifiedAssetByUser(asset) : true
-}
-
 // FIXME Unify once asset similarity code is unified.
 export function isSameAsset(asset1?: AnyAsset, asset2?: AnyAsset): boolean {
  if (typeof asset1 === "undefined" || typeof asset2 === "undefined") {

background/services/indexing/index.ts

@@ -48,6 +48,11 @@ import {
  normalizeEVMAddress,
  sameEVMAddress,
 } from "../../lib/utils"
+import {
+ getActiveAssetsByAddressForNetwork,
+ getAssetsByAddress,
+ shouldRefreshKnownAsset,
+} from "./utils"
 
 // Transactions seen within this many blocks of the chain tip will schedule a
 // token refresh sooner than the standard rate.
@@ -75,29 +80,6 @@ interface Events extends ServiceLifecycleEvents {
  removeAssetData: SmartContractFungibleAsset
 }
 
-const getAssetsByAddress = (assets: SmartContractFungibleAsset[]) => {
- const activeAssetsByAddress = assets.reduce((agg, t) => {
- const newAgg = {
- ...agg,
- }
- newAgg[t.contractAddress.toLowerCase()] = t
- return newAgg
- }, {} as { [address: string]: SmartContractFungibleAsset })
-
- return activeAssetsByAddress
-}
-
-const getActiveAssetsByAddressForNetwork = (
- network: EVMNetwork,
- activeAssetsToTrack: SmartContractFungibleAsset[]
-) => {
- const networkActiveAssets = activeAssetsToTrack.filter(
- (asset) => asset.homeNetwork.chainID === network.chainID
- )
-
- return getAssetsByAddress(networkActiveAssets)
-}
-
 /**
  * IndexingService is responsible for pulling and maintaining all application-
  * level "indexing" data — things like fungible token balances and NFTs, as well
@@ -700,20 +682,9 @@ export default class IndexingService extends BaseService<Events> {
  normalizedAddress
  )
 
- if (knownAsset) {
- const newDiscoveryTxHash = metadata?.discoveryTxHash
- const addressForDiscoveryTxHash = newDiscoveryTxHash
- ? Object.keys(newDiscoveryTxHash)[0]
- : undefined
- const existingDiscoveryTxHash = addressForDiscoveryTxHash
- ? knownAsset.metadata?.discoveryTxHash?.[addressForDiscoveryTxHash]
- : undefined
- // If the discovery tx hash is not specified
- // or if it already exists in the asset, do not update the asset
- if (!newDiscoveryTxHash || existingDiscoveryTxHash) {
- await this.addAssetToTrack(knownAsset)
- return knownAsset
- }
+ if (knownAsset && !shouldRefreshKnownAsset(knownAsset, metadata)) {
+ await this.addAssetToTrack(knownAsset)
+ return knownAsset
  }
 
  let customAsset = await this.db.getCustomAssetByAddressAndNetwork(

background/services/indexing/utils/index.ts

@@ -0,0 +1,68 @@
+import { SmartContractFungibleAsset } from "../../../assets"
+import { EVMNetwork } from "../../../networks"
+import {
+ isUntrustedAsset,
+ isVerifiedAsset,
+} from "../../../redux-slices/utils/asset-utils"
+import { HexString } from "../../../types"
+
+export const getAssetsByAddress = (
+ assets: SmartContractFungibleAsset[]
+): {
+ [address: string]: SmartContractFungibleAsset
+} => {
+ const activeAssetsByAddress = assets.reduce((agg, t) => {
+ const newAgg = {
+ ...agg,
+ }
+ newAgg[t.contractAddress.toLowerCase()] = t
+ return newAgg
+ }, {} as { [address: string]: SmartContractFungibleAsset })
+
+ return activeAssetsByAddress
+}
+
+export const getActiveAssetsByAddressForNetwork = (
+ network: EVMNetwork,
+ activeAssetsToTrack: SmartContractFungibleAsset[]
+): {
+ [address: string]: SmartContractFungibleAsset
+} => {
+ const networkActiveAssets = activeAssetsToTrack.filter(
+ (asset) => asset.homeNetwork.chainID === network.chainID
+ )
+
+ return getAssetsByAddress(networkActiveAssets)
+}
+
+export function shouldRefreshKnownAsset(
+ asset: SmartContractFungibleAsset,
+ metadata: {
+ discoveryTxHash?: {
+ [address: HexString]: HexString
+ }
+ verified?: boolean
+ }
+): boolean {
+ const newDiscoveryTxHash = metadata?.discoveryTxHash
+ const addressForDiscoveryTxHash = newDiscoveryTxHash
+ ? Object.keys(newDiscoveryTxHash)[0]
+ : undefined
+ const existingDiscoveryTxHash = addressForDiscoveryTxHash
+ ? asset.metadata?.discoveryTxHash?.[addressForDiscoveryTxHash]
+ : undefined
+
+ // If the discovery tx hash is not specified
+ // or if it already exists in the asset, do not update the asset
+ // Additionally, discovery tx Hash should only be added for untrusted assets.
+ const allowAddDiscoveryTxHash =
+ isUntrustedAsset(asset) && !(!newDiscoveryTxHash || existingDiscoveryTxHash)
+
+ // Refresh a known unverified asset if it has been manually imported.
+ // This check allows the user to add an asset from the unverified list.
+ const isManuallyImported = metadata?.verified
+ const allowVerifyAssetByManualImport =
+ !isVerifiedAsset(asset) && isManuallyImported
+
+ return allowVerifyAssetByManualImport || allowAddDiscoveryTxHash
+}

background/services/indexing/utils/tests/index.unit.test.ts

@@ -0,0 +1,115 @@
+import { shouldRefreshKnownAsset } from ".."
+import { createSmartContractAsset } from "../../../../tests/factories"
+import * as featureFlags from "../../../../features"
+
+const ADDRESS = "0x0000000000000000000000000000000000000000"
+const DISCOVERY_TX_HASH = "0x0000000000000000000000000000000000000000"
+const METADATA_TX = {
+ discoveryTxHash: {
+ [ADDRESS]: DISCOVERY_TX_HASH,
+ },
+}
+const METADATA_VERIFIED = {
+ verified: true,
+}
+
+const TRUSTED_ASSET = createSmartContractAsset()
+const UNTRUSTED_ASSET = createSmartContractAsset({
+ metadata: { tokenLists: [] },
+})
+
+describe("IndexingService utils", () => {
+ describe("shouldRefreshKnownAsset", () => {
+ beforeAll(() => {
+ jest.spyOn(featureFlags, "isEnabled").mockImplementation(() => true)
+ })
+
+ it("Refresh the untrusted asset if manually imported", () => {
+ const shouldBeRefreshed = shouldRefreshKnownAsset(
+ UNTRUSTED_ASSET,
+ METADATA_VERIFIED
+ )
+
+ expect(shouldBeRefreshed).toBe(true)
+ })
+
+ it("Not refresh the untrusted asset if not manually imported", () => {
+ const shouldBeRefreshed = shouldRefreshKnownAsset(UNTRUSTED_ASSET, {})
+
+ expect(shouldBeRefreshed).toBe(false)
+ })
+
+ it("Not refresh the trusted asset if not manually imported", () => {
+ const shouldBeRefreshed = shouldRefreshKnownAsset(TRUSTED_ASSET, {})
+
+ expect(shouldBeRefreshed).toBe(false)
+ })
+
+ // This state is not quite possible in the app because the user is not able to manually import a trusted asset that exists.
+ it("Not refresh the trusted asset if manually imported", () => {
+ const shouldBeRefreshed = shouldRefreshKnownAsset(
+ TRUSTED_ASSET,
+ METADATA_VERIFIED
+ )
+
+ expect(shouldBeRefreshed).toBe(false)
+ })
+
+ it("Refresh the untrusted asset if it does not already have a discovered tx hash", () => {
+ const shouldBeRefreshed = shouldRefreshKnownAsset(
+ UNTRUSTED_ASSET,
+ METADATA_TX
+ )
+
+ expect(shouldBeRefreshed).toBe(true)
+ })
+
+ it("Not refresh the trusted asset if it does not already have a discovered tx hash", () => {
+ const shouldBeRefreshed = shouldRefreshKnownAsset(
+ TRUSTED_ASSET,
+ METADATA_TX
+ )
+
+ expect(shouldBeRefreshed).toBe(false)
+ })
+
+ it("Not refresh the untrusted asset if it does already have a discovered tx hash", () => {
+ const asset = {
+ ...UNTRUSTED_ASSET,
+ metadata: { ...UNTRUSTED_ASSET, ...METADATA_TX },
+ }
+ const shouldBeRefreshed = shouldRefreshKnownAsset(asset, METADATA_TX)
+
+ expect(shouldBeRefreshed).toBe(false)
+ })
+
+ it("Not refresh the trusted asset if it does already have a discovered tx hash", () => {
+ const asset = {
+ ...TRUSTED_ASSET,
+ metadata: { ...TRUSTED_ASSET, ...METADATA_TX },
+ }
+ const shouldBeRefreshed = shouldRefreshKnownAsset(asset, METADATA_TX)
+
+ expect(shouldBeRefreshed).toBe(false)
+ })
+
+ it("Not refresh the trusted asset if discovered tx hash is not specified", () => {
+ const asset = {
+ ...TRUSTED_ASSET,
+ metadata: { ...TRUSTED_ASSET, ...METADATA_TX },
+ }
+
+ expect(shouldRefreshKnownAsset(TRUSTED_ASSET, {})).toBe(false)
+ expect(shouldRefreshKnownAsset(asset, {})).toBe(false)
+ })
+ it("Not refresh the untrusted asset if discovered tx hash is not specified", () => {
+ const asset = {
+ ...UNTRUSTED_ASSET,
+ metadata: { ...UNTRUSTED_ASSET, ...METADATA_TX },
+ }
+
+ expect(shouldRefreshKnownAsset(UNTRUSTED_ASSET, {})).toBe(false)
+ expect(shouldRefreshKnownAsset(asset, {})).toBe(false)
+ })
+ })
+})

ui/pages/Send.tsx

@@ -28,7 +28,7 @@ import {
 } from "@tallyho/tally-background/redux-slices/assets"
 import { CompleteAssetAmount } from "@tallyho/tally-background/redux-slices/accounts"
 import {
- canBeUsedForTransaction,
+ isVerifiedAsset,
  enrichAssetAmountWithMainCurrencyValues,
 } from "@tallyho/tally-background/redux-slices/utils/asset-utils"
 import { useHistory, useLocation } from "react-router-dom"
@@ -112,7 +112,7 @@ export default function Send(): ReactElement {
  (assetAmount): assetAmount is CompleteAssetAmount<FungibleAsset> =>
  isFungibleAssetAmount(assetAmount) &&
  assetAmount.decimalAmount > 0 &&
- canBeUsedForTransaction(assetAmount.asset)
+ isVerifiedAsset(assetAmount.asset)
  )
  const assetPricePoint = useBackgroundSelector((state) =>
  selectAssetPricePoint(state.assets, selectedAsset, mainCurrencySymbol)

ui/utils/swap.ts

@@ -18,7 +18,7 @@ import { debounce, DebouncedFunc } from "lodash"
 import { useState, useRef, useCallback } from "react"
 import { CompleteAssetAmount } from "@tallyho/tally-background/redux-slices/accounts"
 import {
- canBeUsedForTransaction,
+ isVerifiedAsset,
  isSameAsset,
 } from "@tallyho/tally-background/redux-slices/utils/asset-utils"
 import { useBackgroundDispatch, useBackgroundSelector } from "../hooks"
@@ -271,7 +271,7 @@ export function getOwnedSellAssetAmounts(
  (isSmartContractFungibleAsset(assetAmount.asset) ||
  assetAmount.asset.symbol === currentNetwork.baseAsset.symbol) &&
  assetAmount.decimalAmount > 0 &&
- canBeUsedForTransaction(assetAmount.asset)
+ isVerifiedAsset(assetAmount.asset)
  ) ?? []
  )
 }