solid-wagmi 0.0.5 → 0.2.0

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.0.5",
+  "version": "0.2.0",
   "description": "Solid.js Hooks for Ethereum",
   "type": "module",
   "repository": {
@@ -13,12 +13,37 @@
   "files": [
     "dist/**",
     "!dist/**/*.tsbuildinfo",
-    "src/**/*.ts"
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "/actions",
+    "/chains",
+    "/codegen",
+    "/connectors",
+    "/experimental",
+    "/internal",
+    "/query"
   ],
   "exports": {
     ".": {
       "types": "./dist/types/exports/index.d.ts",
       "default": "./dist/esm/exports/index.js"
+    },
+    "./actions": {
+      "types": "./dist/types/exports/actions.d.ts",
+      "default": "./dist/esm/exports/actions.js"
+    },
+    "./chains": {
+      "types": "./dist/types/exports/chains.d.ts",
+      "default": "./dist/esm/exports/chains.js"
+    },
+    "./connectors": {
+      "types": "./dist/types/exports/connectors.d.ts",
+      "default": "./dist/esm/exports/connectors.js"
+    },
+    "./query": {
+      "types": "./dist/types/exports/query.d.ts",
+      "default": "./dist/esm/exports/query.js"
     }
   },
   "peerDependencies": {
@@ -28,13 +53,28 @@
     "viem": "2.x"
   },
   "dependencies": {
+    "@wagmi/connectors": "^6.1.3",
     "@wagmi/core": "^2.22.1"
   },
-  "keywords": [],
+  "keywords": [
+    "solidjs",
+    "solid",
+    "wagmi",
+    "solid-wagmi"
+  ],
   "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/actions.ts

@@ -0,0 +1 @@
+export * from "@wagmi/core/actions";

package/src/exports/chains.ts

@@ -0,0 +1 @@
+export * from "viem/chains";

package/src/exports/connectors.ts

@@ -0,0 +1 @@
+export * from "@wagmi/connectors";

package/src/exports/index.ts

@@ -13,8 +13,73 @@ 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
+////////////////////////////////////////////////////////////////////////////////
+
+export {
+  ChainNotConfiguredError,
+  ConnectorAccountNotFoundError,
+  ConnectorAlreadyConnectedError,
+  ConnectorChainMismatchError,
+  ConnectorNotFoundError,
+  ConnectorUnavailableReconnectingError,
+  // Utilities
+  cookieStorage,
+  cookieToInitialState,
+  createConfig,
+  createConnector,
+  createStorage,
+  // Transports
+  custom,
+  deepEqual,
+  deserialize,
+  fallback,
+  http,
+  injected,
+  mock,
+  noopStorage,
+  normalizeChainId,
+  parseCookie,
+  ProviderNotFoundError,
+  serialize,
+  SwitchChainNotSupportedError,
+  unstable_connector,
+  webSocket,
+  // Errors
+  type ChainNotConfiguredErrorType,
+  type Config,
+  // Config
+  type Connection,
+  type Connector,
+  type ConnectorAccountNotFoundErrorType,
+  type ConnectorAlreadyConnectedErrorType,
+  type ConnectorChainMismatchErrorType,
+  // Connector
+  type ConnectorEventMap,
+  type ConnectorNotFoundErrorType,
+  type ConnectorUnavailableReconnectingErrorType,
+  type CreateConfigParameters,
+  type CreateConnectorFn,
+  // Storage
+  type CreateStorageParameters,
+  type PartializedState,
+  type ProviderNotFoundErrorType,
+  // Types
+  type Register,
+  type ResolvedRegister,
+  type State,
+  type Storage,
+  type SwitchChainNotSupportedErrorType,
+  type Transport,
+} from "@wagmi/core";

package/src/exports/query.ts

@@ -0,0 +1 @@
+export * from "@wagmi/core/query";

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"],
+  };
+}