@gluwa/connect-kit 0.2.1-next.1 → 0.2.1-next.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @gluwa/wallet-kit
 
+## 0.2.1-next.4
+
+### Patch Changes
+
+- ceec77a: expose all wagmi actions via connectKit.actions
+
 ## 0.2.1-next.1
 
 ### Patch Changes

package/dist/{chunk-CJANPJHY.js → chunk-TMKSC7ZT.js}

@@ -1,6 +1,10 @@
 import React from "react";
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/creditConnectConnector.ts
 import { createConnector } from "@wagmi/core";
@@ -403,5 +407,6 @@ var creditConnectConnector = /* @__PURE__ */ __name((options) => {
 
 export {
   __name,
+  __export,
   creditConnectConnector
 };

package/dist/credit-connect.js

@@ -1,7 +1,7 @@
 import React from "react";
 import {
   creditConnectConnector
-} from "./chunk-CJANPJHY.js";
+} from "./chunk-TMKSC7ZT.js";
 export {
   creditConnectConnector
 };

package/dist/index.d.ts

@@ -1,13 +1,89 @@
-import * as viem from 'viem';
-import { Abi, ContractFunctionName, ContractFunctionArgs, Chain, Transport } from 'viem';
-import * as _wagmi_core from '@wagmi/core';
-import { ReadContractParameters, Config, ReadContractReturnType, WriteContractParameters, WriteContractReturnType } from '@wagmi/core';
+import * as actions from '@wagmi/core/actions';
+import { Abi, FeeValuesType, BlockTag, ContractFunctionParameters, PrepareTransactionRequestRequest, ContractFunctionName, ContractFunctionArgs, TypedData, ContractEventName, Chain, Transport } from 'viem';
+import { Connector, CreateConnectorFn, ConnectParameters, Config, ConnectReturnType, DeployContractParameters, DeployContractReturnType, EstimateFeesPerGasParameters, EstimateFeesPerGasReturnType, EstimateGasParameters, EstimateGasReturnType, EstimateMaxPriorityFeePerGasParameters, EstimateMaxPriorityFeePerGasReturnType, GetBlockParameters, GetBlockReturnType, GetBlockNumberParameters, GetBlockNumberReturnType, GetBlockTransactionCountParameters, GetBlockTransactionCountReturnType, GetCapabilitiesParameters, GetCapabilitiesReturnType, GetClientParameters, GetClientReturnType, GetConnectorClientParameters, GetConnectorClientReturnType, GetFeeHistoryParameters, GetFeeHistoryReturnType, GetGasPriceParameters, GetGasPriceReturnType, GetPublicClientParameters, GetPublicClientReturnType, GetTransactionParameters, GetTransactionReturnType, GetTransactionConfirmationsParameters, GetTransactionConfirmationsReturnType, GetTransactionReceiptParameters, GetTransactionReceiptReturnType, GetWalletClientParameters, GetWalletClientReturnType, MulticallParameters, MulticallReturnType, SelectChains, PrepareTransactionRequestParameters, PrepareTransactionRequestReturnType, ReadContractParameters, ReadContractReturnType, ReadContractsParameters, ReadContractsReturnType, SendCallsParameters, SendCallsReturnType, SendTransactionParameters, SendTransactionReturnType, SignTypedDataParameters, SignTypedDataReturnType, SimulateContractParameters, SimulateContractReturnType, SwitchChainParameters, SwitchChainReturnType, VerifyTypedDataParameters, VerifyTypedDataReturnType, WaitForTransactionReceiptParameters, WaitForTransactionReceiptReturnType, WatchBlockNumberParameters, WatchBlockNumberReturnType, WatchBlocksParameters, WatchBlocksReturnType, WatchClientParameters, WatchClientReturnType, WatchContractEventParameters, WatchPendingTransactionsParameters, WatchPublicClientParameters, WatchPublicClientReturnType, WriteContractParameters, WriteContractReturnType, ReconnectReturnType } from '@wagmi/core';
 export * from '@wagmi/core';
 import { ReactNode, FC } from 'react';
-import { CreateConnectorFn, Config as Config$1 } from 'wagmi';
+import { CreateConnectorFn as CreateConnectorFn$1, Config as Config$1 } from 'wagmi';
 
+declare function connect<connector extends Connector | CreateConnectorFn, withCapabilities extends boolean = false>(parameters: ConnectParameters<Config, connector, withCapabilities>): Promise<ConnectReturnType<Config, connector, withCapabilities>>;
+declare function deployContract<const abi extends Abi | readonly unknown[], chainId extends Config['chains'][number]['id']>(parameters: DeployContractParameters<abi, Config, chainId>): Promise<DeployContractReturnType>;
+declare function estimateFeesPerGas<type extends FeeValuesType = 'eip1559'>(parameters?: EstimateFeesPerGasParameters<type, Config>): Promise<EstimateFeesPerGasReturnType<type>>;
+declare function estimateGas<chainId extends Config['chains'][number]['id'] | undefined = undefined>(parameters: EstimateGasParameters<Config, chainId>): Promise<EstimateGasReturnType>;
+declare function estimateMaxPriorityFeePerGas<chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id']>(parameters?: EstimateMaxPriorityFeePerGasParameters<Config, chainId>): Promise<EstimateMaxPriorityFeePerGasReturnType>;
+declare function getBlock<chainId extends Config['chains'][number]['id'], includeTransactions extends boolean = false, blockTag extends BlockTag = 'latest'>(parameters?: GetBlockParameters<includeTransactions, blockTag, Config, chainId>): Promise<GetBlockReturnType<includeTransactions, blockTag, Config, chainId>>;
+declare function getBlockNumber<chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id']>(parameters?: GetBlockNumberParameters<Config, chainId>): Promise<GetBlockNumberReturnType>;
+declare function getBlockTransactionCount<chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id']>(parameters?: GetBlockTransactionCountParameters<Config, chainId>): Promise<GetBlockTransactionCountReturnType>;
+declare function getCapabilities<chainId extends Config['chains'][number]['id'] | undefined = undefined>(parameters?: GetCapabilitiesParameters<Config, chainId>): Promise<GetCapabilitiesReturnType<Config, chainId>>;
+declare function getClient<chainId extends Config['chains'][number]['id'] | number | undefined>(parameters?: GetClientParameters<Config, chainId>): GetClientReturnType<Config, chainId>;
+declare function getConnectorClient<chainId extends Config['chains'][number]['id']>(parameters?: GetConnectorClientParameters<Config, chainId>): Promise<GetConnectorClientReturnType<Config, chainId>>;
+declare function getFeeHistory<chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id']>(parameters: GetFeeHistoryParameters<Config, chainId>): Promise<GetFeeHistoryReturnType>;
+declare function getGasPrice<chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id']>(parameters?: GetGasPriceParameters<Config, chainId>): Promise<GetGasPriceReturnType>;
+declare function getPublicClient<chainId extends Config['chains'][number]['id'] | number | undefined>(parameters?: GetPublicClientParameters<Config, chainId>): GetPublicClientReturnType<Config, chainId>;
+declare function getTransaction<chainId extends Config['chains'][number]['id']>(parameters: GetTransactionParameters<Config, chainId>): Promise<GetTransactionReturnType<Config, chainId>>;
+declare function getTransactionConfirmations<chainId extends Config['chains'][number]['id'] | undefined = Config['chains'][number]['id']>(parameters: GetTransactionConfirmationsParameters<Config, chainId>): Promise<GetTransactionConfirmationsReturnType>;
+declare function getTransactionReceipt<chainId extends Config['chains'][number]['id']>(parameters: GetTransactionReceiptParameters<Config>): Promise<GetTransactionReceiptReturnType<Config, chainId>>;
+declare function getWalletClient<chainId extends Config['chains'][number]['id']>(parameters?: GetWalletClientParameters<Config, chainId>): Promise<GetWalletClientReturnType<Config, chainId>>;
+declare function multicall<const contracts extends readonly ContractFunctionParameters[], allowFailure extends boolean = true>(parameters: MulticallParameters<contracts, allowFailure, Config>): Promise<MulticallReturnType<contracts, allowFailure>>;
+declare function prepareTransactionRequest<chainId extends Config['chains'][number]['id'] | undefined, const request extends PrepareTransactionRequestRequest<SelectChains<Config, chainId>['0'], SelectChains<Config, chainId>['0']>>(parameters: PrepareTransactionRequestParameters<Config, chainId, request>): Promise<PrepareTransactionRequestReturnType<Config, chainId, request>>;
 declare function readContract<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, 'pure' | 'view'>, args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>>(parameters: ReadContractParameters<abi, functionName, args, Config>): Promise<ReadContractReturnType<abi, functionName, args>>;
-declare function writeContract<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>, args extends ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>>(parameters: WriteContractParameters<abi, functionName, args, Config>): Promise<WriteContractReturnType>;
+declare function readContracts<const contracts extends readonly ContractFunctionParameters[], allowFailure extends boolean = true>(parameters: ReadContractsParameters<contracts, allowFailure, Config>): Promise<ReadContractsReturnType<contracts, allowFailure>>;
+declare function sendCalls<const calls extends readonly unknown[], chainId extends Config['chains'][number]['id']>(parameters: SendCallsParameters<Config, chainId, calls>): Promise<SendCallsReturnType>;
+declare function sendTransaction<chainId extends Config['chains'][number]['id']>(parameters: SendTransactionParameters<Config, chainId>): Promise<SendTransactionReturnType>;
+declare function signTypedData<const typedData extends TypedData | Record<string, unknown>, primaryType extends keyof typedData | 'EIP712Domain'>(parameters: SignTypedDataParameters<typedData, primaryType>): Promise<SignTypedDataReturnType>;
+declare function simulateContract<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>, args extends ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>, chainId extends Config['chains'][number]['id'] | undefined = undefined>(parameters: SimulateContractParameters<abi, functionName, args, Config, chainId>): Promise<SimulateContractReturnType<abi, functionName, args, Config, chainId>>;
+declare function switchChain<chainId extends Config['chains'][number]['id']>(parameters: SwitchChainParameters<Config, chainId>): Promise<SwitchChainReturnType<Config, chainId>>;
+declare function verifyTypedData<const typedData extends TypedData | Record<string, unknown>, primaryType extends keyof typedData | 'EIP712Domain'>(parameters: VerifyTypedDataParameters<typedData, primaryType, Config>): Promise<VerifyTypedDataReturnType>;
+declare function waitForTransactionReceipt<chainId extends Config['chains'][number]['id']>(parameters: WaitForTransactionReceiptParameters<Config, chainId>): Promise<WaitForTransactionReceiptReturnType<Config, chainId>>;
+declare function watchBlockNumber<chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id']>(parameters: WatchBlockNumberParameters<Config, chainId>): WatchBlockNumberReturnType;
+declare function watchBlocks<chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'], includeTransactions extends boolean = false, blockTag extends BlockTag = 'latest'>(parameters: WatchBlocksParameters<includeTransactions, blockTag, Config, chainId>): WatchBlocksReturnType;
+declare function watchClient<chainId extends Config['chains'][number]['id']>(parameters: WatchClientParameters<Config, chainId>): WatchClientReturnType;
+declare function watchContractEvent<chainId extends Config['chains'][number]['id'], const abi extends Abi | readonly unknown[], eventName extends ContractEventName<abi> | undefined, strict extends boolean | undefined = undefined>(parameters: WatchContractEventParameters<abi, eventName, strict, Config, chainId>): () => void;
+declare function watchPendingTransactions<chainId extends Config['chains'][number]['id']>(parameters: WatchPendingTransactionsParameters<Config, chainId>): () => void;
+declare function watchPublicClient<chainId extends Config['chains'][number]['id']>(parameters: WatchPublicClientParameters<Config, chainId>): WatchPublicClientReturnType;
+declare function writeContract<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>, args extends ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>, chainId extends Config['chains'][number]['id']>(parameters: WriteContractParameters<abi, functionName, args, Config, chainId>): Promise<WriteContractReturnType>;
+
+declare const wrappers_connect: typeof connect;
+declare const wrappers_deployContract: typeof deployContract;
+declare const wrappers_estimateFeesPerGas: typeof estimateFeesPerGas;
+declare const wrappers_estimateGas: typeof estimateGas;
+declare const wrappers_estimateMaxPriorityFeePerGas: typeof estimateMaxPriorityFeePerGas;
+declare const wrappers_getBlock: typeof getBlock;
+declare const wrappers_getBlockNumber: typeof getBlockNumber;
+declare const wrappers_getBlockTransactionCount: typeof getBlockTransactionCount;
+declare const wrappers_getCapabilities: typeof getCapabilities;
+declare const wrappers_getClient: typeof getClient;
+declare const wrappers_getConnectorClient: typeof getConnectorClient;
+declare const wrappers_getFeeHistory: typeof getFeeHistory;
+declare const wrappers_getGasPrice: typeof getGasPrice;
+declare const wrappers_getPublicClient: typeof getPublicClient;
+declare const wrappers_getTransaction: typeof getTransaction;
+declare const wrappers_getTransactionConfirmations: typeof getTransactionConfirmations;
+declare const wrappers_getTransactionReceipt: typeof getTransactionReceipt;
+declare const wrappers_getWalletClient: typeof getWalletClient;
+declare const wrappers_multicall: typeof multicall;
+declare const wrappers_prepareTransactionRequest: typeof prepareTransactionRequest;
+declare const wrappers_readContract: typeof readContract;
+declare const wrappers_readContracts: typeof readContracts;
+declare const wrappers_sendCalls: typeof sendCalls;
+declare const wrappers_sendTransaction: typeof sendTransaction;
+declare const wrappers_signTypedData: typeof signTypedData;
+declare const wrappers_simulateContract: typeof simulateContract;
+declare const wrappers_switchChain: typeof switchChain;
+declare const wrappers_verifyTypedData: typeof verifyTypedData;
+declare const wrappers_waitForTransactionReceipt: typeof waitForTransactionReceipt;
+declare const wrappers_watchBlockNumber: typeof watchBlockNumber;
+declare const wrappers_watchBlocks: typeof watchBlocks;
+declare const wrappers_watchClient: typeof watchClient;
+declare const wrappers_watchContractEvent: typeof watchContractEvent;
+declare const wrappers_watchPendingTransactions: typeof watchPendingTransactions;
+declare const wrappers_watchPublicClient: typeof watchPublicClient;
+declare const wrappers_writeContract: typeof writeContract;
+declare namespace wrappers {
+  export { wrappers_connect as connect, wrappers_deployContract as deployContract, wrappers_estimateFeesPerGas as estimateFeesPerGas, wrappers_estimateGas as estimateGas, wrappers_estimateMaxPriorityFeePerGas as estimateMaxPriorityFeePerGas, wrappers_getBlock as getBlock, wrappers_getBlockNumber as getBlockNumber, wrappers_getBlockTransactionCount as getBlockTransactionCount, wrappers_getCapabilities as getCapabilities, wrappers_getClient as getClient, wrappers_getConnectorClient as getConnectorClient, wrappers_getFeeHistory as getFeeHistory, wrappers_getGasPrice as getGasPrice, wrappers_getPublicClient as getPublicClient, wrappers_getTransaction as getTransaction, wrappers_getTransactionConfirmations as getTransactionConfirmations, wrappers_getTransactionReceipt as getTransactionReceipt, wrappers_getWalletClient as getWalletClient, wrappers_multicall as multicall, wrappers_prepareTransactionRequest as prepareTransactionRequest, wrappers_readContract as readContract, wrappers_readContracts as readContracts, wrappers_sendCalls as sendCalls, wrappers_sendTransaction as sendTransaction, wrappers_signTypedData as signTypedData, wrappers_simulateContract as simulateContract, wrappers_switchChain as switchChain, wrappers_verifyTypedData as verifyTypedData, wrappers_waitForTransactionReceipt as waitForTransactionReceipt, wrappers_watchBlockNumber as watchBlockNumber, wrappers_watchBlocks as watchBlocks, wrappers_watchClient as watchClient, wrappers_watchContractEvent as watchContractEvent, wrappers_watchPendingTransactions as watchPendingTransactions, wrappers_watchPublicClient as watchPublicClient, wrappers_writeContract as writeContract };
+}
+
+declare const reconnect: () => Promise<ReconnectReturnType>;
+declare const disconnectAll: (onLog?: (message: string, error?: Error) => void) => Promise<void>;
 
 type ConnectorId = 'CREDIT_CONNECT' | 'METAMASK' | 'WALLET_CONNECT';
 interface ConnectKitConfig {
@@ -18,7 +94,7 @@ interface ConnectKitConfig {
         projectId: string;
         serverUrl: string;
     };
-    extraConnectors?: CreateConnectorFn[];
+    extraConnectors?: CreateConnectorFn$1[];
     autoConnectInjected?: boolean;
 }
 type ConnectorKey = 'creditWallet' | 'metamask' | 'walletConnect';
@@ -93,25 +169,16 @@ declare const useConnectKit: () => ConnectKitContextValue;
 
 declare const initConfig: (kitConfig: ConnectKitConfig) => Config$1;
 
+type StripConfig<T> = T extends (config: any, ...rest: infer A) => infer R ? (...rest: A) => R : never;
+type Bridge = {
+    [K in keyof typeof actions]: StripConfig<(typeof actions)[K]>;
+};
+type KitActions = Omit<Bridge, keyof typeof wrappers | 'reconnect' | 'disconnectAll'> & typeof wrappers & {
+    reconnect: typeof reconnect;
+    disconnectAll: typeof disconnectAll;
+};
 declare const connectKit: {
-    readonly api: {
-        readonly readContract: typeof readContract;
-        readonly writeContract: typeof writeContract;
-        readonly getBalance: (params: _wagmi_core.GetBalanceParameters) => Promise<_wagmi_core.GetBalanceReturnType>;
-        readonly switchChain: (params: _wagmi_core.SwitchChainParameters) => Promise<viem.Chain>;
-        readonly getPublicClient: (params?: _wagmi_core.GetPublicClientParameters) => _wagmi_core.GetPublicClientReturnType;
-        readonly waitForTransactionReceipt: (params: _wagmi_core.WaitForTransactionReceiptParameters) => Promise<_wagmi_core.WaitForTransactionReceiptReturnType>;
-        readonly getAccount: () => _wagmi_core.GetAccountReturnType;
-        readonly signMessage: (params: _wagmi_core.SignMessageParameters) => Promise<`0x${string}`>;
-        readonly signTypedData: (params: _wagmi_core.SignTypedDataParameters) => Promise<`0x${string}`>;
-        readonly watchAsset: (params: _wagmi_core.WatchAssetParameters) => Promise<_wagmi_core.WatchAssetReturnType>;
-    };
-    readonly events: {
-        readonly watchAccount: (params: _wagmi_core.WatchAccountParameters) => (() => void);
-        readonly watchConnections: (params: _wagmi_core.WatchConnectionsParameters) => (() => void);
-        readonly reconnect: () => Promise<_wagmi_core.ReconnectReturnType>;
-        readonly disconnectAll: (onLog?: (message: string, error?: Error) => void) => Promise<void>;
-    };
+    readonly actions: KitActions;
 };
 
 export { type ConnectBannerSiteKey, type ConnectErrorContext, type ConnectErrorReason, type ConnectKitConfig, type ConnectKitContextValue, ConnectKitProvider, type ConnectKitProviderProps, type ConnectKitTheme, type ConnectModalProps, type ConnectResult, type ConnectorId, type ConnectorKey, type Connectors, type WCSubView, type WCWallet, connectKit, initConfig, useConnectKit };

package/dist/index.js

@@ -1,11 +1,54 @@
 import React from "react";
 import {
+  __export,
   __name,
   creditConnectConnector
-} from "./chunk-CJANPJHY.js";
+} from "./chunk-TMKSC7ZT.js";
 
-// src/api/contract.ts
-import { readContract as wagmiReadContract, writeContract as wagmiWriteContract } from "@wagmi/core";
+// src/index.ts
+import * as actions from "@wagmi/core/actions";
+
+// src/api/wrappers.ts
+var wrappers_exports = {};
+__export(wrappers_exports, {
+  connect: () => connect2,
+  deployContract: () => deployContract2,
+  estimateFeesPerGas: () => estimateFeesPerGas2,
+  estimateGas: () => estimateGas2,
+  estimateMaxPriorityFeePerGas: () => estimateMaxPriorityFeePerGas2,
+  getBlock: () => getBlock2,
+  getBlockNumber: () => getBlockNumber2,
+  getBlockTransactionCount: () => getBlockTransactionCount2,
+  getCapabilities: () => getCapabilities2,
+  getClient: () => getClient2,
+  getConnectorClient: () => getConnectorClient2,
+  getFeeHistory: () => getFeeHistory2,
+  getGasPrice: () => getGasPrice2,
+  getPublicClient: () => getPublicClient2,
+  getTransaction: () => getTransaction2,
+  getTransactionConfirmations: () => getTransactionConfirmations2,
+  getTransactionReceipt: () => getTransactionReceipt2,
+  getWalletClient: () => getWalletClient2,
+  multicall: () => multicall2,
+  prepareTransactionRequest: () => prepareTransactionRequest2,
+  readContract: () => readContract2,
+  readContracts: () => readContracts2,
+  sendCalls: () => sendCalls2,
+  sendTransaction: () => sendTransaction2,
+  signTypedData: () => signTypedData2,
+  simulateContract: () => simulateContract2,
+  switchChain: () => switchChain2,
+  verifyTypedData: () => verifyTypedData2,
+  waitForTransactionReceipt: () => waitForTransactionReceipt2,
+  watchBlockNumber: () => watchBlockNumber2,
+  watchBlocks: () => watchBlocks2,
+  watchClient: () => watchClient2,
+  watchContractEvent: () => watchContractEvent2,
+  watchPendingTransactions: () => watchPendingTransactions2,
+  watchPublicClient: () => watchPublicClient2,
+  writeContract: () => writeContract2
+});
+import * as w from "@wagmi/core/actions";
 
 // src/core/config.ts
 import { createConfig, createStorage } from "wagmi";
@@ -139,63 +182,154 @@ var getKitConfig = /* @__PURE__ */ __name(() => {
   return slot.kitConfig;
 }, "getKitConfig");
 
-// src/api/contract.ts
-function readContract(parameters) {
-  return wagmiReadContract(getConfig(), parameters);
+// src/api/wrappers.ts
+function connect2(parameters) {
+  return w.connect(getConfig(), parameters);
 }
-__name(readContract, "readContract");
-function writeContract(parameters) {
-  return wagmiWriteContract(getConfig(), parameters);
+__name(connect2, "connect");
+function deployContract2(parameters) {
+  return w.deployContract(getConfig(), parameters);
 }
-__name(writeContract, "writeContract");
-
-// src/api/balance.ts
-import { getBalance as wagmiGetBalance } from "@wagmi/core";
-var getBalance = /* @__PURE__ */ __name((params) => {
-  return wagmiGetBalance(getConfig(), params);
-}, "getBalance");
-
-// src/api/chain.ts
-import { switchChain as wagmiSwitchChain, getPublicClient as wagmiGetPublicClient } from "@wagmi/core";
-var switchChain = /* @__PURE__ */ __name((params) => {
-  return wagmiSwitchChain(getConfig(), params);
-}, "switchChain");
-var getPublicClient = /* @__PURE__ */ __name((params) => {
-  return wagmiGetPublicClient(getConfig(), params);
-}, "getPublicClient");
-
-// src/api/transaction.ts
-import { waitForTransactionReceipt as wagmiWaitForTransactionReceipt } from "@wagmi/core";
-var waitForTransactionReceipt = /* @__PURE__ */ __name((params) => {
-  return wagmiWaitForTransactionReceipt(getConfig(), params);
-}, "waitForTransactionReceipt");
-
-// src/api/account.ts
-import { getAccount as wagmiGetAccount, signMessage as wagmiSignMessage, signTypedData as wagmiSignTypedData } from "@wagmi/core";
-var getAccount = /* @__PURE__ */ __name(() => {
-  return wagmiGetAccount(getConfig());
-}, "getAccount");
-var signMessage = /* @__PURE__ */ __name((params) => {
-  return wagmiSignMessage(getConfig(), params);
-}, "signMessage");
-var signTypedData = /* @__PURE__ */ __name((params) => {
-  return wagmiSignTypedData(getConfig(), params);
-}, "signTypedData");
-
-// src/api/asset.ts
-import { watchAsset as wagmiWatchAsset } from "@wagmi/core";
-var watchAsset = /* @__PURE__ */ __name((params) => {
-  return wagmiWatchAsset(getConfig(), params);
-}, "watchAsset");
+__name(deployContract2, "deployContract");
+function estimateFeesPerGas2(parameters) {
+  return w.estimateFeesPerGas(getConfig(), parameters);
+}
+__name(estimateFeesPerGas2, "estimateFeesPerGas");
+function estimateGas2(parameters) {
+  return w.estimateGas(getConfig(), parameters);
+}
+__name(estimateGas2, "estimateGas");
+function estimateMaxPriorityFeePerGas2(parameters) {
+  return w.estimateMaxPriorityFeePerGas(getConfig(), parameters);
+}
+__name(estimateMaxPriorityFeePerGas2, "estimateMaxPriorityFeePerGas");
+function getBlock2(parameters) {
+  return w.getBlock(getConfig(), parameters);
+}
+__name(getBlock2, "getBlock");
+function getBlockNumber2(parameters) {
+  return w.getBlockNumber(getConfig(), parameters);
+}
+__name(getBlockNumber2, "getBlockNumber");
+function getBlockTransactionCount2(parameters) {
+  return w.getBlockTransactionCount(getConfig(), parameters);
+}
+__name(getBlockTransactionCount2, "getBlockTransactionCount");
+function getCapabilities2(parameters) {
+  return w.getCapabilities(getConfig(), parameters);
+}
+__name(getCapabilities2, "getCapabilities");
+function getClient2(parameters) {
+  return w.getClient(getConfig(), parameters);
+}
+__name(getClient2, "getClient");
+function getConnectorClient2(parameters) {
+  return w.getConnectorClient(getConfig(), parameters);
+}
+__name(getConnectorClient2, "getConnectorClient");
+function getFeeHistory2(parameters) {
+  return w.getFeeHistory(getConfig(), parameters);
+}
+__name(getFeeHistory2, "getFeeHistory");
+function getGasPrice2(parameters) {
+  return w.getGasPrice(getConfig(), parameters);
+}
+__name(getGasPrice2, "getGasPrice");
+function getPublicClient2(parameters) {
+  return w.getPublicClient(getConfig(), parameters);
+}
+__name(getPublicClient2, "getPublicClient");
+function getTransaction2(parameters) {
+  return w.getTransaction(getConfig(), parameters);
+}
+__name(getTransaction2, "getTransaction");
+function getTransactionConfirmations2(parameters) {
+  return w.getTransactionConfirmations(getConfig(), parameters);
+}
+__name(getTransactionConfirmations2, "getTransactionConfirmations");
+function getTransactionReceipt2(parameters) {
+  return w.getTransactionReceipt(getConfig(), parameters);
+}
+__name(getTransactionReceipt2, "getTransactionReceipt");
+function getWalletClient2(parameters) {
+  return w.getWalletClient(getConfig(), parameters);
+}
+__name(getWalletClient2, "getWalletClient");
+function multicall2(parameters) {
+  return w.multicall(getConfig(), parameters);
+}
+__name(multicall2, "multicall");
+function prepareTransactionRequest2(parameters) {
+  return w.prepareTransactionRequest(getConfig(), parameters);
+}
+__name(prepareTransactionRequest2, "prepareTransactionRequest");
+function readContract2(parameters) {
+  return w.readContract(getConfig(), parameters);
+}
+__name(readContract2, "readContract");
+function readContracts2(parameters) {
+  return w.readContracts(getConfig(), parameters);
+}
+__name(readContracts2, "readContracts");
+function sendCalls2(parameters) {
+  return w.sendCalls(getConfig(), parameters);
+}
+__name(sendCalls2, "sendCalls");
+function sendTransaction2(parameters) {
+  return w.sendTransaction(getConfig(), parameters);
+}
+__name(sendTransaction2, "sendTransaction");
+function signTypedData2(parameters) {
+  return w.signTypedData(getConfig(), parameters);
+}
+__name(signTypedData2, "signTypedData");
+function simulateContract2(parameters) {
+  return w.simulateContract(getConfig(), parameters);
+}
+__name(simulateContract2, "simulateContract");
+function switchChain2(parameters) {
+  return w.switchChain(getConfig(), parameters);
+}
+__name(switchChain2, "switchChain");
+function verifyTypedData2(parameters) {
+  return w.verifyTypedData(getConfig(), parameters);
+}
+__name(verifyTypedData2, "verifyTypedData");
+function waitForTransactionReceipt2(parameters) {
+  return w.waitForTransactionReceipt(getConfig(), parameters);
+}
+__name(waitForTransactionReceipt2, "waitForTransactionReceipt");
+function watchBlockNumber2(parameters) {
+  return w.watchBlockNumber(getConfig(), parameters);
+}
+__name(watchBlockNumber2, "watchBlockNumber");
+function watchBlocks2(parameters) {
+  return w.watchBlocks(getConfig(), parameters);
+}
+__name(watchBlocks2, "watchBlocks");
+function watchClient2(parameters) {
+  return w.watchClient(getConfig(), parameters);
+}
+__name(watchClient2, "watchClient");
+function watchContractEvent2(parameters) {
+  return w.watchContractEvent(getConfig(), parameters);
+}
+__name(watchContractEvent2, "watchContractEvent");
+function watchPendingTransactions2(parameters) {
+  return w.watchPendingTransactions(getConfig(), parameters);
+}
+__name(watchPendingTransactions2, "watchPendingTransactions");
+function watchPublicClient2(parameters) {
+  return w.watchPublicClient(getConfig(), parameters);
+}
+__name(watchPublicClient2, "watchPublicClient");
+function writeContract2(parameters) {
+  return w.writeContract(getConfig(), parameters);
+}
+__name(writeContract2, "writeContract");
 
 // src/events/account.ts
-import { watchAccount as wagmiWatchAccount, watchConnections as wagmiWatchConnections, reconnect as wagmiReconnect, connect as wagmiConnect, getAccount as wagmiGetAccount2, disconnect as wagmiDisconnect } from "@wagmi/core";
-var watchAccount = /* @__PURE__ */ __name((params) => {
-  return wagmiWatchAccount(getConfig(), params);
-}, "watchAccount");
-var watchConnections = /* @__PURE__ */ __name((params) => {
-  return wagmiWatchConnections(getConfig(), params);
-}, "watchConnections");
+import { reconnect as wagmiReconnect, connect as wagmiConnect, getAccount as wagmiGetAccount, disconnect as wagmiDisconnect } from "@wagmi/core";
 var reconnect = /* @__PURE__ */ __name(async () => {
   const config = getConfig();
   if (getKitConfig().autoConnectInjected !== false) {
@@ -218,7 +352,7 @@ var reconnect = /* @__PURE__ */ __name(async () => {
       console.warn("auto-connect skipped (non-fatal):", error);
     }
   }
-  if (wagmiGetAccount2(config).status === "connected") {
+  if (wagmiGetAccount(config).status === "connected") {
     return [];
   }
   const result = await wagmiReconnect(config);
@@ -250,7 +384,7 @@ var disconnectAll = /* @__PURE__ */ __name(async (onLog) => {
 // src/ConnectKitProvider.tsx
 import { createContext, useCallback as useCallback4, useContext, useEffect as useEffect8, useMemo as useMemo2, useRef as useRef6, useState as useState7 } from "react";
 import { WagmiProvider, useAccount, useConfig as useConfig3, useDisconnect, useSwitchChain } from "wagmi";
-import { getAccount as getAccount3 } from "@wagmi/core";
+import { getAccount as getAccount2 } from "@wagmi/core";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 
 // src/layout/connectDialog/index.tsx
@@ -917,10 +1051,10 @@ var AllWallets = /* @__PURE__ */ __name(({ wallets, isLoading, onSelectWallet })
     const q = search.trim().toLowerCase();
     let list = wallets;
     if (filterInstalled) {
-      list = list.filter((w) => w.mobileNative || w.mobileUniversal || w.desktopNative || w.desktopUniversal);
+      list = list.filter((w2) => w2.mobileNative || w2.mobileUniversal || w2.desktopNative || w2.desktopUniversal);
     }
     if (q) {
-      list = list.filter((w) => w.name.toLowerCase().includes(q));
+      list = list.filter((w2) => w2.name.toLowerCase().includes(q));
     }
     return list;
   }, [
@@ -1188,7 +1322,7 @@ var useMetaMaskExtension = /* @__PURE__ */ __name(() => {
 // src/hooks/useWagmiConnect.ts
 import { useEffect as useEffect3, useRef, useCallback } from "react";
 import { useConnect, useConfig } from "wagmi";
-import { getAccount as getAccount2 } from "@wagmi/core";
+import { getAccount } from "@wagmi/core";
 var hasMetaMaskKeyword = /* @__PURE__ */ __name((value) => value.toLowerCase().includes("metamask"), "hasMetaMaskKeyword");
 var hasWalletConnectKeyword = /* @__PURE__ */ __name((value) => value.toLowerCase().includes("walletconnect"), "hasWalletConnectKeyword");
 var isMetaMaskConnector = /* @__PURE__ */ __name((connector) => {
@@ -1292,7 +1426,7 @@ var useWagmiConnect = /* @__PURE__ */ __name(({ onConnect, onError, onQrUri, onS
       if (attemptCounter.current !== attemptId) {
         return;
       }
-      const address = (_b = (_a = result.accounts) == null ? void 0 : _a[0]) != null ? _b : getAccount2(config).address;
+      const address = (_b = (_a = result.accounts) == null ? void 0 : _a[0]) != null ? _b : getAccount(config).address;
       if (!address) {
         throw new Error("Connected but no account returned");
       }
@@ -1484,19 +1618,19 @@ var fetchWCWalletList = /* @__PURE__ */ __name(async (projectId, signal) => {
     if (!res.ok) throw new Error(`Failed to fetch wallet list: ${res.status}`);
     const json = await res.json();
     const listings = Object.values((_a = json.listings) != null ? _a : {});
-    for (const w of listings) {
-      if (byId.has(w.id)) continue;
-      byId.set(w.id, {
-        id: w.id,
-        name: w.name,
-        imageUrl: (_e = (_d = (_b = w.image_url) == null ? void 0 : _b.md) != null ? _d : (_c = w.image_url) == null ? void 0 : _c.sm) != null ? _e : "",
-        mobileNative: (_g = (_f = w.mobile) == null ? void 0 : _f.native) != null ? _g : "",
-        mobileUniversal: (_i = (_h = w.mobile) == null ? void 0 : _h.universal) != null ? _i : "",
-        desktopNative: (_k = (_j = w.desktop) == null ? void 0 : _j.native) != null ? _k : "",
-        desktopUniversal: (_m = (_l = w.desktop) == null ? void 0 : _l.universal) != null ? _m : "",
-        appIos: (_o = (_n = w.app) == null ? void 0 : _n.ios) != null ? _o : "",
-        appAndroid: (_q = (_p = w.app) == null ? void 0 : _p.android) != null ? _q : "",
-        homepage: (_r = w.homepage) != null ? _r : ""
+    for (const w2 of listings) {
+      if (byId.has(w2.id)) continue;
+      byId.set(w2.id, {
+        id: w2.id,
+        name: w2.name,
+        imageUrl: (_e = (_d = (_b = w2.image_url) == null ? void 0 : _b.md) != null ? _d : (_c = w2.image_url) == null ? void 0 : _c.sm) != null ? _e : "",
+        mobileNative: (_g = (_f = w2.mobile) == null ? void 0 : _f.native) != null ? _g : "",
+        mobileUniversal: (_i = (_h = w2.mobile) == null ? void 0 : _h.universal) != null ? _i : "",
+        desktopNative: (_k = (_j = w2.desktop) == null ? void 0 : _j.native) != null ? _k : "",
+        desktopUniversal: (_m = (_l = w2.desktop) == null ? void 0 : _l.universal) != null ? _m : "",
+        appIos: (_o = (_n = w2.app) == null ? void 0 : _n.ios) != null ? _o : "",
+        appAndroid: (_q = (_p = w2.app) == null ? void 0 : _p.android) != null ? _q : "",
+        homepage: (_r = w2.homepage) != null ? _r : ""
       });
     }
     if (listings.length < entries || byId.size >= json.total) break;
@@ -1981,7 +2115,7 @@ var ConnectKitProviderInner = /* @__PURE__ */ __name(({ children, siteKey, conne
   }, []);
   const close = useCallback4(() => {
     setIsOpen(false);
-    const status = getAccount3(wagmiConfig).status;
+    const status = getAccount2(wagmiConfig).status;
     if (status === "connecting" || status === "reconnecting") {
       disconnectAsync().catch(() => void 0);
     }
@@ -2091,22 +2225,14 @@ var useConnectKit = /* @__PURE__ */ __name(() => {
 }, "useConnectKit");
 
 // src/index.ts
+var bridged = Object.fromEntries(Object.entries(actions).map(([name, fn]) => [
+  name,
+  (...args) => fn(getConfig(), ...args)
+]));
 var connectKit = {
-  api: {
-    readContract,
-    writeContract,
-    getBalance,
-    switchChain,
-    getPublicClient,
-    waitForTransactionReceipt,
-    getAccount,
-    signMessage,
-    signTypedData,
-    watchAsset
-  },
-  events: {
-    watchAccount,
-    watchConnections,
+  actions: {
+    ...bridged,
+    ...wrappers_exports,
     reconnect,
     disconnectAll
   }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gluwa/connect-kit",
-  "version": "0.2.1-next.1",
+  "version": "0.2.1-next.4",
   "type": "module",
   "exports": {
     ".": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gluwa/connect-kit",
-  "version": "0.2.1-next.1",
+  "version": "0.2.1-next.4",
   "type": "module",
   "exports": {
     ".": {

package/src/api/wrappers.ts

@@ -0,0 +1,361 @@
+import * as w from '@wagmi/core/actions';
+import type {
+  Abi,
+  BlockTag,
+  ContractEventName,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+  FeeValuesType,
+  TypedData,
+  PrepareTransactionRequestRequest as ViemPrepareTransactionRequestRequest,
+} from 'viem';
+import type {
+  Config,
+  ConnectParameters,
+  ConnectReturnType,
+  Connector,
+  CreateConnectorFn,
+  DeployContractParameters,
+  DeployContractReturnType,
+  EstimateFeesPerGasParameters,
+  EstimateFeesPerGasReturnType,
+  EstimateGasParameters,
+  EstimateGasReturnType,
+  EstimateMaxPriorityFeePerGasParameters,
+  EstimateMaxPriorityFeePerGasReturnType,
+  GetBlockNumberParameters,
+  GetBlockNumberReturnType,
+  GetBlockParameters,
+  GetBlockReturnType,
+  GetBlockTransactionCountParameters,
+  GetBlockTransactionCountReturnType,
+  GetCapabilitiesParameters,
+  GetCapabilitiesReturnType,
+  GetClientParameters,
+  GetClientReturnType,
+  GetConnectorClientParameters,
+  GetConnectorClientReturnType,
+  GetFeeHistoryParameters,
+  GetFeeHistoryReturnType,
+  GetGasPriceParameters,
+  GetGasPriceReturnType,
+  GetPublicClientParameters,
+  GetPublicClientReturnType,
+  GetTransactionConfirmationsParameters,
+  GetTransactionConfirmationsReturnType,
+  GetTransactionParameters,
+  GetTransactionReceiptParameters,
+  GetTransactionReceiptReturnType,
+  GetTransactionReturnType,
+  GetWalletClientParameters,
+  GetWalletClientReturnType,
+  MulticallParameters,
+  MulticallReturnType,
+  PrepareTransactionRequestParameters,
+  PrepareTransactionRequestReturnType,
+  ReadContractParameters,
+  ReadContractReturnType,
+  ReadContractsParameters,
+  ReadContractsReturnType,
+  SelectChains,
+  SendCallsParameters,
+  SendCallsReturnType,
+  SendTransactionParameters,
+  SendTransactionReturnType,
+  SignTypedDataParameters,
+  SignTypedDataReturnType,
+  SimulateContractParameters,
+  SimulateContractReturnType,
+  SwitchChainParameters,
+  SwitchChainReturnType,
+  VerifyTypedDataParameters,
+  VerifyTypedDataReturnType,
+  WaitForTransactionReceiptParameters,
+  WaitForTransactionReceiptReturnType,
+  WatchBlockNumberParameters,
+  WatchBlockNumberReturnType,
+  WatchBlocksParameters,
+  WatchBlocksReturnType,
+  WatchClientParameters,
+  WatchClientReturnType,
+  WatchContractEventParameters,
+  WatchPendingTransactionsParameters,
+  WatchPublicClientParameters,
+  WatchPublicClientReturnType,
+  WriteContractParameters,
+  WriteContractReturnType,
+} from '@wagmi/core';
+import { getConfig } from '../core/config';
+
+export function connect<
+  connector extends Connector | CreateConnectorFn,
+  withCapabilities extends boolean = false,
+>(
+  parameters: ConnectParameters<Config, connector, withCapabilities>,
+): Promise<ConnectReturnType<Config, connector, withCapabilities>> {
+  return w.connect(getConfig(), parameters as never) as never;
+}
+
+export function deployContract<
+  const abi extends Abi | readonly unknown[],
+  chainId extends Config['chains'][number]['id'],
+>(parameters: DeployContractParameters<abi, Config, chainId>): Promise<DeployContractReturnType> {
+  return w.deployContract(getConfig(), parameters as never) as never;
+}
+
+export function estimateFeesPerGas<type extends FeeValuesType = 'eip1559'>(
+  parameters?: EstimateFeesPerGasParameters<type, Config>,
+): Promise<EstimateFeesPerGasReturnType<type>> {
+  return w.estimateFeesPerGas(getConfig(), parameters as never) as never;
+}
+
+export function estimateGas<chainId extends Config['chains'][number]['id'] | undefined = undefined>(
+  parameters: EstimateGasParameters<Config, chainId>,
+): Promise<EstimateGasReturnType> {
+  return w.estimateGas(getConfig(), parameters as never) as never;
+}
+
+export function estimateMaxPriorityFeePerGas<
+  chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'],
+>(
+  parameters?: EstimateMaxPriorityFeePerGasParameters<Config, chainId>,
+): Promise<EstimateMaxPriorityFeePerGasReturnType> {
+  return w.estimateMaxPriorityFeePerGas(getConfig(), parameters as never) as never;
+}
+
+export function getBlock<
+  chainId extends Config['chains'][number]['id'],
+  includeTransactions extends boolean = false,
+  blockTag extends BlockTag = 'latest',
+>(
+  parameters?: GetBlockParameters<includeTransactions, blockTag, Config, chainId>,
+): Promise<GetBlockReturnType<includeTransactions, blockTag, Config, chainId>> {
+  return w.getBlock(getConfig(), parameters as never) as never;
+}
+
+export function getBlockNumber<
+  chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'],
+>(parameters?: GetBlockNumberParameters<Config, chainId>): Promise<GetBlockNumberReturnType> {
+  return w.getBlockNumber(getConfig(), parameters as never) as never;
+}
+
+export function getBlockTransactionCount<
+  chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'],
+>(
+  parameters?: GetBlockTransactionCountParameters<Config, chainId>,
+): Promise<GetBlockTransactionCountReturnType> {
+  return w.getBlockTransactionCount(getConfig(), parameters as never) as never;
+}
+
+export function getCapabilities<
+  chainId extends Config['chains'][number]['id'] | undefined = undefined,
+>(
+  parameters?: GetCapabilitiesParameters<Config, chainId>,
+): Promise<GetCapabilitiesReturnType<Config, chainId>> {
+  return w.getCapabilities(getConfig(), parameters as never) as never;
+}
+
+export function getClient<chainId extends Config['chains'][number]['id'] | number | undefined>(
+  parameters?: GetClientParameters<Config, chainId>,
+): GetClientReturnType<Config, chainId> {
+  return w.getClient(getConfig(), parameters as never) as never;
+}
+
+export function getConnectorClient<chainId extends Config['chains'][number]['id']>(
+  parameters?: GetConnectorClientParameters<Config, chainId>,
+): Promise<GetConnectorClientReturnType<Config, chainId>> {
+  return w.getConnectorClient(getConfig(), parameters as never) as never;
+}
+
+export function getFeeHistory<
+  chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'],
+>(parameters: GetFeeHistoryParameters<Config, chainId>): Promise<GetFeeHistoryReturnType> {
+  return w.getFeeHistory(getConfig(), parameters as never) as never;
+}
+
+export function getGasPrice<
+  chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'],
+>(parameters?: GetGasPriceParameters<Config, chainId>): Promise<GetGasPriceReturnType> {
+  return w.getGasPrice(getConfig(), parameters as never) as never;
+}
+
+export function getPublicClient<
+  chainId extends Config['chains'][number]['id'] | number | undefined,
+>(
+  parameters?: GetPublicClientParameters<Config, chainId>,
+): GetPublicClientReturnType<Config, chainId> {
+  return w.getPublicClient(getConfig(), parameters as never) as never;
+}
+
+export function getTransaction<chainId extends Config['chains'][number]['id']>(
+  parameters: GetTransactionParameters<Config, chainId>,
+): Promise<GetTransactionReturnType<Config, chainId>> {
+  return w.getTransaction(getConfig(), parameters as never) as never;
+}
+
+export function getTransactionConfirmations<
+  chainId extends Config['chains'][number]['id'] | undefined = Config['chains'][number]['id'],
+>(
+  parameters: GetTransactionConfirmationsParameters<Config, chainId>,
+): Promise<GetTransactionConfirmationsReturnType> {
+  return w.getTransactionConfirmations(getConfig(), parameters as never) as never;
+}
+
+export function getTransactionReceipt<chainId extends Config['chains'][number]['id']>(
+  parameters: GetTransactionReceiptParameters<Config>,
+): Promise<GetTransactionReceiptReturnType<Config, chainId>> {
+  return w.getTransactionReceipt(getConfig(), parameters as never) as never;
+}
+
+export function getWalletClient<chainId extends Config['chains'][number]['id']>(
+  parameters?: GetWalletClientParameters<Config, chainId>,
+): Promise<GetWalletClientReturnType<Config, chainId>> {
+  return w.getWalletClient(getConfig(), parameters as never) as never;
+}
+
+export function multicall<
+  const contracts extends readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+>(
+  parameters: MulticallParameters<contracts, allowFailure, Config>,
+): Promise<MulticallReturnType<contracts, allowFailure>> {
+  return w.multicall(getConfig(), parameters as never) as never;
+}
+
+export function prepareTransactionRequest<
+  chainId extends Config['chains'][number]['id'] | undefined,
+  const request extends ViemPrepareTransactionRequestRequest<
+    SelectChains<Config, chainId>['0'],
+    SelectChains<Config, chainId>['0']
+  >,
+>(
+  parameters: PrepareTransactionRequestParameters<Config, chainId, request>,
+): Promise<PrepareTransactionRequestReturnType<Config, chainId, request>> {
+  return w.prepareTransactionRequest(getConfig(), parameters as never) as never;
+}
+
+export function readContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+>(
+  parameters: ReadContractParameters<abi, functionName, args, Config>,
+): Promise<ReadContractReturnType<abi, functionName, args>> {
+  return w.readContract(getConfig(), parameters as never) as never;
+}
+
+export function readContracts<
+  const contracts extends readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+>(
+  parameters: ReadContractsParameters<contracts, allowFailure, Config>,
+): Promise<ReadContractsReturnType<contracts, allowFailure>> {
+  return w.readContracts(getConfig(), parameters as never) as never;
+}
+
+export function sendCalls<
+  const calls extends readonly unknown[],
+  chainId extends Config['chains'][number]['id'],
+>(parameters: SendCallsParameters<Config, chainId, calls>): Promise<SendCallsReturnType> {
+  return w.sendCalls(getConfig(), parameters as never) as never;
+}
+
+export function sendTransaction<chainId extends Config['chains'][number]['id']>(
+  parameters: SendTransactionParameters<Config, chainId>,
+): Promise<SendTransactionReturnType> {
+  return w.sendTransaction(getConfig(), parameters as never) as never;
+}
+
+export function signTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(parameters: SignTypedDataParameters<typedData, primaryType>): Promise<SignTypedDataReturnType> {
+  return w.signTypedData(getConfig(), parameters as never) as never;
+}
+
+export function simulateContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
+  chainId extends Config['chains'][number]['id'] | undefined = undefined,
+>(
+  parameters: SimulateContractParameters<abi, functionName, args, Config, chainId>,
+): Promise<SimulateContractReturnType<abi, functionName, args, Config, chainId>> {
+  return w.simulateContract(getConfig(), parameters as never) as never;
+}
+
+export function switchChain<chainId extends Config['chains'][number]['id']>(
+  parameters: SwitchChainParameters<Config, chainId>,
+): Promise<SwitchChainReturnType<Config, chainId>> {
+  return w.switchChain(getConfig(), parameters as never) as never;
+}
+
+export function verifyTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  parameters: VerifyTypedDataParameters<typedData, primaryType, Config>,
+): Promise<VerifyTypedDataReturnType> {
+  return w.verifyTypedData(getConfig(), parameters as never) as never;
+}
+
+export function waitForTransactionReceipt<chainId extends Config['chains'][number]['id']>(
+  parameters: WaitForTransactionReceiptParameters<Config, chainId>,
+): Promise<WaitForTransactionReceiptReturnType<Config, chainId>> {
+  return w.waitForTransactionReceipt(getConfig(), parameters as never) as never;
+}
+
+export function watchBlockNumber<
+  chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'],
+>(parameters: WatchBlockNumberParameters<Config, chainId>): WatchBlockNumberReturnType {
+  return w.watchBlockNumber(getConfig(), parameters as never) as never;
+}
+
+export function watchBlocks<
+  chainId extends Config['chains'][number]['id'] = Config['chains'][number]['id'],
+  includeTransactions extends boolean = false,
+  blockTag extends BlockTag = 'latest',
+>(
+  parameters: WatchBlocksParameters<includeTransactions, blockTag, Config, chainId>,
+): WatchBlocksReturnType {
+  return w.watchBlocks(getConfig(), parameters as never) as never;
+}
+
+export function watchClient<chainId extends Config['chains'][number]['id']>(
+  parameters: WatchClientParameters<Config, chainId>,
+): WatchClientReturnType {
+  return w.watchClient(getConfig(), parameters as never) as never;
+}
+
+export function watchContractEvent<
+  chainId extends Config['chains'][number]['id'],
+  const abi extends Abi | readonly unknown[],
+  eventName extends ContractEventName<abi> | undefined,
+  strict extends boolean | undefined = undefined,
+>(parameters: WatchContractEventParameters<abi, eventName, strict, Config, chainId>): () => void {
+  return w.watchContractEvent(getConfig(), parameters as never) as never;
+}
+
+export function watchPendingTransactions<chainId extends Config['chains'][number]['id']>(
+  parameters: WatchPendingTransactionsParameters<Config, chainId>,
+): () => void {
+  return w.watchPendingTransactions(getConfig(), parameters as never) as never;
+}
+
+export function watchPublicClient<chainId extends Config['chains'][number]['id']>(
+  parameters: WatchPublicClientParameters<Config, chainId>,
+): WatchPublicClientReturnType {
+  return w.watchPublicClient(getConfig(), parameters as never) as never;
+}
+
+export function writeContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
+  chainId extends Config['chains'][number]['id'],
+>(
+  parameters: WriteContractParameters<abi, functionName, args, Config, chainId>,
+): Promise<WriteContractReturnType> {
+  return w.writeContract(getConfig(), parameters as never) as never;
+}

package/src/events/account.ts

@@ -1,24 +1,12 @@
 import {
-  watchAccount as wagmiWatchAccount,
-  watchConnections as wagmiWatchConnections,
   reconnect as wagmiReconnect,
   connect as wagmiConnect,
   getAccount as wagmiGetAccount,
   disconnect as wagmiDisconnect,
-  type WatchAccountParameters,
-  type WatchConnectionsParameters,
   type ReconnectReturnType,
 } from '@wagmi/core';
 import { getConfig, getKitConfig } from '../core/config';
 
-export const watchAccount = (params: WatchAccountParameters): (() => void) => {
-  return wagmiWatchAccount(getConfig(), params);
-};
-
-export const watchConnections = (params: WatchConnectionsParameters): (() => void) => {
-  return wagmiWatchConnections(getConfig(), params);
-};
-
 export const reconnect = async (): Promise<ReconnectReturnType> => {
   const config = getConfig();
 

package/src/index.ts

@@ -1,10 +1,7 @@
-import { readContract, writeContract } from './api/contract';
-import { getBalance } from './api/balance';
-import { switchChain, getPublicClient } from './api/chain';
-import { waitForTransactionReceipt } from './api/transaction';
-import { getAccount, signMessage, signTypedData } from './api/account';
-import { watchAsset } from './api/asset';
-import { watchAccount, watchConnections, reconnect, disconnectAll } from './events/account';
+import * as actions from '@wagmi/core/actions';
+import * as wrappers from './api/wrappers';
+import { reconnect, disconnectAll } from './events/account';
+import { getConfig } from './core/config';
 
 export { ConnectKitProvider, useConnectKit } from './ConnectKitProvider';
 export type { ConnectKitContextValue, ConnectKitProviderProps } from './ConnectKitProvider';
@@ -26,25 +23,32 @@ export type {
   WCWallet,
 } from './types';
 
-export const connectKit = {
-  api: {
-    readContract,
-    writeContract,
-    getBalance,
-    switchChain,
-    getPublicClient,
-    waitForTransactionReceipt,
-    getAccount,
-    signMessage,
-    signTypedData,
-    watchAsset,
-  },
-  events: {
-    watchAccount,
-    watchConnections,
+type StripConfig<T> = T extends (config: any, ...rest: infer A) => infer R
+  ? (...rest: A) => R
+  : never;
+
+type Bridge = { [K in keyof typeof actions]: StripConfig<(typeof actions)[K]> };
+
+const bridged = Object.fromEntries(
+  Object.entries(actions).map(([name, fn]) => [
+    name,
+    (...args: unknown[]) => (fn as (...a: unknown[]) => unknown)(getConfig(), ...args),
+  ]),
+) as Bridge;
+
+type KitActions = Omit<Bridge, keyof typeof wrappers | 'reconnect' | 'disconnectAll'> &
+  typeof wrappers & {
+    reconnect: typeof reconnect;
+    disconnectAll: typeof disconnectAll;
+  };
+
+export const connectKit: { readonly actions: KitActions } = {
+  actions: {
+    ...bridged,
+    ...wrappers,
     reconnect,
     disconnectAll,
   },
-} as const;
+};
 
 export type * from '@wagmi/core';

package/src/api/account.ts

@@ -1,21 +0,0 @@
-import {
-  getAccount as wagmiGetAccount,
-  signMessage as wagmiSignMessage,
-  signTypedData as wagmiSignTypedData,
-  type GetAccountReturnType,
-  type SignMessageParameters,
-  type SignTypedDataParameters,
-} from '@wagmi/core';
-import { getConfig } from '../core/config';
-
-export const getAccount = (): GetAccountReturnType => {
-  return wagmiGetAccount(getConfig());
-};
-
-export const signMessage = (params: SignMessageParameters): Promise<`0x${string}`> => {
-  return wagmiSignMessage(getConfig(), params);
-};
-
-export const signTypedData = (params: SignTypedDataParameters): Promise<`0x${string}`> => {
-  return wagmiSignTypedData(getConfig(), params);
-};

package/src/api/asset.ts

@@ -1,10 +0,0 @@
-import {
-  watchAsset as wagmiWatchAsset,
-  type WatchAssetParameters,
-  type WatchAssetReturnType,
-} from '@wagmi/core';
-import { getConfig } from '../core/config';
-
-export const watchAsset = (params: WatchAssetParameters): Promise<WatchAssetReturnType> => {
-  return wagmiWatchAsset(getConfig(), params);
-};

package/src/api/balance.ts

@@ -1,10 +0,0 @@
-import {
-  getBalance as wagmiGetBalance,
-  type GetBalanceParameters,
-  type GetBalanceReturnType,
-} from '@wagmi/core';
-import { getConfig } from '../core/config';
-
-export const getBalance = (params: GetBalanceParameters): Promise<GetBalanceReturnType> => {
-  return wagmiGetBalance(getConfig(), params);
-};

package/src/api/chain.ts

@@ -1,17 +0,0 @@
-import {
-  switchChain as wagmiSwitchChain,
-  getPublicClient as wagmiGetPublicClient,
-  type SwitchChainParameters,
-  type GetPublicClientParameters,
-  type GetPublicClientReturnType,
-} from '@wagmi/core';
-import type { Chain } from 'viem';
-import { getConfig } from '../core/config';
-
-export const switchChain = (params: SwitchChainParameters): Promise<Chain> => {
-  return wagmiSwitchChain(getConfig(), params);
-};
-
-export const getPublicClient = (params?: GetPublicClientParameters): GetPublicClientReturnType => {
-  return wagmiGetPublicClient(getConfig(), params);
-};

package/src/api/contract.ts

@@ -1,33 +0,0 @@
-import {
-  readContract as wagmiReadContract,
-  writeContract as wagmiWriteContract,
-  type ReadContractParameters,
-  type ReadContractReturnType,
-  type WriteContractParameters,
-  type WriteContractReturnType,
-  type Config,
-} from '@wagmi/core';
-import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem';
-import { getConfig } from '../core/config';
-
-export function readContract<
-  const abi extends Abi | readonly unknown[],
-  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
-  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
->(
-  parameters: ReadContractParameters<abi, functionName, args, Config>,
-): Promise<ReadContractReturnType<abi, functionName, args>> {
-  return wagmiReadContract(getConfig(), parameters as any) as Promise<
-    ReadContractReturnType<abi, functionName, args>
-  >;
-}
-
-export function writeContract<
-  const abi extends Abi | readonly unknown[],
-  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
-  args extends ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
->(
-  parameters: WriteContractParameters<abi, functionName, args, Config>,
-): Promise<WriteContractReturnType> {
-  return wagmiWriteContract(getConfig(), parameters as any);
-}

package/src/api/transaction.ts

@@ -1,12 +0,0 @@
-import {
-  waitForTransactionReceipt as wagmiWaitForTransactionReceipt,
-  type WaitForTransactionReceiptParameters,
-  type WaitForTransactionReceiptReturnType,
-} from '@wagmi/core';
-import { getConfig } from '../core/config';
-
-export const waitForTransactionReceipt = (
-  params: WaitForTransactionReceiptParameters,
-): Promise<WaitForTransactionReceiptReturnType> => {
-  return wagmiWaitForTransactionReceipt(getConfig(), params);
-};