@0xsquid/react-hooks 1.0.4 → 1.0.6

package/src/services/internal/transactionStatusService.ts

@@ -1,293 +0,0 @@
-import { SquidStatusErrorType } from "@/core/types/error";
-import type {
-  StepStatusGetterProps,
-  TransactionParams,
-} from "@/core/types/transaction";
-import {
-  AxelarStatusResponseType,
-  TransactionStatus,
-  TransactionType,
-} from "@/core/types/transaction";
-import type { ChainData, StatusResponse, Token } from "@0xsquid/sdk/dist/types";
-import type { UseQueryResult } from "@tanstack/react-query";
-import { isStatusError } from "./errorService";
-import { getMainExplorerUrl } from "./transactionService";
-
-/**
- * Get the steps for a transaction
- * First step and second step are always the same
- * @param transaction
- * @param statusResponse
- * @returns {TransactionStepStatus[]}
- */
-export const getStepStatuses = ({
-  transaction,
-  statusResponse,
-  onlyFullStatusStep,
-}: StepStatusGetterProps): TransactionStatus[] => {
-  let firstStepStatus: TransactionStatus;
-
-  // "warning" state is a custom one indicating that
-  // the user is taking too much time to validate the transaction
-  // And can be set to loading
-  switch (transaction?.sourceStatus) {
-    case "error":
-    case "success":
-    case "ongoing":
-      firstStepStatus = transaction.sourceStatus;
-      break;
-    case "warning":
-      firstStepStatus = TransactionStatus.ONGOING;
-      break;
-    default:
-      firstStepStatus = TransactionStatus.PENDING;
-  }
-
-  let middleStepStatus: TransactionStatus =
-    !onlyFullStatusStep && firstStepStatus !== "success"
-      ? TransactionStatus.PENDING
-      : middleStepChecker(statusResponse);
-
-  const lastStepStatus = getLastStepStatus(firstStepStatus, middleStepStatus);
-
-  // Once we have the last step status,
-  // we have to override the middle step for some states
-  middleStepStatus =
-    middleStepStatus === "needs_gas" || middleStepStatus === "partial_success"
-      ? TransactionStatus.SUCCESS
-      : middleStepStatus;
-
-  return onlyFullStatusStep
-    ? [middleStepStatus]
-    : [firstStepStatus, middleStepStatus, lastStepStatus];
-};
-
-const getLastStepStatus = (
-  first: TransactionStatus,
-  middle: TransactionStatus
-): TransactionStatus => {
-  if (
-    first === TransactionStatus.PENDING ||
-    first === "ongoing" ||
-    first === "error"
-  ) {
-    return TransactionStatus.PENDING;
-  }
-
-  switch (middle) {
-    case "initialLoading":
-    case "ongoing":
-      return TransactionStatus.PENDING;
-    default:
-      return middle;
-  }
-};
-
-export const getHalfSuccessState = (
-  status?: TransactionStatus
-): TransactionStatus | undefined => {
-  switch (status) {
-    case "success":
-      return TransactionStatus.SUCCESS;
-    case "partial_success": // Received axlUSDC
-      return TransactionStatus.PARTIAL_SUCCESS;
-    case "needs_gas":
-      return TransactionStatus.NEEDS_GAS;
-    default:
-      return undefined;
-  }
-};
-
-const middleStepChecker = (
-  statusResponse?: UseQueryResult<any, unknown>
-): TransactionStatus => {
-  const squidStatus = statusResponse?.data;
-  const successState = getHalfSuccessState(
-    squidStatus?.squidTransactionStatus as TransactionStatus | undefined
-  );
-  if (successState) {
-    return successState;
-  }
-  if (squidStatus?.status === AxelarStatusResponseType.ERROR) {
-    const { error } = squidStatus;
-    if (isStatusError(error)) {
-      if (error.errorType === SquidStatusErrorType.NotFoundError) {
-        return TransactionStatus.ERROR;
-      }
-    }
-    return TransactionStatus.ERROR;
-  }
-
-  if (statusResponse?.isInitialLoading) {
-    return TransactionStatus.INITIAL_LOADING;
-  }
-
-  return TransactionStatus.ONGOING;
-};
-
-export const getStepsInfos = ({
-  fromChain,
-  toChain,
-  fromToken,
-  toToken,
-  amount,
-  txType,
-  transaction,
-  statusResponse,
-}: {
-  txType: TransactionType;
-  amount: string;
-  fromChain?: ChainData;
-  toChain?: ChainData;
-  fromToken?: Token;
-  toToken?: Token;
-  transaction?: TransactionParams;
-  statusResponse?: UseQueryResult<StatusResponse, unknown>;
-}): {
-  label: string;
-  status: TransactionStatus;
-  subTitle?: string;
-  link?: string;
-}[] => {
-  const [firstStepStatus, middleStepStatus, lastStepStatus] = getStepStatuses({
-    transaction,
-    statusResponse,
-  });
-
-  const payLabel = `Pay ${amount} ${fromToken?.symbol} on ${fromChain?.networkName}`;
-  const swapForUSDCLabel = `Swap ${fromToken?.symbol} for axlUSDC`;
-  const sendUSDCLabel = `Send axlUSDC to ${toChain?.networkName}`;
-  const swapUSDCLabel = `Swap axlUSDC for ${toToken?.symbol}`;
-  const receiveLabel = `Receive ${toToken?.symbol} on ${toChain?.networkName}`;
-  const axelarUrl = getMainExplorerUrl(transaction);
-  const sourceExplorerUrl = transaction?.sourceTxExplorerUrl;
-  const destinationExplorerUrl = statusResponse?.data?.toChain?.transactionUrl;
-
-  switch (txType) {
-    case TransactionType.CALL_BRIDGE_CALL:
-      return [
-        {
-          label: payLabel,
-          status: firstStepStatus,
-          link: sourceExplorerUrl,
-          subTitle: "View on explorer",
-        },
-        {
-          label: swapForUSDCLabel,
-          status:
-            firstStepStatus !== "success"
-              ? TransactionStatus.PENDING
-              : firstStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: sendUSDCLabel,
-          status: middleStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: swapUSDCLabel,
-          status:
-            middleStepStatus !== "success"
-              ? TransactionStatus.PENDING
-              : middleStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: receiveLabel,
-          status: lastStepStatus,
-          link: destinationExplorerUrl,
-          subTitle: "View on explorer",
-        },
-      ];
-    case TransactionType.CALL_BRIDGE:
-      return [
-        {
-          label: payLabel,
-          status: firstStepStatus,
-          link: sourceExplorerUrl,
-          subTitle: "View on explorer",
-        },
-        {
-          label: swapForUSDCLabel,
-          status:
-            firstStepStatus !== "success"
-              ? TransactionStatus.PENDING
-              : firstStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: sendUSDCLabel,
-          status: middleStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: receiveLabel,
-          status: lastStepStatus,
-          link: destinationExplorerUrl,
-          subTitle: "View on explorer",
-        },
-      ];
-    case TransactionType.BRIDGE:
-      return [
-        {
-          label: payLabel,
-          status: firstStepStatus,
-          link: sourceExplorerUrl,
-          subTitle: "View on explorer",
-        },
-        {
-          label: sendUSDCLabel,
-          status:
-            firstStepStatus !== "success"
-              ? TransactionStatus.PENDING
-              : firstStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: receiveLabel,
-          status: lastStepStatus,
-          link: destinationExplorerUrl,
-          subTitle: "View on explorer",
-        },
-      ];
-    case TransactionType.BRIDGE_CALL:
-      return [
-        {
-          label: payLabel,
-          status: firstStepStatus,
-          link: sourceExplorerUrl,
-          subTitle: "View on explorer",
-        },
-        {
-          label: sendUSDCLabel,
-          status:
-            firstStepStatus !== "success"
-              ? TransactionStatus.PENDING
-              : firstStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: swapUSDCLabel,
-          status: middleStepStatus,
-          link: axelarUrl,
-          subTitle: "View on Axelarscan",
-        },
-        {
-          label: receiveLabel,
-          status: lastStepStatus,
-          link: destinationExplorerUrl,
-          subTitle: "View on explorer",
-        },
-      ];
-    default:
-      return [];
-  }
-};

package/src/services/internal/walletService.ts

@@ -1,158 +0,0 @@
-import { walletStoreLinks, wallets } from "@/core/constants";
-import type { ConnectorID, TypedWindow, Wallet } from "@/core/types/wallet";
-import type { ChainData, CosmosChain } from "@0xsquid/sdk/dist/types";
-import { ChainType } from "@0xsquid/sdk/dist/types";
-import { fromBech32 } from "@cosmjs/encoding";
-import type { ChainInfo } from "@keplr-wallet/types";
-import { ethers } from "ethers";
-import getProperty from "lodash/get";
-import type { Chain } from "wagmi";
-
-export const formatWalletAddress = (
-  walletAddress: string | undefined,
-  trimLength: number = 5
-) => {
-  return walletAddress
-    ? walletAddress?.length > trimLength
-      ? `${walletAddress.slice(0, trimLength)}...${walletAddress.slice(
-          walletAddress.length - (trimLength - 2), // -2 here because the start of wallet is 0x
-          walletAddress.length
-        )}`.toLowerCase()
-      : walletAddress
-    : "";
-};
-
-export const isCosmosAddressValid = (chainPrefix: string, address: string) => {
-  try {
-    if (!address.toLowerCase().startsWith(chainPrefix)) {
-      throw new Error("Invalid address for this chain");
-    }
-    fromBech32(address);
-    return true;
-  } catch (error) {
-    return false;
-  }
-};
-
-export const isWalletAddressValid = (
-  chainData?: ChainData,
-  address?: string
-) => {
-  if (address) {
-    if (chainData?.chainType === ChainType.EVM) {
-      return ethers.utils.isAddress(address);
-    }
-    if (chainData?.chainType === ChainType.COSMOS) {
-      return isCosmosAddressValid(
-        (chainData as CosmosChain).bech32Config.bech32PrefixAccAddr,
-        address
-      );
-    }
-  }
-  return false;
-};
-
-export const getWalletByConnectorID = (
-  connectorID: ConnectorID
-): Wallet | undefined => {
-  return wallets.find((w) => w.connectorId === connectorID);
-};
-
-export const getCosmosChainInfosObject = (chain: ChainData): ChainInfo => {
-  const cosmosChain = chain as CosmosChain;
-  return {
-    ...cosmosChain,
-    chainName: cosmosChain.networkName,
-    chainId: cosmosChain.chainId.toString(),
-    rpc: cosmosChain.rpc.split("?chain")[0],
-    feeCurrencies: cosmosChain.feeCurrencies.map((c) => ({
-      ...c,
-      gasPriceStep: cosmosChain.gasPriceStep,
-    })),
-  };
-};
-
-export const isWalletExtensionInstalled = (wallet: Wallet) => {
-  if (
-    (wallet.connectorId === "metaMask" && !window.ethereum) ||
-    (wallet.connectorId === "keplr" && !(window as TypedWindow).keplr) ||
-    (wallet.connectorId === "leap" && !(window as TypedWindow).leap) ||
-    // Cosmostation has two different connectors for different extensions
-    ((wallet.connectorId === "cosmostationCosmos" ||
-      wallet.connectorId === "cosmostation") &&
-      !(window as TypedWindow).cosmostation) ||
-    (wallet.connectorId === "xdefi" && !(window as TypedWindow).xfi) ||
-    (wallet.connectorId === "bitget" && !(window as TypedWindow).bitkeep) ||
-    (wallet.connectorId === "exodus" && !(window as TypedWindow).exodus)
-  ) {
-    return false;
-  }
-  return true;
-};
-
-export const redirectExtensionStoreIfNotInstalled = (wallet: Wallet) => {
-  const { userAgent } = navigator;
-  let link;
-
-  if (!isWalletExtensionInstalled(wallet)) {
-    if (userAgent.indexOf("Firefox") > -1) {
-      link = walletStoreLinks[wallet.connectorId].firefox;
-    } else if (userAgent.indexOf("Chrome") > -1) {
-      link = walletStoreLinks[wallet.connectorId].chrome;
-    }
-
-    if (link && link !== "") {
-      (window as any)?.open(link, "_blank").focus();
-    }
-  }
-};
-
-/**
- * Get the value of an object property using a string path
- * E.G. window["cosmostation.providers.keplr"]
- * @param obj
- * @param path
- * @returns
- */
-export const getDescendantProp = (obj: any, path: string) => {
-  return path.split(".").reduce((acc, part) => acc && acc[part], obj);
-};
-
-export const formatChainsForWagmi = (chains: ChainData[]): Chain[] => {
-  return chains
-    ?.filter((c) => c.chainType === ChainType.EVM)
-    .map(
-      (c) =>
-        ({
-          id: +c.chainId,
-          name: c.networkName,
-          network: c.networkName,
-          contracts: {
-            multicall3: {
-              address: "0xcA11bde05977b3631167028862bE2a173976CA11",
-            },
-          },
-          nativeCurrency: c.nativeCurrency,
-          rpcUrls: { public: { http: [c.rpc] }, default: { http: [c.rpc] } },
-        }) as Chain
-    );
-};
-
-/**
- * Dynamically accesses a nested property of an object based on a dot-separated string path.
- * Returns the value of the property if found, otherwise undefined.
- * e.g. "xfi.keplr" will return window.xfi.keplr
- */
-export const accessProperty = (
-  object: Record<string, any>,
-  path: string
-): any => {
-  const value = getProperty(object, path);
-  if (value === undefined) {
-    console.error(`Property "${path}" not found while reading object`, object);
-  }
-  return value;
-};
-
-export const metamaskIcon = getWalletByConnectorID("metaMask")?.icon;
-export const EVMnetworkNotSupportedErrorCode = 4902;

package/src/tests/assetsService.test.ts

@@ -1,176 +0,0 @@
-import {
-  shareSubgraphId,
-  sortTokensBySharedSubgraphIds,
-  filterChains,
-} from "@/services/internal/assetsService";
-import { OnlineSquidData, fetchSquidData } from "./fetchSquidData";
-
-let squid: OnlineSquidData | undefined = undefined;
-let CHAINS: OnlineSquidData["chains"] = {};
-let TOKENS: OnlineSquidData["tokens"] = {};
-
-describe("assetsService", () => {
-  beforeAll(async () => {
-    squid = await fetchSquidData();
-    CHAINS = squid?.chains;
-    TOKENS = squid?.tokens;
-  });
-
-  describe("shareSubgraphId", () => {
-    test("should return false when no token has subgraph ids", () => {
-      expect(shareSubgraphId(TOKENS.BASE.USDBC, TOKENS.AVALANCHE.MAI)).toBe(
-        false
-      );
-    });
-
-    test("should return true when tokens share subgraph ids", () => {
-      expect(shareSubgraphId(TOKENS.AVALANCHE.USDC, TOKENS.ETHEREUM.USDC)).toBe(
-        true
-      );
-    });
-
-    test("should return false when tokens do not share subgraph ids", () => {
-      expect(shareSubgraphId(TOKENS.AVALANCHE.AVAX, TOKENS.ETHEREUM.ETH)).toBe(
-        false
-      );
-    });
-  });
-
-  describe("sortTokensBySharedSubgraphIds", () => {
-    test("should sort 'a' token first when it shares subgraph ids with the token to check", () => {
-      expect(
-        sortTokensBySharedSubgraphIds({
-          a: TOKENS.AVALANCHE.USDC,
-          b: TOKENS.ETHEREUM.WBTC,
-          tokenToCheck: TOKENS.ETHEREUM.USDC,
-        })
-      ).toBe(-1);
-    });
-
-    test("should sort 'b' token first when it shares subgraph ids with the token to check", () => {
-      expect(
-        sortTokensBySharedSubgraphIds({
-          a: TOKENS.AVALANCHE.USDC,
-          b: TOKENS.ETHEREUM.ETH,
-          tokenToCheck: TOKENS.ETHEREUM.WETH,
-        })
-      ).toBe(1);
-    });
-
-    test("should not change order when tokens do not share subgraph ids with the token to check", () => {
-      expect(
-        sortTokensBySharedSubgraphIds({
-          a: TOKENS.AVALANCHE.AVAX,
-          b: TOKENS.ETHEREUM.ETH,
-          tokenToCheck: TOKENS.ETHEREUM.USDC,
-        })
-      ).toBe(0);
-    });
-
-    test("should not change the order when both tokens share subgraph ids with the token to check", () => {
-      expect(
-        sortTokensBySharedSubgraphIds({
-          a: TOKENS.ETHEREUM.USDC,
-          b: TOKENS.AVALANCHE.axlUSDC,
-          tokenToCheck: TOKENS.AVALANCHE.USDC,
-        })
-      ).toBe(0);
-    });
-  });
-
-  describe("filterChains", () => {
-    test("return chains without changes when no chain is disabled or coming soon", () => {
-      const chains = [CHAINS.AVALANCHE, CHAINS.ETHEREUM, CHAINS.NOBLE];
-
-      expect(
-        filterChains({
-          chains,
-          config: {
-            comingSoonChainIds: undefined,
-            disabledChains: undefined,
-          },
-          direction: "from",
-        })
-      ).toEqual(chains);
-    });
-
-    test("sorts disabled chains to the end", () => {
-      expect(
-        filterChains({
-          chains: [CHAINS.MOONBEAM, CHAINS.POLYGON, CHAINS.BINANCE],
-          config: {
-            comingSoonChainIds: undefined,
-            disabledChains: { source: [CHAINS.POLYGON.chainId] },
-          },
-          direction: "from",
-        })
-      ).toEqual([CHAINS.MOONBEAM, CHAINS.BINANCE, CHAINS.POLYGON]);
-
-      expect(
-        filterChains({
-          chains: [CHAINS.POLYGON, CHAINS.CELO, CHAINS.BINANCE],
-          config: {
-            comingSoonChainIds: undefined,
-            disabledChains: { destination: [CHAINS.CELO.chainId] },
-          },
-          direction: "to",
-        })
-      ).toEqual([CHAINS.POLYGON, CHAINS.BINANCE, CHAINS.CELO]);
-    });
-
-    test("sorts coming soon chains to the end", () => {
-      expect(
-        filterChains({
-          chains: [CHAINS.LINEA, CHAINS.FANTOM, CHAINS.CELO],
-          config: {
-            disabledChains: undefined,
-            comingSoonChainIds: [CHAINS.LINEA.chainId],
-          },
-          direction: "from",
-        })
-      ).toEqual([CHAINS.FANTOM, CHAINS.CELO, CHAINS.LINEA]);
-
-      expect(
-        filterChains({
-          chains: [CHAINS.NOBLE, CHAINS.OPTIMISM, CHAINS.MANTLE],
-          config: {
-            disabledChains: undefined,
-            comingSoonChainIds: [CHAINS.NOBLE.chainId],
-          },
-          direction: "to",
-        })
-      ).toEqual([CHAINS.OPTIMISM, CHAINS.MANTLE, CHAINS.NOBLE]);
-    });
-
-    test("sorts available chains first, then disabled chains, and finally coming soon chains", () => {
-      const chains = [
-        CHAINS.MOONBEAM,
-        CHAINS.POLYGON,
-        CHAINS.BINANCE,
-        CHAINS.LINEA,
-        CHAINS.FANTOM,
-        CHAINS.CELO,
-      ];
-
-      expect(
-        filterChains({
-          chains,
-          config: {
-            disabledChains: {
-              source: [CHAINS.MOONBEAM.chainId, CHAINS.LINEA.chainId],
-            },
-            comingSoonChainIds: [CHAINS.POLYGON.chainId],
-          },
-          direction: "from",
-        })
-      ).toEqual([
-        CHAINS.BINANCE,
-        CHAINS.FANTOM,
-        CHAINS.CELO,
-        CHAINS.MOONBEAM,
-        CHAINS.LINEA,
-        CHAINS.POLYGON,
-      ]);
-    });
-  });
-});