solid-wagmi 0.1.0 → 0.2.1

package/dist/types/test/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../test/constants.ts"],"names":[],"mappings":"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"}

package/dist/types/test/lib.d.ts

@@ -0,0 +1,2 @@
+export declare function renderHook<HookFN extends () => unknown>(hookFn: HookFN): ReturnType<HookFN>;
+//# sourceMappingURL=lib.d.ts.map

package/dist/types/test/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../../test/lib.ts"],"names":[],"mappings":"AAUA,wBAAgB,UAAU,CAAC,MAAM,SAAS,MAAM,OAAO,EAAE,MAAM,EAAE,MAAM,sBAkBtE"}

package/dist/types/test/utils.d.ts

@@ -0,0 +1,17 @@
+export declare function getRpcUrls({ port }: {
+    port: number;
+}): {
+    readonly port: number;
+    readonly rpcUrls: {
+        readonly default: {
+            readonly http: readonly [`http://127.0.0.1:${number}/`];
+            readonly webSocket: readonly [`ws://127.0.0.1:${number}/`];
+        };
+        readonly public: {
+            readonly http: readonly [`http://127.0.0.1:${number}/`];
+            readonly webSocket: readonly [`ws://127.0.0.1:${number}/`];
+        };
+    };
+};
+export declare function wait(time: number): Promise<unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/test/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../test/utils.ts"],"names":[],"mappings":"AAMA,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;EAiBpD;AAED,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,oBAEtC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-wagmi",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Solid.js Hooks for Ethereum",
   "type": "module",
   "repository": {
@@ -13,7 +13,16 @@
   "files": [
     "dist/**",
     "!dist/**/*.tsbuildinfo",
-    "src/**/*.ts"
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "/actions",
+    "/chains",
+    "/codegen",
+    "/connectors",
+    "/experimental",
+    "/internal",
+    "/query"
   ],
   "exports": {
     ".": {
@@ -55,8 +64,17 @@
   ],
   "author": "",
   "license": "ISC",
+  "devDependencies": {
+    "@solidjs/testing-library": "^0.8.10",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/user-event": "^14.6.1",
+    "jsdom": "^27.1.0",
+    "prool": "^0.0.25",
+    "vite-plugin-solid": "^2.11.10",
+    "vitest": "^4.0.8"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest",
     "build": "pnpm run clean && pnpm run build:esm",
     "build:esm": "tsc --project tsconfig.build.json --outDir ./dist/esm --declaration --declarationMap --declarationDir ./dist/types",
     "clean": "rm -rf dist tsconfig.tsbuildinfo actions chains codegen connectors experimental query"

package/src/errors/context.ts

@@ -1,5 +1,7 @@
 export class WagmiProviderNotFoundError extends Error {
+  public static MESSAGE = "`useConfig` must be used withtin <WagmiProvider/>";
+
   constructor() {
-    super("`useConfig` must be used withtin <WagmiProvider/>");
+    super(WagmiProviderNotFoundError.MESSAGE);
   }
 }

package/src/exports/index.ts

@@ -13,11 +13,15 @@ export { WagmiProviderNotFoundError } from "../errors/context.js";
 // Hooks
 // ///////////////////////////////////////////////////////////////
 export { useAccount } from "../hooks/useAccount.js";
+export { useBalance } from "../hooks/useBalance.js";
 export { useChainId } from "../hooks/useChainId.js";
 export { useConfig } from "../hooks/useConfig.js";
 export { useConnect } from "../hooks/useConnect.js";
 export { useConnections } from "../hooks/useConnections.js";
 export { useDisconnect } from "../hooks/useDisconnect.js";
+export { useReadContract } from "../hooks/useReadContract.js";
+export { useReadContracts } from "../hooks/useReadContracts.js";
+export { useWriteContract } from "../hooks/useWriteContract.js";
 
 ////////////////////////////////////////////////////////////////////////////////
 // @wagmi/core

package/src/hooks/useAccount.ts

@@ -3,7 +3,7 @@ import { createSignal, onCleanup, onMount } from "solid-js";
 import { useConfig } from "./useConfig.js";
 
 export function useAccount() {
-  const { config } = useConfig();
+  const config = useConfig();
   const [account, setAccount] = createSignal(getAccount(config));
 
   // Watch account

package/src/hooks/useBalance.ts

@@ -0,0 +1,45 @@
+import { useQuery } from "@tanstack/solid-query";
+import type {
+  Config,
+  GetBalanceErrorType,
+  ResolvedRegister,
+} from "@wagmi/core";
+import type { Compute } from "@wagmi/core/internal";
+import {
+  getBalanceQueryOptions,
+  type GetBalanceData,
+  type GetBalanceOptions,
+  type GetBalanceQueryFnData,
+  type GetBalanceQueryKey,
+} from "@wagmi/core/query";
+import type { ConfigParameter, QueryParameter } from "../types/index.js";
+import { useChainId } from "./useChainId.js";
+import { useConfig } from "./useConfig.js";
+
+export type UseBalanceParameters<
+  config extends Config = ResolvedRegister["config"],
+  selectData = GetBalanceData
+> = Compute<
+  GetBalanceOptions<config> &
+    ConfigParameter<config> &
+    QueryParameter<
+      GetBalanceQueryFnData,
+      GetBalanceErrorType,
+      selectData,
+      GetBalanceQueryKey<config>
+    >
+>;
+export function useBalance(params: () => UseBalanceParameters) {
+  const config = useConfig(params);
+  const chain = useChainId();
+
+  const options = () =>
+    getBalanceQueryOptions(config, { chainId: chain().id, ...params() });
+  const enabled = () =>
+    Boolean(params().address && (params().query?.enabled ?? true));
+
+  return useQuery(() => ({
+    ...options(),
+    enabled: enabled(),
+  }));
+}

package/src/hooks/useChainId.ts

@@ -5,7 +5,7 @@ import { extractChain } from "viem";
 import { useConfig } from "./useConfig.js";
 
 export function useChainId() {
-  const { config } = useConfig();
+  const config = useConfig();
   const [chainId, setChainID] = createSignal(getChainId(config));
 
   // Watch chain id

package/src/hooks/useConfig.ts

@@ -1,11 +1,21 @@
-import { useContext } from "solid-js";
+import type { Config, ResolvedRegister } from "@wagmi/core";
+import { useContext, type Accessor } from "solid-js";
 import { WagmiContext } from "../context.js";
 import { WagmiProviderNotFoundError } from "../errors/context.js";
+import type { ConfigParameter } from "../types/index.js";
 
-export function useConfig() {
-  const config = useContext(WagmiContext);
+export type UseConfigParameters<config extends Config = Config> = Accessor<
+  ConfigParameter<config>
+>;
+
+export type UseConfigReturnType<config extends Config = Config> = config;
+
+export function useConfig<config extends Config = ResolvedRegister["config"]>(
+  parameters?: UseConfigParameters<config>
+): UseConfigReturnType<config> {
+  const config = parameters?.().config ?? useContext(WagmiContext);
 
   if (!config) throw new WagmiProviderNotFoundError();
 
-  return config;
+  return config as UseConfigReturnType<config>;
 }

package/src/hooks/useConnect.ts

@@ -4,7 +4,7 @@ import { createEffect, onCleanup } from "solid-js";
 import { useConfig } from "./useConfig.js";
 
 export function useConnect() {
-  const { config } = useConfig();
+  const config = useConfig();
 
   const mutationOptions = connectMutationOptions(config);
   const { mutate, mutateAsync, ...result } = useMutation(() => ({

package/src/hooks/useConnections.ts

@@ -3,7 +3,7 @@ import { createSignal, onCleanup, onMount } from "solid-js";
 import { useConfig } from "./useConfig.js";
 
 export function useConnections() {
-  const { config } = useConfig();
+  const config = useConfig();
   const [connections, setConnections] = createSignal(getConnections(config));
 
   let cleanup: VoidFunction | undefined;

package/src/hooks/useDisconnect.ts

@@ -5,7 +5,7 @@ import { useConfig } from "./useConfig.js";
 import { useConnections } from "./useConnections.js";
 
 export function useDisconnect() {
-  const { config } = useConfig();
+  const config = useConfig();
 
   const connections = useConnections();
   const mutationOptions = disconnectMutationOptions(config);

package/src/hooks/useReadContract.ts

@@ -0,0 +1,101 @@
+import { useQuery } from "@tanstack/solid-query";
+import type { Config, ResolvedRegister } from "@wagmi/core";
+import {
+  readContractQueryOptions,
+  type ReadContractData,
+  type ReadContractOptions,
+  type ReadContractQueryFnData,
+  type ReadContractQueryKey,
+} from "@wagmi/core/query";
+
+import type { UnionCompute } from "@wagmi/core/internal";
+import { type Accessor } from "solid-js";
+import {
+  type Abi,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+  type ReadContractErrorType,
+} from "viem";
+import type {
+  ConfigParameter,
+  QueryParameter,
+  UseQueryReturnType,
+} from "../types/index.js";
+import { useConfig } from "./useConfig.js";
+
+export type UseReadContractReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    "pure" | "view"
+  > = ContractFunctionName<abi, "pure" | "view">,
+  args extends ContractFunctionArgs<
+    abi,
+    "pure" | "view",
+    functionName
+  > = ContractFunctionArgs<abi, "pure" | "view", functionName>,
+  selectData = ReadContractData<abi, functionName, args>
+> = UseQueryReturnType<selectData, ReadContractErrorType>;
+
+export type UseReadContractParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    "pure" | "view"
+  > = ContractFunctionName<abi, "pure" | "view">,
+  args extends ContractFunctionArgs<
+    abi,
+    "pure" | "view",
+    functionName
+  > = ContractFunctionArgs<abi, "pure" | "view", functionName>,
+  config extends Config = Config,
+  selectData = ReadContractData<abi, functionName, args>
+> = UnionCompute<
+  ReadContractOptions<abi, functionName, args, config> &
+    ConfigParameter<config> &
+    QueryParameter<
+      ReadContractQueryFnData<abi, functionName, args>,
+      ReadContractErrorType,
+      selectData,
+      ReadContractQueryKey<abi, functionName, args, config>
+    >
+>;
+
+export function useReadContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, "pure" | "view">,
+  const args extends ContractFunctionArgs<abi, "pure" | "view", functionName>,
+  config extends Config = ResolvedRegister["config"],
+  selectData = ReadContractData<abi, functionName, args>
+>(
+  params: Accessor<
+    UseReadContractParameters<abi, functionName, args, config, selectData>
+  >
+): UseReadContractReturnType<abi, functionName, args, selectData> {
+  const config = useConfig(params);
+
+  return useQuery(() => {
+    const { address, abi, functionName, query = {} } = params();
+    const { initialData, ...queryLeftovers } = query;
+    // @ts-ignore
+    const code = params().code as Hex | undefined;
+
+    const options = readContractQueryOptions<config, abi, functionName, args>(
+      config,
+      params()
+    );
+    const enabled = Boolean(
+      (address || code) && abi && functionName && (query?.enabled ?? true)
+    );
+
+    return {
+      ...options,
+      ...queryLeftovers,
+
+      // Initial Data type gets messed up when wrapped in function
+      initiData:
+        initialData instanceof Function ? initialData()! : initialData!,
+      enabled,
+    };
+  });
+}

package/src/hooks/useReadContracts.ts

@@ -0,0 +1,104 @@
+import { useQuery } from "@tanstack/solid-query";
+import type {
+  Config,
+  ReadContractsErrorType,
+  ResolvedRegister,
+} from "@wagmi/core";
+import {
+  readContractsQueryOptions,
+  type ReadContractsData,
+  type ReadContractsOptions,
+  type ReadContractsQueryFnData,
+  type ReadContractsQueryKey,
+} from "@wagmi/core/query";
+
+import type { Compute } from "@wagmi/core/internal";
+import { createMemo, type Accessor } from "solid-js";
+import { type ContractFunctionParameters } from "viem";
+import type {
+  ConfigParameter,
+  QueryParameter,
+  UseQueryReturnType,
+} from "../types/index.js";
+import { useChainId } from "./useChainId.js";
+import { useConfig } from "./useConfig.js";
+
+export type UseReadContractsReturnType<
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+  selectData = ReadContractsData<contracts, allowFailure>
+> = UseQueryReturnType<selectData, ReadContractsErrorType>;
+
+export type UseReadContractsParameters<
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+  config extends Config = Config,
+  selectData = ReadContractsData<contracts, allowFailure>
+> = Compute<
+  ReadContractsOptions<contracts, allowFailure, config> &
+    ConfigParameter<config> &
+    QueryParameter<
+      ReadContractsQueryFnData<contracts, allowFailure>,
+      ReadContractsErrorType,
+      selectData,
+      ReadContractsQueryKey<contracts, allowFailure, config>
+    >
+>;
+
+export function useReadContracts<
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean = true,
+  config extends Config = ResolvedRegister["config"],
+  selectData = ReadContractsData<contracts, allowFailure>
+>(
+  params: Accessor<
+    UseReadContractsParameters<contracts, allowFailure, config, selectData>
+  >
+) {
+  const contracts = createMemo(() => params().contracts ?? []);
+  const config = useConfig(params);
+  const chainId = useChainId();
+
+  const contractsChainId = createMemo(() => {
+    const firstChainId = (contracts()[0] as { chainId?: number } | undefined)
+      ?.chainId;
+    if (
+      (contracts() as { chainId?: number }[]).every(
+        (contract) => contract.chainId === firstChainId
+      )
+    )
+      return firstChainId;
+    return undefined;
+  });
+
+  const enabled = createMemo(() => {
+    let isContractsValid = false;
+    for (const contract of contracts()) {
+      const { abi, address, functionName } =
+        contract as ContractFunctionParameters;
+      if (!abi || !address || !functionName) {
+        isContractsValid = false;
+        break;
+      }
+      isContractsValid = true;
+    }
+    return Boolean(isContractsValid && (params().query?.enabled ?? true));
+  });
+
+  return useQuery(() => {
+    const { query = {} } = params();
+    // @ts-ignore
+    const code = params().code as Hex | undefined;
+
+    const options = readContractsQueryOptions<Config, contracts, allowFailure>(
+      config,
+      { ...params(), chainId: contractsChainId() ?? chainId().id }
+    );
+
+    return {
+      ...query,
+      ...options,
+      enabled,
+    } as any;
+  }) as UseReadContractsReturnType<contracts, allowFailure, selectData>;
+}

package/src/hooks/useWriteContract.ts

@@ -0,0 +1,78 @@
+import { useMutation } from "@tanstack/solid-query";
+import type { Config, WriteContractErrorType } from "@wagmi/core";
+import {
+  writeContractMutationOptions,
+  type WriteContractData,
+  type WriteContractMutate,
+  type WriteContractMutateAsync,
+  type WriteContractVariables,
+} from "@wagmi/core/query";
+
+import type { Abi } from "viem";
+import type {
+  ConfigParameter,
+  UseMutationParameters,
+  UseMutationReturnType,
+} from "../types/index.js";
+import { useConfig } from "./useConfig.js";
+
+export type UseWriteContractParameters<
+  config extends Config = Config,
+  context = unknown
+> = ConfigParameter<config> & {
+  mutation?:
+    | UseMutationParameters<
+        WriteContractData,
+        WriteContractErrorType,
+        WriteContractVariables<
+          Abi,
+          string,
+          readonly unknown[],
+          config,
+          config["chains"][number]["id"]
+        >,
+        context
+      >
+    | undefined;
+};
+
+export type UseWriteContractReturnType<
+  config extends Config = Config,
+  context = unknown
+> = UseMutationReturnType<
+  WriteContractData,
+  WriteContractErrorType,
+  WriteContractVariables<
+    Abi,
+    string,
+    readonly unknown[],
+    config,
+    config["chains"][number]["id"]
+  >,
+  context
+> & {
+  writeContract: WriteContractMutate<config, context>;
+  writeContractAsync: WriteContractMutateAsync<config, context>;
+};
+
+export function useWriteContract<
+  config extends Config = Config,
+  context = unknown
+>(
+  params?: () => UseWriteContractParameters<config, context>
+): UseWriteContractReturnType<config, context> {
+  const config = useConfig();
+
+  const mutationOptions = writeContractMutationOptions(config);
+  const { mutate, mutateAsync, ...result } = useMutation(() => ({
+    ...(params?.().mutation ?? {}),
+    ...mutationOptions,
+  }));
+
+  type Return = UseWriteContractReturnType<config, context>;
+  return {
+    ...(result as Return),
+    writeContract: mutate as Return["writeContract"],
+    writeContractAsync: mutateAsync as Return["writeContractAsync"],
+  };
+}

package/src/types/index.ts

@@ -0,0 +1,116 @@
+import type {
+  DefaultError,
+  QueryKey,
+  SolidQueryOptions,
+  UseInfiniteQueryOptions,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryResult,
+} from "@tanstack/solid-query";
+import type { Config } from "@wagmi/core";
+import type {
+  Compute,
+  ExactPartial,
+  Omit,
+  UnionStrictOmit,
+} from "@wagmi/core/internal";
+
+export type EnabledParameter = {
+  enabled?: boolean | undefined;
+};
+
+export type ConfigParameter<config extends Config = Config> = {
+  config?: Config | config | undefined;
+};
+
+export type UseQueryReturnType<data = unknown, error = DefaultError> = Compute<
+  UseQueryResult<data, error>
+>;
+export type UseInfiniteQueryParameters<
+  queryFnData = unknown,
+  error = DefaultError,
+  data = queryFnData,
+  queryKey extends QueryKey = QueryKey,
+  pageParam = unknown
+> = Compute<
+  Omit<
+    ReturnType<
+      UseInfiniteQueryOptions<queryFnData, error, data, queryKey, pageParam>
+    >,
+    "initialData"
+  > & {
+    // Fix `initialData` type
+    initialData?:
+      | ReturnType<
+          UseInfiniteQueryOptions<queryFnData, error, data, queryKey>
+        >["initialData"]
+      | undefined;
+  }
+>;
+
+export type UseMutationReturnType<
+  data = unknown,
+  error = Error,
+  variables = void,
+  context = unknown
+> = Compute<
+  UnionStrictOmit<
+    UseMutationResult<data, error, variables, context>,
+    "mutate" | "mutateAsync"
+  >
+>;
+
+export type UseMutationParameters<
+  data = unknown,
+  error = Error,
+  variables = void,
+  context = unknown
+> = Compute<
+  Omit<
+    ReturnType<UseMutationOptions<data, error, Compute<variables>, context>>,
+    "mutationFn" | "mutationKey" | "throwOnError"
+  >
+>;
+
+export type UseQueryParameters<
+  queryFnData = unknown,
+  error = DefaultError,
+  data = queryFnData,
+  queryKey extends QueryKey = QueryKey
+> = Compute<
+  ExactPartial<
+    Omit<SolidQueryOptions<queryFnData, error, data, queryKey>, "initialData">
+  > & {
+    // Fix `initialData` type
+    initialData?:
+      | SolidQueryOptions<queryFnData, error, data, queryKey>["initialData"]
+      | undefined;
+  }
+>;
+
+export type QueryParameter<
+  queryFnData = unknown,
+  error = DefaultError,
+  data = queryFnData,
+  queryKey extends QueryKey = QueryKey
+> = {
+  query?:
+    | Omit<
+        UseQueryParameters<queryFnData, error, data, queryKey>,
+        "queryFn" | "queryHash" | "queryKey" | "queryKeyHashFn" | "throwOnError"
+      >
+    | undefined;
+};
+
+export type InfiniteQueryParameter<
+  queryFnData = unknown,
+  error = DefaultError,
+  data = queryFnData,
+  queryKey extends QueryKey = QueryKey,
+  pageParam = unknown
+> = {
+  query: Omit<
+    UseInfiniteQueryParameters<queryFnData, error, data, queryKey, pageParam>,
+    "queryFn" | "queryHash" | "queryKey" | "queryKeyHashFn" | "throwOnError"
+  >;
+};

package/dist/esm/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,OAAO,EAAc,MAAM,aAAa,CAAC;AAC/D,OAAO,EACL,eAAe,EACf,aAAa,EAEb,OAAO,EACP,UAAU,GACX,MAAM,UAAU,CAAC;AAOlB,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,EAAY,CAAC;AAEtD,MAAM,UAAU,aAAa,CAAC,KAK7B;IACC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,UAAU,CAAC,KAAK,EAAE;QAC3C,QAAQ;QACR,cAAc;QACd,kBAAkB;KACnB,CAAC,CAAC;IACH,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,gBAAgB,EAAE,GAAG,UAAU,CAAC;IAE9D,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAEtE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG;QAAE,SAAS,CAAC,OAAO,EAAE,CAAC;IAC/C,OAAO,CAAC,GAAG,EAAE;QACX,IAAI,MAAM,CAAC,SAAS,CAAC,GAAG;YAAE,SAAS,CAAC,OAAO,EAAE,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,OAAO,eAAe,CAAC,YAAY,CAAC,QAAQ,EAAE;QAC5C,KAAK,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE;QAC/B,IAAI,QAAQ;YACV,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/esm/errors/context.js

@@ -1,6 +0,0 @@
-export class WagmiProviderNotFoundError extends Error {
-    constructor() {
-        super("`useConfig` must be used withtin <WagmiProvider/>");
-    }
-}
-//# sourceMappingURL=context.js.map

package/dist/esm/errors/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/errors/context.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IACnD;QACE,KAAK,CAAC,mDAAmD,CAAC,CAAC;IAC7D,CAAC;CACF"}

package/dist/esm/exports/actions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.js","sourceRoot":"","sources":["../../../src/exports/actions.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/esm/exports/chains.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chains.js","sourceRoot":"","sources":["../../../src/exports/chains.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/esm/exports/connectors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connectors.js","sourceRoot":"","sources":["../../../src/exports/connectors.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/esm/exports/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/exports/index.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,UAAU;AACV,kEAAkE;AAElE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,kEAAkE;AAClE,SAAS;AACT,kEAAkE;AAClE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE,kEAAkE;AAClE,QAAQ;AACR,kEAAkE;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D,gFAAgF;AAChF,cAAc;AACd,gFAAgF;AAEhF,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,8BAA8B,EAC9B,2BAA2B,EAC3B,sBAAsB,EACtB,qCAAqC;AACrC,YAAY;AACZ,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,eAAe,EACf,aAAa;AACb,aAAa;AACb,MAAM,EACN,SAAS,EACT,WAAW,EACX,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,qBAAqB,EACrB,SAAS,EACT,4BAA4B,EAC5B,kBAAkB,EAClB,SAAS,GA2BV,MAAM,aAAa,CAAC"}

package/dist/esm/exports/query.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../src/exports/query.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}