create-stylus 0.0.5

package/templates/base/packages/nextjs/tailwind.config.js

@@ -0,0 +1,97 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: ["./app/**/*.{js,ts,jsx,tsx}", "./components/**/*.{js,ts,jsx,tsx}", "./utils/**/*.{js,ts,jsx,tsx}"],
+  plugins: [require("daisyui")],
+  darkMode: "class",
+  // DaisyUI theme colors
+  daisyui: {
+    themes: [
+      {
+        light: {
+          primary: "#93BBFB",
+          "primary-content": "#212638",
+          secondary: "#DAE8FF",
+          "secondary-content": "#212638",
+          accent: "#93BBFB",
+          "accent-content": "#212638",
+          neutral: "#212638",
+          "neutral-content": "#ffffff",
+          "base-100": "#ffffff",
+          "base-200": "#f4f8ff",
+          "base-300": "#DAE8FF",
+          "base-content": "#212638",
+          info: "#93BBFB",
+          success: "#34EEB6",
+          warning: "#FFCF72",
+          error: "#FF8863",
+
+          "--bg-border": "#ffffff",
+          "--round-color": "#000",
+          "--rounded-btn": "9999rem",
+          "--gradient-start": "#3283EB",
+          "--gradient-end": "#E3066E",
+
+          ".tooltip": {
+            "--tooltip-tail": "6px",
+          },
+          ".link": {
+            textUnderlineOffset: "2px",
+          },
+          ".link:hover": {
+            opacity: "80%",
+          },
+        },
+      },
+      {
+        dark: {
+          primary: "#212638",
+          "primary-content": "#F9FBFF",
+          secondary: "#323f61",
+          "secondary-content": "#F9FBFF",
+          accent: "#4969A6",
+          "accent-content": "#F9FBFF",
+          neutral: "#F9FBFF",
+          "neutral-content": "#385183",
+          "base-100": "#000",
+          "base-200": "#2A3655",
+          "base-300": "#212638",
+          "base-content": "#F9FBFF",
+          info: "#385183",
+          success: "#34EEB6",
+          warning: "#FFCF72",
+          error: "#FF8863",
+
+          "--bg-border": "#000000",
+          "--round-color": "#E3066E",
+          "--rounded-btn": "9999rem",
+          "--gradient-start": "#3283EB",
+          "--gradient-end": "#E3066E",
+
+          ".tooltip": {
+            "--tooltip-tail": "6px",
+            "--tooltip-color": "oklch(var(--p))",
+          },
+          ".link": {
+            textUnderlineOffset: "2px",
+          },
+          ".link:hover": {
+            opacity: "80%",
+          },
+        },
+      },
+    ],
+  },
+  theme: {
+    extend: {
+      fontFamily: {
+        sans: ["var(--font-dm-sans)", "system-ui", "sans-serif"],
+      },
+      boxShadow: {
+        center: "0 0 12px -2px rgb(0 0 0 / 0.05)",
+      },
+      animation: {
+        "pulse-fast": "pulse 1s cubic-bezier(0.4, 0, 0.6, 1) infinite",
+      },
+    },
+  },
+};

package/templates/base/packages/nextjs/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "paths": {
+      "~~/*": ["./*"]
+    },
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/templates/base/packages/nextjs/types/abitype/abi.d.ts

@@ -0,0 +1,16 @@
+import "abitype";
+import "~~/node_modules/viem/node_modules/abitype";
+
+type AddressType = string;
+
+declare module "abitype" {
+  export interface Register {
+    AddressType: AddressType;
+  }
+}
+
+declare module "~~/node_modules/viem/node_modules/abitype" {
+  export interface Register {
+    AddressType: AddressType;
+  }
+}

package/templates/base/packages/nextjs/types/utils.ts

@@ -0,0 +1,3 @@
+export type Tuple<T, MaxLength extends number = 10, Current extends T[] = []> = Current["length"] extends MaxLength
+  ? Current
+  : Current | Tuple<T, MaxLength, [T, ...Current]>;

package/templates/base/packages/nextjs/utils/scaffold-eth/block.ts

@@ -0,0 +1,17 @@
+import { Block, Transaction, TransactionReceipt } from "viem";
+
+export type TransactionWithFunction = Transaction & {
+  functionName?: string;
+  functionArgs?: any[];
+  functionArgNames?: string[];
+  functionArgTypes?: string[];
+};
+
+type TransactionReceipts = {
+  [key: string]: TransactionReceipt;
+};
+
+export type TransactionsTableProps = {
+  blocks: Block[];
+  transactionReceipts: TransactionReceipts;
+};

package/templates/base/packages/nextjs/utils/scaffold-eth/common.ts

@@ -0,0 +1,8 @@
+// To be used in JSON.stringify when a field might be bigint
+
+// https://wagmi.sh/react/faq#bigint-serialization
+export const replacer = (_key: string, value: unknown) => (typeof value === "bigint" ? value.toString() : value);
+
+export const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+
+export const isZeroAddress = (address: string) => address === ZERO_ADDRESS;

package/templates/base/packages/nextjs/utils/scaffold-eth/contract.ts

@@ -0,0 +1,352 @@
+import { getParsedError } from "./getParsedError";
+import { AllowedChainIds } from "../scaffold-stylus/networks";
+import { notification } from "./notification";
+import { MutateOptions } from "@tanstack/react-query";
+import {
+  Abi,
+  AbiParameter,
+  AbiParameterToPrimitiveType,
+  AbiParametersToPrimitiveTypes,
+  ExtractAbiEvent,
+  ExtractAbiEventNames,
+  ExtractAbiFunction,
+} from "abitype";
+import type { ExtractAbiFunctionNames } from "abitype";
+import type { Simplify } from "type-fest";
+import type { MergeDeepRecord } from "type-fest/source/merge-deep";
+import {
+  Address,
+  Block,
+  GetEventArgs,
+  GetTransactionReceiptReturnType,
+  GetTransactionReturnType,
+  Log,
+  TransactionReceipt,
+  WriteContractErrorType,
+} from "viem";
+import { Config, UseReadContractParameters, UseWatchContractEventParameters, UseWriteContractParameters } from "wagmi";
+import { WriteContractParameters, WriteContractReturnType, simulateContract } from "wagmi/actions";
+import { WriteContractVariables } from "wagmi/query";
+import deployedContractsData from "~~/contracts/deployedContracts";
+import externalContractsData from "~~/contracts/externalContracts";
+import scaffoldConfig from "~~/scaffold.config";
+
+type AddExternalFlag<T> = {
+  [ChainId in keyof T]: {
+    [ContractName in keyof T[ChainId]]: T[ChainId][ContractName] & { external?: true };
+  };
+};
+
+const deepMergeContracts = <L extends Record<PropertyKey, any>, E extends Record<PropertyKey, any>>(
+  local: L,
+  external: E,
+) => {
+  const result: Record<PropertyKey, any> = {};
+  const allKeys = Array.from(new Set([...Object.keys(external), ...Object.keys(local)]));
+  for (const key of allKeys) {
+    if (!external[key]) {
+      result[key] = local[key];
+      continue;
+    }
+    const amendedExternal = Object.fromEntries(
+      Object.entries(external[key] as Record<string, Record<string, unknown>>).map(([contractName, declaration]) => [
+        contractName,
+        { ...declaration, external: true },
+      ]),
+    );
+    result[key] = { ...local[key], ...amendedExternal };
+  }
+  return result as MergeDeepRecord<AddExternalFlag<L>, AddExternalFlag<E>, { arrayMergeMode: "replace" }>;
+};
+
+const contractsData = deepMergeContracts(deployedContractsData, externalContractsData);
+
+export type InheritedFunctions = { readonly [key: string]: string };
+
+export type GenericContract = {
+  address: Address;
+  abi: Abi;
+  inheritedFunctions?: InheritedFunctions;
+  external?: true;
+  deployedOnBlock?: number;
+};
+
+export type GenericContractsDeclaration = {
+  [chainId: number]: {
+    [contractName: string]: GenericContract;
+  };
+};
+
+export const contracts = contractsData as GenericContractsDeclaration | null;
+
+type ConfiguredChainId = (typeof scaffoldConfig)["targetNetworks"][0]["id"];
+
+type IsContractDeclarationMissing<TYes, TNo> = typeof contractsData extends { [key in ConfiguredChainId]: any }
+  ? TNo
+  : TYes;
+
+type ContractsDeclaration = IsContractDeclarationMissing<GenericContractsDeclaration, typeof contractsData>;
+
+type Contracts = ContractsDeclaration[ConfiguredChainId];
+
+export type ContractName = keyof Contracts;
+
+export type Contract<TContractName extends ContractName> = Contracts[TContractName];
+
+type InferContractAbi<TContract> = TContract extends { abi: infer TAbi } ? TAbi : never;
+
+export type ContractAbi<TContractName extends ContractName = ContractName> = InferContractAbi<Contract<TContractName>>;
+
+export type AbiFunctionInputs<TAbi extends Abi, TFunctionName extends string> = ExtractAbiFunction<
+  TAbi,
+  TFunctionName
+>["inputs"];
+
+export type AbiFunctionArguments<TAbi extends Abi, TFunctionName extends string> = AbiParametersToPrimitiveTypes<
+  AbiFunctionInputs<TAbi, TFunctionName>
+>;
+
+export type AbiFunctionOutputs<TAbi extends Abi, TFunctionName extends string> = ExtractAbiFunction<
+  TAbi,
+  TFunctionName
+>["outputs"];
+
+export type AbiFunctionReturnType<TAbi extends Abi, TFunctionName extends string> = IsContractDeclarationMissing<
+  any,
+  AbiParametersToPrimitiveTypes<AbiFunctionOutputs<TAbi, TFunctionName>> extends readonly [any]
+    ? AbiParametersToPrimitiveTypes<AbiFunctionOutputs<TAbi, TFunctionName>>[0]
+    : AbiParametersToPrimitiveTypes<AbiFunctionOutputs<TAbi, TFunctionName>>
+>;
+
+export type AbiEventInputs<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = ExtractAbiEvent<
+  TAbi,
+  TEventName
+>["inputs"];
+
+export enum ContractCodeStatus {
+  "LOADING",
+  "DEPLOYED",
+  "NOT_FOUND",
+}
+
+type AbiStateMutability = "pure" | "view" | "nonpayable" | "payable";
+export type ReadAbiStateMutability = "view" | "pure";
+export type WriteAbiStateMutability = "nonpayable" | "payable";
+
+export type FunctionNamesWithInputs<
+  TContractName extends ContractName,
+  TAbiStateMutability extends AbiStateMutability = AbiStateMutability,
+> = Exclude<
+  Extract<
+    ContractAbi<TContractName>[number],
+    {
+      type: "function";
+      stateMutability: TAbiStateMutability;
+    }
+  >,
+  {
+    inputs: readonly [];
+  }
+>["name"];
+
+type Expand<T> = T extends object ? (T extends infer O ? { [K in keyof O]: O[K] } : never) : T;
+
+type UnionToIntersection<U> = Expand<(U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never>;
+
+type OptionalTuple<T> = T extends readonly [infer H, ...infer R] ? readonly [H | undefined, ...OptionalTuple<R>] : T;
+
+type UseScaffoldArgsParam<
+  TContractName extends ContractName,
+  TFunctionName extends ExtractAbiFunctionNames<ContractAbi<TContractName>>,
+> =
+  TFunctionName extends FunctionNamesWithInputs<TContractName>
+    ? {
+        args: OptionalTuple<UnionToIntersection<AbiFunctionArguments<ContractAbi<TContractName>, TFunctionName>>>;
+        value?: ExtractAbiFunction<ContractAbi<TContractName>, TFunctionName>["stateMutability"] extends "payable"
+          ? bigint | undefined
+          : undefined;
+      }
+    : {
+        args?: never;
+      };
+
+export type UseDeployedContractConfig<TContractName extends ContractName> = {
+  contractName: TContractName;
+  chainId?: AllowedChainIds;
+};
+
+export type UseScaffoldWriteConfig<TContractName extends ContractName> = {
+  contractName: TContractName;
+  chainId?: AllowedChainIds;
+  disableSimulate?: boolean;
+  writeContractParams?: UseWriteContractParameters;
+};
+
+export type UseScaffoldReadConfig<
+  TContractName extends ContractName,
+  TFunctionName extends ExtractAbiFunctionNames<ContractAbi<TContractName>, ReadAbiStateMutability>,
+> = {
+  contractName: TContractName;
+  chainId?: AllowedChainIds;
+  watch?: boolean;
+} & IsContractDeclarationMissing<
+  Partial<UseReadContractParameters>,
+  {
+    functionName: TFunctionName;
+  } & UseScaffoldArgsParam<TContractName, TFunctionName> &
+    Omit<UseReadContractParameters, "chainId" | "abi" | "address" | "functionName" | "args">
+>;
+
+export type ScaffoldWriteContractVariables<
+  TContractName extends ContractName,
+  TFunctionName extends ExtractAbiFunctionNames<ContractAbi<TContractName>, WriteAbiStateMutability>,
+> = IsContractDeclarationMissing<
+  Partial<WriteContractParameters>,
+  {
+    functionName: TFunctionName;
+  } & UseScaffoldArgsParam<TContractName, TFunctionName> &
+    Omit<WriteContractParameters, "chainId" | "abi" | "address" | "functionName" | "args">
+>;
+
+type WriteVariables = WriteContractVariables<Abi, string, any[], Config, number>;
+
+export type TransactorFuncOptions = {
+  onBlockConfirmation?: (txnReceipt: TransactionReceipt) => void;
+  blockConfirmations?: number;
+};
+
+export type ScaffoldWriteContractOptions = MutateOptions<
+  WriteContractReturnType,
+  WriteContractErrorType,
+  WriteVariables,
+  unknown
+> &
+  TransactorFuncOptions;
+
+export type UseScaffoldEventConfig<
+  TContractName extends ContractName,
+  TEventName extends ExtractAbiEventNames<ContractAbi<TContractName>>,
+  TEvent extends ExtractAbiEvent<ContractAbi<TContractName>, TEventName> = ExtractAbiEvent<
+    ContractAbi<TContractName>,
+    TEventName
+  >,
+> = {
+  contractName: TContractName;
+  eventName: TEventName;
+  chainId?: AllowedChainIds;
+} & IsContractDeclarationMissing<
+  Omit<UseWatchContractEventParameters, "onLogs" | "address" | "abi" | "eventName"> & {
+    onLogs: (
+      logs: Simplify<
+        Omit<Log<bigint, number, any>, "args" | "eventName"> & {
+          args: Record<string, unknown>;
+          eventName: string;
+        }
+      >[],
+    ) => void;
+  },
+  Omit<UseWatchContractEventParameters<ContractAbi<TContractName>>, "onLogs" | "address" | "abi" | "eventName"> & {
+    onLogs: (
+      logs: Simplify<
+        Omit<Log<bigint, number, false, TEvent, false, [TEvent], TEventName>, "args"> & {
+          args: AbiParametersToPrimitiveTypes<TEvent["inputs"]> &
+            GetEventArgs<
+              ContractAbi<TContractName>,
+              TEventName,
+              {
+                IndexedOnly: false;
+              }
+            >;
+        }
+      >[],
+    ) => void;
+  }
+>;
+
+type IndexedEventInputs<
+  TContractName extends ContractName,
+  TEventName extends ExtractAbiEventNames<ContractAbi<TContractName>>,
+> = Extract<AbiEventInputs<ContractAbi<TContractName>, TEventName>[number], { indexed: true }>;
+
+export type EventFilters<
+  TContractName extends ContractName,
+  TEventName extends ExtractAbiEventNames<ContractAbi<TContractName>>,
+> = IsContractDeclarationMissing<
+  any,
+  IndexedEventInputs<TContractName, TEventName> extends never
+    ? never
+    : {
+        [Key in IsContractDeclarationMissing<
+          any,
+          IndexedEventInputs<TContractName, TEventName>["name"]
+        >]?: AbiParameterToPrimitiveType<Extract<IndexedEventInputs<TContractName, TEventName>, { name: Key }>>;
+      }
+>;
+
+export type UseScaffoldEventHistoryConfig<
+  TContractName extends ContractName,
+  TEventName extends ExtractAbiEventNames<ContractAbi<TContractName>>,
+  TBlockData extends boolean = false,
+  TTransactionData extends boolean = false,
+  TReceiptData extends boolean = false,
+> = {
+  contractName: TContractName;
+  eventName: IsContractDeclarationMissing<string, TEventName>;
+  fromBlock: bigint;
+  toBlock?: bigint;
+  chainId?: AllowedChainIds;
+  filters?: EventFilters<TContractName, TEventName>;
+  blockData?: TBlockData;
+  transactionData?: TTransactionData;
+  receiptData?: TReceiptData;
+  watch?: boolean;
+  enabled?: boolean;
+  blocksBatchSize?: number;
+};
+
+export type UseScaffoldEventHistoryData<
+  TContractName extends ContractName,
+  TEventName extends ExtractAbiEventNames<ContractAbi<TContractName>>,
+  TBlockData extends boolean = false,
+  TTransactionData extends boolean = false,
+  TReceiptData extends boolean = false,
+  TEvent extends ExtractAbiEvent<ContractAbi<TContractName>, TEventName> = ExtractAbiEvent<
+    ContractAbi<TContractName>,
+    TEventName
+  >,
+> =
+  | IsContractDeclarationMissing<
+      any[],
+      {
+        args: AbiParametersToPrimitiveTypes<TEvent["inputs"]> &
+          GetEventArgs<
+            ContractAbi<TContractName>,
+            TEventName,
+            {
+              IndexedOnly: false;
+            }
+          >;
+        blockData: TBlockData extends true ? Block<bigint, true> : null;
+        receiptData: TReceiptData extends true ? GetTransactionReturnType : null;
+        transactionData: TTransactionData extends true ? GetTransactionReceiptReturnType : null;
+      } & Log<bigint, number, false, TEvent, false, [TEvent], TEventName>[]
+    >
+  | undefined;
+
+export type AbiParameterTuple = Extract<AbiParameter, { type: "tuple" | `tuple[${string}]` }>;
+
+export const simulateContractWriteAndNotifyError = async ({
+  wagmiConfig,
+  writeContractParams: params,
+}: {
+  wagmiConfig: Config;
+  writeContractParams: WriteContractVariables<Abi, string, any[], Config, number>;
+}) => {
+  try {
+    await simulateContract(wagmiConfig, params);
+  } catch (error) {
+    const parsedError = getParsedError(error);
+    notification.error(parsedError);
+    throw error;
+  }
+};

package/templates/base/packages/nextjs/utils/scaffold-eth/contractsData.ts

@@ -0,0 +1,11 @@
+import { useTargetNetwork } from "~~/hooks/scaffold-eth";
+import { GenericContractsDeclaration, contracts } from "~~/utils/scaffold-eth/contract";
+
+const DEFAULT_ALL_CONTRACTS: GenericContractsDeclaration[number] = {};
+
+export function useAllContracts() {
+  const { targetNetwork } = useTargetNetwork();
+  const contractsData = contracts?.[targetNetwork.id];
+  // using constant to avoid creating a new object on every call
+  return contractsData || DEFAULT_ALL_CONTRACTS;
+}

package/templates/base/packages/nextjs/utils/scaffold-eth/decodeTxData.ts

@@ -0,0 +1,65 @@
+import { TransactionWithFunction } from "./block";
+import { GenericContractsDeclaration } from "./contract";
+import { Abi, AbiFunction, decodeFunctionData, getAbiItem } from "viem";
+import { arbitrumNitro } from "~~/utils/scaffold-stylus/chain";
+import contractData from "~~/contracts/deployedContracts";
+
+type ContractsInterfaces = Record<string, Abi>;
+type TransactionType = TransactionWithFunction | null;
+
+const deployedContracts = contractData as GenericContractsDeclaration | null;
+const chainMetaData = deployedContracts?.[arbitrumNitro.id];
+const interfaces = chainMetaData
+  ? Object.entries(chainMetaData).reduce((finalInterfacesObj, [contractName, contract]) => {
+      finalInterfacesObj[contractName] = contract.abi;
+      return finalInterfacesObj;
+    }, {} as ContractsInterfaces)
+  : {};
+
+export const decodeTransactionData = (tx: TransactionWithFunction) => {
+  if (tx.input.length >= 10 && !tx.input.startsWith("0x60e06040")) {
+    let foundInterface = false;
+    for (const [, contractAbi] of Object.entries(interfaces)) {
+      try {
+        const { functionName, args } = decodeFunctionData({
+          abi: contractAbi,
+          data: tx.input,
+        });
+        tx.functionName = functionName;
+        tx.functionArgs = args as any[];
+        tx.functionArgNames = getAbiItem<AbiFunction[], string>({
+          abi: contractAbi as AbiFunction[],
+          name: functionName,
+        })?.inputs?.map((input: any) => input.name);
+        tx.functionArgTypes = getAbiItem<AbiFunction[], string>({
+          abi: contractAbi as AbiFunction[],
+          name: functionName,
+        })?.inputs.map((input: any) => input.type);
+        foundInterface = true;
+        break;
+      } catch {
+        // do nothing
+      }
+    }
+    if (!foundInterface) {
+      tx.functionName = "⚠️ Unknown";
+    }
+  }
+  return tx;
+};
+
+export const getFunctionDetails = (transaction: TransactionType) => {
+  if (
+    transaction &&
+    transaction.functionName &&
+    transaction.functionArgNames &&
+    transaction.functionArgTypes &&
+    transaction.functionArgs
+  ) {
+    const details = transaction.functionArgNames.map(
+      (name, i) => `${transaction.functionArgTypes?.[i] || ""} ${name} = ${transaction.functionArgs?.[i] ?? ""}`,
+    );
+    return `${transaction.functionName}(${details.join(", ")})`;
+  }
+  return "";
+};

package/templates/base/packages/nextjs/utils/scaffold-eth/fetchPriceFromUniswap.ts

@@ -0,0 +1,72 @@
+import { ChainWithAttributes, getAlchemyHttpUrl } from "../scaffold-stylus/networks";
+import { CurrencyAmount, Token } from "@uniswap/sdk-core";
+import { Pair, Route } from "@uniswap/v2-sdk";
+import { Address, createPublicClient, fallback, http, parseAbi } from "viem";
+import { mainnet } from "viem/chains";
+
+const alchemyHttpUrl = getAlchemyHttpUrl(mainnet.id);
+const rpcFallbacks = alchemyHttpUrl ? [http(alchemyHttpUrl), http()] : [http()];
+const publicClient = createPublicClient({
+  chain: mainnet,
+  transport: fallback(rpcFallbacks),
+});
+
+const ABI = parseAbi([
+  "function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)",
+  "function token0() external view returns (address)",
+  "function token1() external view returns (address)",
+]);
+
+export const fetchPriceFromUniswap = async (targetNetwork: ChainWithAttributes): Promise<number> => {
+  if (
+    targetNetwork.nativeCurrency.symbol !== "ETH" &&
+    targetNetwork.nativeCurrency.symbol !== "SEP" &&
+    !targetNetwork.nativeCurrencyTokenAddress
+  ) {
+    return 0;
+  }
+  try {
+    const DAI = new Token(1, "0x6B175474E89094C44Da98b954EedeAC495271d0F", 18);
+    const TOKEN = new Token(
+      1,
+      targetNetwork.nativeCurrencyTokenAddress || "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+      18,
+    );
+    const pairAddress = Pair.getAddress(TOKEN, DAI) as Address;
+
+    const wagmiConfig = {
+      address: pairAddress,
+      abi: ABI,
+    };
+
+    const reserves = await publicClient.readContract({
+      ...wagmiConfig,
+      functionName: "getReserves",
+    });
+
+    const token0Address = await publicClient.readContract({
+      ...wagmiConfig,
+      functionName: "token0",
+    });
+
+    const token1Address = await publicClient.readContract({
+      ...wagmiConfig,
+      functionName: "token1",
+    });
+    const token0 = [TOKEN, DAI].find(token => token.address === token0Address) as Token;
+    const token1 = [TOKEN, DAI].find(token => token.address === token1Address) as Token;
+    const pair = new Pair(
+      CurrencyAmount.fromRawAmount(token0, reserves[0].toString()),
+      CurrencyAmount.fromRawAmount(token1, reserves[1].toString()),
+    );
+    const route = new Route([pair], TOKEN, DAI);
+    const price = parseFloat(route.midPrice.toSignificant(6));
+    return price;
+  } catch (error) {
+    console.error(
+      `useNativeCurrencyPrice - Error fetching ${targetNetwork.nativeCurrency.symbol} price from Uniswap: `,
+      error,
+    );
+    return 0;
+  }
+};