@swapkit/helpers 3.0.0-beta.0 → 3.0.0-beta.1

package/package.json

@@ -1,12 +1,13 @@
 {
   "author": "swapkit-oss",
   "dependencies": {
-    "zod": "3.24.2",
+    "ts-pattern": "5.7.0",
+    "zod": "3.24.3",
     "zustand": "5.0.3"
   },
   "description": "SwapKit - Helpers",
   "devDependencies": {
-    "@swapkit/toolboxes": "1.0.0-beta.0"
+    "@swapkit/toolboxes": "1.0.0-beta.1"
   },
   "exports": {
     ".": {
@@ -38,18 +39,20 @@
   "license": "Apache-2.0",
   "name": "@swapkit/helpers",
   "repository": {
+    "directory": "packages/helpers",
     "type": "git",
     "url": "git+https://github.com/thorswap/SwapKit.git"
   },
   "scripts": {
     "build": "bun run ./build.ts",
+    "build:clean": "rm -rf dist && bun run ./build.ts",
     "clean": "rm -rf dist node_modules *.tsbuildinfo",
-    "lint": "biome check --write ./src",
     "generate-tokens": "bun --bun ./fetchTokenLists.ts",
     "test": "bun test",
     "test:ci": "bun test --coverage",
-    "type-check": "tsc --noEmit"
+    "type-check": "bun tsc --noEmit",
+    "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "3.0.0-beta.0"
+  "version": "3.0.0-beta.1"
 }

package/src/api/midgard/endpoints.ts

@@ -7,160 +7,148 @@ import type {
   THORNameDetails,
 } from "./types";
 
-// TODO: question: Move to SKConfig under midgardUrls
-// also - shouldn't that be named `isThorchain`?
-// As we default to TC and this is the only place that checks for opposite
-function getMidgardBaseUrl(isMayachain = false) {
-  return isMayachain ? "https://midgard.mayachain.info" : "https://midgard.ninerealms.com";
+function getMidgardBaseUrl(isThorchain = true) {
+  return isThorchain ? "https://midgard.ninerealms.com" : "https://midgard.mayachain.info";
 }
 
-function getNameServiceBaseUrl(isMayachain = false) {
-  return isMayachain
-    ? `${getMidgardBaseUrl(isMayachain)}/v2/mayaname`
-    : `${getMidgardBaseUrl(isMayachain)}/v2/thorname`;
+function getNameServiceBaseUrl(isThorchain = true) {
+  const baseUrl = getMidgardBaseUrl(isThorchain);
+  return isThorchain ? `${baseUrl}/v2/thorname` : `${baseUrl}/v2/mayaname`;
 }
 
-export function getBorrowerDetailRaw(address: string, isMayachain = false) {
-  return RequestClient.get<BorrowerDetails>(
-    `${getMidgardBaseUrl(isMayachain)}/v2/borrower/${address}`,
-  );
+function getBorrowerDetailRaw(baseUrl: string) {
+  return function getBorrowerDetail(address: string) {
+    return RequestClient.get<BorrowerDetails>(`${baseUrl}/v2/borrower/${address}`);
+  };
 }
 
-export function getSaverDetailRaw(address: string, isMayachain = false) {
-  return RequestClient.get<SaverDetails>(`${getMidgardBaseUrl(isMayachain)}/v2/saver/${address}`);
+function getSaverDetailRaw(baseUrl: string) {
+  return function getSaverDetail(address: string) {
+    return RequestClient.get<SaverDetails>(`${baseUrl}/v2/saver/${address}`);
+  };
 }
 
-export function getLiquidityPositionRaw<T extends boolean = false>(
-  address: string,
-  isMayachain?: T,
-) {
-  return RequestClient.get<T extends true ? MemberDetailsMayachain : MemberDetailsThorchain>(
-    `${getMidgardBaseUrl(isMayachain)}/v2/member/${address}`,
-  );
+function getLiquidityPositionRaw<Chain extends Chain.THORChain | Chain.Maya>(baseUrl: string) {
+  return function getLiquidityPosition(
+    address: string,
+  ): Promise<Chain extends Chain.THORChain ? MemberDetailsThorchain : MemberDetailsMayachain> {
+    return RequestClient.get<
+      Chain extends Chain.THORChain ? MemberDetailsThorchain : MemberDetailsMayachain
+    >(`${baseUrl}/v2/member/${address}`);
+  };
 }
 
-export function getNameDetails(name: string, isMayachain = false) {
-  return RequestClient.get<THORNameDetails>(`${getNameServiceBaseUrl(isMayachain)}/lookup/${name}`);
+function getNameDetails(baseUrl: string) {
+  return function getNameDetails(name: string) {
+    return RequestClient.get<THORNameDetails>(`${baseUrl}/lookup/${name}`);
+  };
 }
 
-export function getNamesByAddress(address: string, isMayachain = false) {
-  return RequestClient.get<THORNameDetails>(
-    `${getNameServiceBaseUrl(isMayachain)}/rlookup/${address}`,
-  );
+function getNamesByAddress(baseUrl: string) {
+  return function getNamesByAddress(address: string) {
+    return RequestClient.get<string[]>(`${baseUrl}/rlookup/${address}`);
+  };
 }
 
-export function getNamesByOwner(address: string, isMayachain = false) {
-  return RequestClient.get<THORNameDetails>(
-    `${getNameServiceBaseUrl(isMayachain)}/owner/${address}`,
-  );
+function getNamesByOwner(baseUrl: string) {
+  return function getNamesByOwner(address: string) {
+    return RequestClient.get<string[]>(`${baseUrl}/owner/${address}`);
+  };
 }
 
-export async function getBorrowerDetail(address: string, isMayachain = false) {
-  const rawBorrowerDetail = await getBorrowerDetailRaw(address, isMayachain);
-
-  return rawBorrowerDetail.pools.map((p) => ({
-    collateral_deposited: AssetValue.from({
-      asset: p.collateral_asset,
-      value: p.collateral_deposited,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    collateral_withdrawn: AssetValue.from({
-      asset: p.collateral_asset,
-      value: p.collateral_withdrawn,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    debt_issued_tor: SwapKitNumber.fromBigInt(BigInt(p.debt_issued_tor), BaseDecimal.THOR),
-    debt_repaid_tor: SwapKitNumber.fromBigInt(BigInt(p.debt_repaid_tor), BaseDecimal.THOR),
-    last_open_loan_timestamp: p.last_open_loan_timestamp,
-    last_repay_loan_timestamp: p.last_repay_loan_timestamp,
-    target_assets: p.target_assets.map((asset) => AssetValue.from({ asset })),
-  }));
+function getBorrowerDetail(borrowerDetailGetter: ReturnType<typeof getBorrowerDetailRaw>) {
+  return async function getBorrowerDetail(address: string) {
+    const rawBorrowerDetail = await borrowerDetailGetter(address);
+
+    return rawBorrowerDetail.pools.map((p) => ({
+      collateral_deposited: AssetValue.from({
+        asset: p.collateral_asset,
+        value: p.collateral_deposited,
+        fromBaseDecimal: BaseDecimal.THOR,
+      }),
+      collateral_withdrawn: AssetValue.from({
+        asset: p.collateral_asset,
+        value: p.collateral_withdrawn,
+        fromBaseDecimal: BaseDecimal.THOR,
+      }),
+      debt_issued_tor: SwapKitNumber.fromBigInt(BigInt(p.debt_issued_tor), BaseDecimal.THOR),
+      debt_repaid_tor: SwapKitNumber.fromBigInt(BigInt(p.debt_repaid_tor), BaseDecimal.THOR),
+      last_open_loan_timestamp: p.last_open_loan_timestamp,
+      last_repay_loan_timestamp: p.last_repay_loan_timestamp,
+      target_assets: p.target_assets.map((asset) => AssetValue.from({ asset })),
+    }));
+  };
 }
 
-export async function getSaverDetail(address: string, isMayachain = false) {
-  const rawSaverPositions = await getSaverDetailRaw(address, isMayachain);
-
-  return rawSaverPositions.pools.map((p) => ({
-    assetRegisteredAddress: p.assetAddress,
-    assetAdded: AssetValue.from({
-      asset: p.pool,
-      value: p.assetAdded,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    assetDeposit: AssetValue.from({
-      asset: p.pool,
-      value: p.assetDeposit,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    assetRedeem: AssetValue.from({
-      asset: p.pool,
-      value: p.assetRedeem,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    assetWithdrawn: AssetValue.from({
-      asset: p.pool,
-      value: p.assetWithdrawn,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    dateLastAdded: p.dateLastAdded,
-    dateFirstAdded: p.dateFirstAdded,
-  }));
+function getPoolAsset({ asset, value }: { asset: string; value: string }) {
+  return AssetValue.from({ asset, value, fromBaseDecimal: BaseDecimal.THOR });
 }
 
-export async function getLiquidityPosition(address: string, isMayachain = false) {
-  const rawLiquidityPositions = await getLiquidityPositionRaw(address, isMayachain);
-
-  return rawLiquidityPositions.pools.map((p) => ({
-    assetRegisteredAddress: p.assetAddress,
-    asset: AssetValue.from({
-      asset: p.pool,
-      value: p.assetAdded,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    assetPending: AssetValue.from({
-      asset: p.pool,
-      value: p.assetPending,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    assetWithdrawn: AssetValue.from({
-      asset: p.pool,
-      value: p.assetWithdrawn,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    [`${isMayachain ? "cacao" : "rune"}RegisteredAddress`]: p.runeAddress,
-    [`${isMayachain ? "cacao" : "rune"}`]: AssetValue.from({
-      asset: "THOR.RUNE",
-      value: p.runeAdded,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    [`${isMayachain ? "cacao" : "rune"}Pending`]: AssetValue.from({
-      asset: "THOR.RUNE",
-      value: p.runePending,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    [`${isMayachain ? "cacao" : "rune"}Withdrawn`]: AssetValue.from({
-      asset: "THOR.RUNE",
-      value: p.runeWithdrawn,
-      fromBaseDecimal: BaseDecimal.THOR,
-    }),
-    poolShare: new SwapKitNumber(p.liquidityUnits).div(p.pool),
-    dateLastAdded: p.dateLastAdded,
-    dateFirstAdded: p.dateFirstAdded,
-  }));
+function getSaverDetail(saverDetailGetter: ReturnType<typeof getSaverDetailRaw>) {
+  return async function getSaverDetail(address: string) {
+    const rawSaverPositions = await saverDetailGetter(address);
+
+    return rawSaverPositions.pools.map((p) => ({
+      assetAdded: getPoolAsset({ asset: p.pool, value: p.assetAdded }),
+      assetDeposit: getPoolAsset({ asset: p.pool, value: p.assetDeposit }),
+      assetRedeem: getPoolAsset({ asset: p.pool, value: p.assetRedeem }),
+      assetWithdrawn: getPoolAsset({ asset: p.pool, value: p.assetWithdrawn }),
+      assetRegisteredAddress: p.assetAddress,
+      dateFirstAdded: p.dateFirstAdded,
+      dateLastAdded: p.dateLastAdded,
+    }));
+  };
 }
 
-const getMidgardMethodsForProtocol = (chain: Chain.THORChain | Chain.Maya) => ({
-  getBorrowerDetail: (address: string) => getBorrowerDetail(address, chain === Chain.Maya),
-  getBorrowerDetailRaw: (address: string) => getBorrowerDetailRaw(address, chain === Chain.Maya),
-  getSaversDetail: (address: string) => getSaverDetail(address, chain === Chain.Maya),
-  getSaverDetailRaw: (address: string) => getSaverDetailRaw(address, chain === Chain.Maya),
-  getLiquidityPosition: (address: string) => getLiquidityPosition(address, chain === Chain.Maya),
-  getLiquidityPositionRaw: (address: string) =>
-    getLiquidityPositionRaw(address, chain === Chain.Maya),
-  getNameDetails: (name: string) => getNameDetails(name, chain === Chain.Maya),
-  getNamesByAddress: (address: string) => getNamesByAddress(address, chain === Chain.Maya),
-  getNamesByOwner: (address: string) => getNamesByOwner(address, chain === Chain.Maya),
-});
+function getLiquidityPosition<IsThorchain extends boolean = true>({
+  liquidityPositionGetter,
+  isThorchain,
+}: {
+  liquidityPositionGetter: ReturnType<
+    typeof getLiquidityPositionRaw<IsThorchain extends true ? Chain.THORChain : Chain.Maya>
+  >;
+  isThorchain: IsThorchain;
+}) {
+  return async function getLiquidityPosition(address: string) {
+    const rawLiquidityPositions = await liquidityPositionGetter(address);
+    const fieldPrefix = isThorchain ? "rune" : "cacao";
+
+    return rawLiquidityPositions.pools.map((p) => ({
+      [`${fieldPrefix}Pending`]: getPoolAsset({ asset: "THOR.RUNE", value: p.runePending }),
+      [`${fieldPrefix}RegisteredAddress`]: p.runeAddress,
+      [`${fieldPrefix}Withdrawn`]: getPoolAsset({ asset: "THOR.RUNE", value: p.runeWithdrawn }),
+      [fieldPrefix]: getPoolAsset({ asset: "THOR.RUNE", value: p.runeAdded }),
+      asset: getPoolAsset({ asset: p.pool, value: p.assetAdded }),
+      assetPending: getPoolAsset({ asset: p.pool, value: p.assetPending }),
+      assetRegisteredAddress: p.assetAddress,
+      assetWithdrawn: getPoolAsset({ asset: p.pool, value: p.assetWithdrawn }),
+      dateFirstAdded: p.dateFirstAdded,
+      dateLastAdded: p.dateLastAdded,
+      poolShare: new SwapKitNumber(p.liquidityUnits).div(p.pool),
+    }));
+  };
+}
+
+function getMidgardMethodsForProtocol<T extends Chain.THORChain | Chain.Maya>(chain: T) {
+  const isThorchain = chain === Chain.THORChain;
+  const midgardBaseUrl = getMidgardBaseUrl(isThorchain);
+  const nameServiceBaseUrl = getNameServiceBaseUrl(isThorchain);
+  const liquidityPositionGetter = getLiquidityPositionRaw<T>(midgardBaseUrl);
+  const borrowerDetailGetter = getBorrowerDetailRaw(midgardBaseUrl);
+  const saverDetailGetter = getSaverDetailRaw(midgardBaseUrl);
+
+  return {
+    getLiquidityPositionRaw: liquidityPositionGetter,
+    getBorrowerDetailRaw: borrowerDetailGetter,
+    getSaverDetailRaw: saverDetailGetter,
+    getBorrowerDetail: getBorrowerDetail(borrowerDetailGetter),
+    getSaversDetail: getSaverDetail(saverDetailGetter),
+    getNameDetails: getNameDetails(nameServiceBaseUrl),
+    getNamesByAddress: getNamesByAddress(nameServiceBaseUrl),
+    getNamesByOwner: getNamesByOwner(nameServiceBaseUrl),
+    getLiquidityPosition: getLiquidityPosition({ liquidityPositionGetter, isThorchain }),
+  };
+}
 
 export const thorchainMidgard = getMidgardMethodsForProtocol(Chain.THORChain);
 export const mayachainMidgard = getMidgardMethodsForProtocol(Chain.Maya);

package/src/api/swapkitApi/endpoints.ts

@@ -1,7 +1,16 @@
-import crypto from "crypto";
-import { ProviderName, RequestClient, SKConfig, SwapKitError, warnOnce } from "@swapkit/helpers";
+import {
+  type Chain,
+  type EVMChain,
+  EVMChains,
+  type ProviderName,
+  RequestClient,
+  SKConfig,
+  SwapKitError,
+  isGasAsset,
+} from "@swapkit/helpers";
 
 import {
+  type BalanceResponse,
   type BrokerDepositChannelParams,
   type DepositChannelResponse,
   DepositChannelResponseSchema,
@@ -19,56 +28,12 @@ import {
   type TrackerResponse,
 } from "./types";
 
-function getApiUrl(path?: `/${string}`) {
-  const { isDev, apiUrl, devApiUrl } = SKConfig.get("envs");
-
-  return `${isDev ? devApiUrl : apiUrl}${path}`;
-}
-
-function getAuthHeaders(hash?: string) {
-  const { swapKit } = SKConfig.get("apiKeys");
-  const { referer } = SKConfig.get("envs");
-
-  return {
-    ...(swapKit && !hash ? { "x-api-key": swapKit } : {}),
-    ...(hash && referer ? { "x-payload-hash": hash, referer } : {}),
-  };
+export function getTrackerDetails(json: TrackerParams) {
+  return RequestClient.post<TrackerResponse>(getApiUrl("/track"), { json });
 }
 
-export const computeHash = (
-  hashParams: { method: "POST"; payload: any } | { method: "GET"; url: string },
-) => {
-  const { swapKit } = SKConfig.get("apiKeys");
-  const { referer } = SKConfig.get("envs");
-
-  if (!(referer && swapKit)) return;
-
-  if (!["POST", "GET"].includes(hashParams.method)) {
-    throw new SwapKitError("api_v2_invalid_method_key_hash", {
-      message: `Invalid method for params: ${JSON.stringify(hashParams)}`,
-    });
-  }
-
-  const data =
-    hashParams.method === "POST"
-      ? JSON.stringify(hashParams.payload)
-      : `${hashParams.url}${swapKit}`;
-
-  return crypto.createHash("sha256").update(data, "utf8").digest("hex");
-};
-
-export function getTrackerDetails(payload: TrackerParams) {
-  return RequestClient.post<TrackerResponse>(getApiUrl("/track"), {
-    json: payload,
-    headers: getAuthHeaders(computeHash({ method: "POST", payload })),
-  });
-}
-
-export async function getSwapQuote(searchParams: QuoteRequest) {
-  const response = await RequestClient.post<QuoteResponse>(getApiUrl("/quote"), {
-    json: searchParams,
-    headers: getAuthHeaders(computeHash({ method: "POST", payload: searchParams })),
-  });
+export async function getSwapQuote(json: QuoteRequest) {
+  const response = await RequestClient.post<QuoteResponse>(getApiUrl("/quote"), { json });
 
   if (response.error) {
     throw new SwapKitError("api_v2_server_error", { message: response.error });
@@ -89,33 +54,32 @@ export async function getSwapQuote(searchParams: QuoteRequest) {
   }
 }
 
-/**
- * @deprecated use getTokenListProviders instead
- */
-export function getTokenListProvidersV2() {
-  warnOnce(true, "getTokenListProvidersV2 is deprecated, use getTokenListProviders instead");
-  return getTokenListProviders();
+export async function getChainBalance<T extends Chain>({
+  chain,
+  address,
+  scamFilter = true,
+}: { chain: T; address: string; scamFilter?: boolean }) {
+  const url = getApiUrl(`/balance?chain=${chain}&address=${address}`);
+  const balanceResponse = await RequestClient.get<BalanceResponse>(url);
+  const balances = Array.isArray(balanceResponse) ? balanceResponse : [];
+
+  return scamFilter ? filterAssets(balances) : balances;
 }
 
 export function getTokenListProviders() {
   const url = getApiUrl("/providers");
-  return RequestClient.get<TokenListProvidersResponse>(url, {
-    headers: getAuthHeaders(computeHash({ method: "GET", url })),
-  });
+  return RequestClient.get<TokenListProvidersResponse>(url);
 }
 
 export function getTokenList(provider: ProviderName) {
   const url = getApiUrl(`/tokens?provider=${provider}`);
-  return RequestClient.get<TokensResponseV2>(url, {
-    headers: getAuthHeaders(computeHash({ method: "GET", url })),
-  });
+  return RequestClient.get<TokensResponseV2>(url);
 }
 
 export async function getPrice(body: PriceRequest) {
   const url = getApiUrl("/price");
   const response = await RequestClient.post<PriceResponse>(url, {
     json: body,
-    headers: getAuthHeaders(computeHash({ method: "POST", payload: body })),
   });
 
   try {
@@ -133,10 +97,7 @@ export async function getPrice(body: PriceRequest) {
 
 export async function getGasRate() {
   const url = getApiUrl("/gas");
-
-  const response = await RequestClient.get<GasResponse>(url, {
-    headers: getAuthHeaders(computeHash({ method: "GET", url })),
-  });
+  const response = await RequestClient.get<GasResponse>(url);
 
   try {
     const parsedResponse = GasResponseSchema.safeParse(response);
@@ -151,97 +112,6 @@ export async function getGasRate() {
   }
 }
 
-const UNCHAINABLE_PROVIDERS = [
-  ProviderName.CAVIAR_V1,
-  ProviderName.CHAINFLIP,
-  ProviderName.CHAINFLIP_STREAMING,
-  ProviderName.MAYACHAIN,
-  ProviderName.MAYACHAIN_STREAMING,
-];
-
-const CHAINABLE_PROVIDERS = [
-  ProviderName.ONEINCH,
-  ProviderName.PANCAKESWAP,
-  ProviderName.PANGOLIN_V1,
-  ProviderName.SUSHISWAP_V2,
-  ProviderName.THORCHAIN,
-  ProviderName.THORCHAIN_STREAMING,
-  ProviderName.TRADERJOE_V2,
-  ProviderName.UNISWAP_V2,
-  ProviderName.UNISWAP_V3,
-];
-
-// TODO update this once the trading pairs are supported by BE api
-export async function getTokenTradingPairs(providers: ProviderName[]) {
-  const tradingPairs = new Map<
-    string,
-    {
-      tokens: TokensResponseV2["tokens"];
-      providers: ProviderName[];
-    }
-  >();
-
-  if (!providers.length) return tradingPairs;
-
-  const providerRequests = providers.map(async (provider) => {
-    const tokenList = await getTokenList(provider);
-    return tokenList;
-  });
-
-  const providersData = (await Promise.all(providerRequests))
-    .filter((provider) => !!provider)
-    .map(({ tokens, ...rest }) => ({
-      data: {
-        ...(rest || {}),
-        tokens: tokens.map(({ address, ...rest }) => ({
-          ...rest,
-          ...(address &&
-          [
-            "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd",
-            "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-          ].includes(address.toLowerCase())
-            ? {}
-            : { address }),
-        })),
-      },
-      ...rest,
-    }));
-
-  const chainableTokens = providersData
-    .filter(({ data }) => {
-      return !UNCHAINABLE_PROVIDERS.includes((data?.provider || "") as ProviderName);
-    })
-    .reduce(
-      (acc, { data }) => (data?.tokens ? acc.concat(data.tokens) : acc),
-      [] as TokensResponseV2["tokens"],
-    );
-
-  for (const { data } of providersData) {
-    if (!data?.tokens) return;
-
-    const isProviderChainable =
-      data.provider && !UNCHAINABLE_PROVIDERS.includes(data.provider as ProviderName);
-
-    for (const token of data.tokens) {
-      const existingTradingPairs = tradingPairs.get(token.identifier.toLowerCase()) || {
-        tokens: [],
-        providers: [],
-      };
-
-      const tradingPairsForToken = isProviderChainable
-        ? { tokens: chainableTokens, providers: CHAINABLE_PROVIDERS }
-        : { tokens: data.tokens, providers: data.provider };
-
-      tradingPairs.set(token.identifier.toLowerCase(), {
-        tokens: existingTradingPairs.tokens.concat(tradingPairsForToken.tokens),
-        providers: existingTradingPairs.providers.concat(tradingPairsForToken.providers),
-      });
-    }
-  }
-
-  return tradingPairs;
-}
-
 export async function getChainflipDepositChannel(body: BrokerDepositChannelParams) {
   const { destinationAddress } = body;
 
@@ -264,3 +134,28 @@ export async function getChainflipDepositChannel(body: BrokerDepositChannelParam
     throw new SwapKitError("api_v2_invalid_response", error);
   }
 }
+
+function getApiUrl(path?: `/${string}`) {
+  const { isDev, apiUrl, devApiUrl } = SKConfig.get("envs");
+
+  return `${isDev ? devApiUrl : apiUrl}${path}`;
+}
+
+function evmAssetHasAddress(assetString: string) {
+  const [chain, symbol] = assetString.split(".") as [EVMChain, string];
+  if (!EVMChains.includes(chain as EVMChain)) return true;
+  const splitSymbol = symbol.split("-");
+  const address = splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
+
+  return isGasAsset({ chain: chain as Chain, symbol }) || !!address;
+}
+
+const potentialScamRegex = new RegExp(
+  /(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/,
+  "gmi",
+);
+function filterAssets(tokens: BalanceResponse) {
+  return tokens.filter((token) => {
+    return !potentialScamRegex.test(token.identifier) && evmAssetHasAddress(token.identifier);
+  });
+}