@graphprotocol/graph-auth-kit 7.8.1

package/dist/hooks-D5Hw1GuR.js

@@ -0,0 +1,511 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { useMutation } from "@tanstack/react-query";
+import { watchAccount } from "@wagmi/core";
+import { useMemo, useState, useEffect } from "react";
+import { encodeFunctionData, getAddress, isAddress } from "viem";
+import { useChainId, useConnectorClient, useAccount, useConfig, useAccountEffect, useWalletClient } from "wagmi";
+import { writeContractMutationOptions } from "wagmi/query";
+import { b as createSafe, c as createApiKit, K as useGraphAuthKitInnerContext, I as clientToProvider, w as GraphAuthKitConnector, M as MULTISIG_AUTH_STORAGE_KEY, N as MultisigSchema } from "./GraphAuthKitInner.context-B3nCqd7x.js";
+import { VoidSigner } from "@ethersproject/abstract-signer";
+import "@safe-global/protocol-kit";
+import { OperationType } from "@safe-global/types-kit";
+import { BigNumber, utils } from "ethers";
+const createLibAddress = "0x7cbB62EaA69F79e6873cD1ecB2392971036cFAa4";
+const createLibInterface = new utils.Interface([
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "newContract",
+        type: "address"
+      }
+    ],
+    name: "ContractCreation",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "deploymentData",
+        type: "bytes"
+      }
+    ],
+    name: "performCreate",
+    outputs: [
+      {
+        internalType: "address",
+        name: "newContract",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "deploymentData",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32"
+      }
+    ],
+    name: "performCreate2",
+    outputs: [
+      {
+        internalType: "address",
+        name: "newContract",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+]);
+const mapStatus = (receipt) => {
+  const success = receipt.logs.find(
+    (log) => log.topics[0] === "0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e"
+  );
+  return success ? 1 : 0;
+};
+const mapContractAddress = (receipt, safeTx) => {
+  if (safeTx.to.toLowerCase() === createLibAddress.toLowerCase()) {
+    const creationLog = receipt.logs.find(
+      (log) => log.topics[0] === "0x4db17dd5e4732fb6da34a148104a592783ca119a1e7bb8829eba6cbadef0b511"
+    );
+    if (creationLog) return utils.getAddress("0x" + creationLog.data.slice(creationLog.data.length - 40));
+  }
+  return receipt.contractAddress;
+};
+const mapReceipt = (receipt, safeTx) => {
+  receipt.status = mapStatus(receipt);
+  receipt.contractAddress = mapContractAddress(receipt, safeTx);
+  return receipt;
+};
+const sleep = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+class SafeEthersSigner extends VoidSigner {
+  constructor(safeAddress, provider, signerAddress, chainId, options) {
+    super(safeAddress, provider);
+    __publicField(this, "safeAddress");
+    __publicField(this, "signerAddress");
+    __publicField(this, "chainId");
+    __publicField(this, "options");
+    __publicField(this, "safe");
+    __publicField(this, "apiKit");
+    this.signerAddress = signerAddress;
+    this.safeAddress = safeAddress;
+    this.chainId = chainId;
+    this.options = options;
+  }
+  async createSafeInstance() {
+    const eip1193Provider = {
+      request: async (args) => {
+        var _a;
+        return (_a = this.provider) == null ? void 0 : _a.send(args.method, args.params);
+      }
+    };
+    return createSafe({
+      provider: eip1193Provider,
+      signer: this.signerAddress,
+      safeAddress: this.safeAddress
+    });
+  }
+  async getSafeInstance() {
+    if (!this.safe) {
+      this.safe = await this.createSafeInstance();
+    }
+    return this.safe;
+  }
+  createApiKitInstance() {
+    var _a;
+    return createApiKit(this.chainId, (_a = this.options) == null ? void 0 : _a.apiKey);
+  }
+  async getApiKitInstance() {
+    if (!this.apiKit) {
+      this.apiKit = await this.createApiKitInstance();
+    }
+    return this.apiKit;
+  }
+  async getNextNonce() {
+    try {
+      const apiKit = await this.getApiKitInstance();
+      const nonce = await apiKit.getNextNonce(this.safeAddress);
+      return parseInt(nonce, 10);
+    } catch (error) {
+      throw new Error(`Failed to get next nonce: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async buildTransactionResponse(safeTxHash, safeTx) {
+    const connectedSafe = await this.getSafeInstance();
+    const connectedService = await this.getApiKitInstance();
+    const chainIdBigInt = await connectedSafe.getChainId();
+    return {
+      to: safeTx.to,
+      value: BigNumber.from(safeTx.value),
+      data: safeTx.data,
+      operation: safeTx.operation,
+      gasLimit: BigNumber.from(safeTx.safeTxGas),
+      gasPrice: BigNumber.from(0),
+      nonce: safeTx.nonce,
+      chainId: parseInt(chainIdBigInt.toString()),
+      hash: safeTxHash,
+      from: this.address,
+      confirmations: 0,
+      wait: async (confirmations) => {
+        var _a, _b;
+        while (true) {
+          try {
+            const txDetails = await connectedService.getTransaction(safeTxHash);
+            if (txDetails.transactionHash) {
+              this._checkProvider("sendTransaction");
+              const receipt = await ((_a = this.provider) == null ? void 0 : _a.waitForTransaction(
+                txDetails.transactionHash,
+                confirmations
+              ));
+              return mapReceipt(receipt, safeTx);
+            }
+          } catch (_e) {
+          }
+          await sleep(((_b = this.options) == null ? void 0 : _b.pollingDelay) ?? 5e3);
+        }
+      }
+    };
+  }
+  /**
+   * Populates all fields in a transaction, signs it and sends it to the Safe transaction service
+   *
+   * @param transaction - The transaction what should be send
+   * @returns A promise that resolves to a SafeTransactionReponse, that contains all the information of the transaction.
+   */
+  async sendTransaction(transaction) {
+    var _a;
+    const tx = await transaction;
+    let operation = OperationType.Call;
+    let to = await tx.to;
+    let data = ((_a = await tx.data) == null ? void 0 : _a.toString()) ?? "0x";
+    let value = BigNumber.from(await tx.value ?? 0);
+    if (!to) {
+      to = createLibAddress;
+      data = createLibInterface.encodeFunctionData("performCreate", [value, data]);
+      value = BigNumber.from(0);
+      operation = OperationType.DelegateCall;
+    }
+    const apiKit = await this.getApiKitInstance();
+    const nonce = await this.getNextNonce();
+    const safeTransactionData = {
+      to,
+      data,
+      value: value.toString(),
+      operation,
+      nonce
+    };
+    const estimateTx = await apiKit.estimateSafeTransaction(this.safeAddress, safeTransactionData);
+    safeTransactionData.safeTxGas = estimateTx.safeTxGas;
+    const connectedSafe = await this.getSafeInstance();
+    const safeTransaction = await connectedSafe.createTransaction({ transactions: [safeTransactionData] });
+    const safeTxHash = await connectedSafe.getTransactionHash(safeTransaction);
+    const senderSignature = await connectedSafe.signHash(safeTxHash);
+    await apiKit.proposeTransaction({
+      safeAddress: this.safeAddress,
+      safeTransactionData: safeTransaction.data,
+      safeTxHash,
+      senderAddress: this.signerAddress,
+      senderSignature: senderSignature.data
+    });
+    return this.buildTransactionResponse(safeTxHash, safeTransaction.data);
+  }
+}
+function safeViemActions(safeAddress, chainId, safeApiKey) {
+  return (client) => {
+    return {
+      async writeContract(parameters) {
+        const eip1193Provider = {
+          async request({ method, params }) {
+            if (method === "eth_requestAccounts") {
+              return client.requestAddresses();
+            }
+            if (method === "eth_accounts") {
+              return client.getAddresses();
+            }
+            if (method === "eth_signTypedData_v4") {
+              const arg = params && Array.isArray(params) ? params[1] : void 0;
+              const json = JSON.parse(arg);
+              return client.signTypedData(json);
+            }
+            if (method === "eth_sendTransaction") {
+              const tx = params && Array.isArray(params) ? params[0] : void 0;
+              return client.sendTransaction({
+                account: client.account,
+                chain: client.chain,
+                to: (tx == null ? void 0 : tx.to) || "0x",
+                value: tx == null ? void 0 : tx.value,
+                data: tx == null ? void 0 : tx.data,
+                nonce: tx == null ? void 0 : tx.nonce
+              });
+            }
+            return client.request({ method, params });
+          }
+        };
+        const apiKit = await createApiKit(chainId, safeApiKey);
+        const signerAddresses = await client.getAddresses();
+        const signerAddress = signerAddresses[0];
+        const protocolKit = await createSafe({ provider: eip1193Provider, signer: signerAddress, safeAddress });
+        const { abi, address, args, dataSuffix, functionName, value } = parameters;
+        const data = encodeFunctionData({
+          abi,
+          args,
+          functionName
+        });
+        const dataWithSuffix = `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`;
+        const operation = OperationType.Call;
+        let nonce;
+        try {
+          nonce = parseInt(await apiKit.getNextNonce(safeAddress), 10);
+        } catch (error) {
+          throw new Error(`Failed to get next nonce: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const safeTransactionData = {
+          to: address,
+          data: dataWithSuffix,
+          value: value ? value.toString() : "0",
+          operation,
+          nonce
+        };
+        const estimateTx = await apiKit.estimateSafeTransaction(safeAddress, safeTransactionData);
+        safeTransactionData.safeTxGas = estimateTx.safeTxGas;
+        const safeTransaction = await protocolKit.createTransaction({ transactions: [safeTransactionData] });
+        const safeTxHash = await protocolKit.getTransactionHash(safeTransaction);
+        const senderSignature = await protocolKit.signHash(safeTxHash);
+        await apiKit.proposeTransaction({
+          safeAddress,
+          safeTransactionData: safeTransaction.data,
+          safeTxHash,
+          senderAddress: signerAddress,
+          senderSignature: senderSignature.data
+        });
+        return safeTxHash;
+      }
+    };
+  };
+}
+function useClientToEthersSigner() {
+  const chainId = useChainId();
+  const { data: client, ...rest } = useConnectorClient({ chainId });
+  const { _enteredMultisigInfo, _safeApiKey } = useGraphAuthKitInnerContext();
+  return useMemo(() => {
+    if (rest.error) {
+      return { signer: void 0, ...rest };
+    }
+    if (rest.status === "pending" && !client) {
+      return { signer: void 0, ...rest };
+    }
+    if (!client) return { signer: null, ...rest };
+    const provider = clientToProvider(client);
+    if (_enteredMultisigInfo != null) {
+      const safeAddress = getAddress(_enteredMultisigInfo.address);
+      const safeEthersSigner = new SafeEthersSigner(
+        safeAddress,
+        provider,
+        client.account.address,
+        chainId,
+        { apiKey: _safeApiKey }
+      );
+      return { signer: safeEthersSigner, type: "multisig", ...rest };
+    }
+    return { signer: provider.getSigner(), type: "eoa", ...rest };
+  }, [chainId, client, rest.status, rest.error, _enteredMultisigInfo, _safeApiKey]);
+}
+function useGraphAuthKitConnector() {
+  const account = useGraphAuthKitAccount();
+  const { _enteredMultisigInfo } = useGraphAuthKitInnerContext();
+  if (account.connector == null) {
+    return null;
+  }
+  if ((_enteredMultisigInfo == null ? void 0 : _enteredMultisigInfo.address) != null || account.connectedWithMultisig) {
+    return "multisig";
+  }
+  const parsed = GraphAuthKitConnector.safeParse(account.connector.type);
+  return parsed.success ? parsed.data : null;
+}
+function useGraphAuthKitAccount() {
+  const data = useAccount();
+  const _enteredMultisigInfo = useMultisigInfo();
+  return useMemo(() => {
+    if (_enteredMultisigInfo != null && data.address != null) {
+      const address = getAddress(_enteredMultisigInfo.address);
+      const [, ...rest] = data.addresses ?? [];
+      return {
+        ...data,
+        address,
+        addresses: [address, data.address, ...rest],
+        eoa: data.address,
+        connectedWithMultisig: true
+      };
+    }
+    return {
+      ...data,
+      address: data.address,
+      addresses: data.addresses,
+      connector: data.connector,
+      eoa: void 0,
+      connectedWithMultisig: false
+    };
+  }, [data, _enteredMultisigInfo]);
+}
+function useAuthAccount() {
+  const auth = useGraphAuthKitAccount();
+  if (auth.address == null) {
+    throw new Error("Wallet is not connected");
+  }
+  return {
+    address: auth.address,
+    addresses: auth.addresses,
+    // not sure why this type assertion is necessary. but addresses comes across as [string, ...string[]]
+    chain: auth.chain,
+    chainId: auth.chainId,
+    connector: auth.connector,
+    eoa: auth.eoa,
+    connectedWithMultisig: auth.eoa != null
+  };
+}
+function useMultisigInfo({
+  config
+} = {}) {
+  const conf = useConfig({ config });
+  const { _enteredMultisigInfo } = useGraphAuthKitInnerContext();
+  const [multisigInfo, setMultisigInfo] = useState(null);
+  useAccountEffect({
+    onDisconnect() {
+      setMultisigInfo(null);
+    }
+  });
+  useEffect(() => {
+    async function retrieveFromStorage() {
+      var _a;
+      const multisigCookie = await ((_a = conf.storage) == null ? void 0 : _a.getItem(MULTISIG_AUTH_STORAGE_KEY));
+      if (multisigCookie) {
+        const parsedMultisigSchema = MultisigSchema.safeParse(
+          typeof multisigCookie === "string" ? JSON.parse(multisigCookie) : multisigCookie
+        );
+        if (parsedMultisigSchema.success && isAddress(parsedMultisigSchema.data.address)) {
+          setMultisigInfo(parsedMultisigSchema.data);
+        }
+      }
+    }
+    if (_enteredMultisigInfo != null) {
+      setMultisigInfo(_enteredMultisigInfo);
+    } else {
+      void retrieveFromStorage();
+    }
+  }, [conf, _enteredMultisigInfo]);
+  return multisigInfo;
+}
+function useGraphAuthKitAccountEffect(args = {}) {
+  const { onConnect, onDisconnect } = args;
+  const conf = useConfig(args);
+  const _enteredMultisigInfo = useMultisigInfo(args);
+  useEffect(() => {
+    return watchAccount(conf, {
+      onChange(account, prevAccount) {
+        if ((prevAccount.status === "reconnecting" || prevAccount.status === "connecting" && prevAccount.address === void 0) && account.status === "connected" || account.status === "connected" && account.address !== prevAccount.address) {
+          const { chain, chainId, connector } = account;
+          let { address, addresses } = account;
+          let eoa = void 0;
+          let connectedWithMultisig = false;
+          if (_enteredMultisigInfo != null) {
+            const [, ...rest] = addresses;
+            const multisigAddress = getAddress(_enteredMultisigInfo.address);
+            eoa = address;
+            address = multisigAddress;
+            addresses = [multisigAddress, eoa, ...rest];
+            connectedWithMultisig = true;
+          }
+          const isReconnected = prevAccount.status === "reconnecting" || // if `previousAccount.status` is `undefined`, the connector connected immediately.
+          prevAccount.status === void 0;
+          onConnect == null ? void 0 : onConnect({
+            address,
+            addresses,
+            eoa,
+            chain,
+            chainId,
+            connector,
+            isReconnected,
+            connectedWithMultisig
+          });
+        } else if (prevAccount.status === "connected" && account.status === "disconnected") {
+          onDisconnect == null ? void 0 : onDisconnect();
+        }
+      }
+    });
+  }, [conf, _enteredMultisigInfo, onConnect, onDisconnect]);
+}
+function useGraphAuthKitWalletClient() {
+  const walletClient = useWalletClient();
+  const _enteredMultisigInfo = useMultisigInfo();
+  const { _safeApiKey } = useGraphAuthKitInnerContext();
+  if (!walletClient.data) {
+    return walletClient;
+  }
+  if (_enteredMultisigInfo != null && _safeApiKey != null) {
+    const safeAddress = getAddress(_enteredMultisigInfo.address);
+    const safeWalletClient = walletClient.data.extend(
+      safeViemActions(safeAddress, _enteredMultisigInfo.network, _safeApiKey)
+    );
+    return { ...walletClient, data: safeWalletClient };
+  }
+  return walletClient;
+}
+function useGraphAuthKitWriteContract(parameters = {}) {
+  const { data: walletClient } = useGraphAuthKitWalletClient();
+  const { mutation } = parameters;
+  const conf = useConfig(parameters);
+  const mutationOptions = writeContractMutationOptions(conf);
+  const customMutationFn = (variables) => {
+    if (!walletClient) {
+      throw new Error("WalletClient is not available");
+    }
+    return walletClient.writeContract(variables);
+  };
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+    mutationFn: customMutationFn
+  });
+  return {
+    ...result,
+    writeContract: mutate,
+    writeContractAsync: mutateAsync
+  };
+}
+export {
+  SafeEthersSigner as S,
+  useGraphAuthKitAccount as a,
+  useGraphAuthKitConnector as b,
+  useClientToEthersSigner as c,
+  useAuthAccount as d,
+  useGraphAuthKitAccountEffect as e,
+  useGraphAuthKitWalletClient as f,
+  useGraphAuthKitWriteContract as g,
+  mapReceipt as m,
+  useMultisigInfo as u
+};

package/dist/hooks.d.ts

@@ -0,0 +1,125 @@
+import { Compute } from '@wagmi/core/internal';
+import { providers } from 'ethers';
+import { Address, Chain } from 'viem';
+import { Config, Connector, ResolvedRegister, UseAccountReturnType, UseConnectorClientReturnType, UseWalletClientReturnType, UseWriteContractParameters, UseWriteContractReturnType } from 'wagmi';
+import { MultisigSchema } from './inner/GraphAuthKitInner.context';
+import { SafeEthersSigner } from './safe/SafeEthersSigner';
+import { GraphAuthKitConnector } from './types';
+/**
+ * Hook to to convert a Viem Client to an ethers.js Signer:
+ * - if a multisig wallet is connected return an instance of SafeEthersSigner
+ * - if an EoA wallet is connected return the Signer from `clientToProvider`
+ */
+export declare function useClientToEthersSigner<const config extends Config = ResolvedRegister['config']>(): Omit<UseConnectorClientReturnType, "data"> & {
+    signer: providers.JsonRpcSigner | SafeEthersSigner | undefined | null;
+};
+export declare function useGraphAuthKitConnector<const config extends Config = ResolvedRegister['config']>(): GraphAuthKitConnector | null;
+export type UseGraphAuthKitAccountReturnType<config extends Config = ResolvedRegister['config']> = UseAccountReturnType<config> & Readonly<{
+    /** If the user is connected to a multisig, this is the EoA signer address the user is connected with */
+    eoa?: Address | null;
+    /** Flag on if the user is connected via a multisig */
+    connectedWithMultisig: boolean;
+}>;
+/**
+ * Override hook of wagmi `useAccount`.
+ * The GraphAuthKit lets users connect to a Safe by entering the Safe information in,
+ * and then connecting their EoA account through the other EoA wallet options.
+ *
+ * However, in this use-case, the connected account according to wagmi is still the EoA.
+ * This hook checks the inner context and if the user is connected via a multisig,
+ * returns the multisig address as the `address` return from the hook.
+ *
+ * Otherwise, returns the connected wallet state.
+ *
+ * @see https://wagmi.sh/react/api/hooks/useAccount
+ */
+export declare function useGraphAuthKitAccount<const config extends Config = ResolvedRegister['config']>(): UseGraphAuthKitAccountReturnType<config>;
+export type UseAuthAccountReturnType<config extends Config = Config, chain = Config extends config ? Chain : config['chains'][number]> = {
+    address: Address;
+    addresses: readonly [Address, ...Address[]];
+    chain: chain | undefined;
+    chainId: number;
+    connector: Connector;
+} & Readonly<{
+    /** If the user is connected to a multisig, this is the EoA signer address the user is connected with */
+    eoa?: Address | null;
+    /** Flag on if the user is connected via a multisig */
+    connectedWithMultisig: boolean;
+}>;
+/**
+ * Hook that returns the authenticated account information.
+ * If the wallet is not connected, an error is thrown.
+ * This hooks is useful to render where you _know_ the wallet is connected,
+ * preventing checks if the `address` is null further down the tree.
+ */
+export declare function useAuthAccount<const config extends Config = ResolvedRegister['config']>(): UseAuthAccountReturnType<config>;
+/**
+ * Retrieve the entered multisig info from:
+ * - the innter context object
+ * - if not in the inner context, check if found in storage
+ */
+export declare function useMultisigInfo<const config extends Config = ResolvedRegister['config']>({ config, }?: Readonly<{
+    config?: config;
+}>): MultisigSchema | null;
+export type UseGraphAuthKitAccountEffectArgs<config extends Config = ResolvedRegister['config']> = Compute<{
+    config?: config | undefined;
+    onConnect?(data: Compute<Pick<Extract<UseGraphAuthKitAccountReturnType<config>, {
+        status: 'connected';
+    }>, 'address' | 'addresses' | 'chain' | 'chainId' | 'connector' | 'eoa' | 'connectedWithMultisig'> & {
+        isReconnected: boolean;
+    }>): void;
+    onDisconnect?(): void;
+}>;
+/**
+ * Override hook of the wagmi `useAccountEffect` that listens to changes derived from the `useGraphAuthKitAccount` hook.
+ * Listening to the `useAccountEffect` hook does not work when the user connects via a multisig in the graph-auth-kit
+ * as the connected account is the EoA and not the Safe address.
+ * This hooks listens on account changes, but checks if the user has connected through a multisig.
+ *
+ * @see https://wagmi.sh/react/api/hooks/useAccountEffect
+ */
+export declare function useGraphAuthKitAccountEffect<const config extends Config = ResolvedRegister['config']>(args?: UseGraphAuthKitAccountEffectArgs<config>): void;
+/**
+ * Override hook of wagmi `useWalletClient`.
+ * The GraphAuthKit lets users connect to a Safe by entering the Safe information in,
+ * and then connecting their EoA account through the other EoA wallet options.
+ *
+ * However, in this use-case, the connected account according to wagmi is still the EoA.
+ * This hook checks the inner context and if the user is connected via a multisig,
+ * it returns the an extended version of the walletClient overriding the `writeContract` method.
+ *
+ * Otherwise, it returns the walletClient as is.
+ *
+ * @see https://wagmi.sh/react/api/hooks/useWalletClient
+ */
+export declare function useGraphAuthKitWalletClient<const config extends Config = ResolvedRegister['config']>(): UseWalletClientReturnType<config>;
+/**
+ * Override hook of wagmi `useWriteContract`.
+ * The GraphAuthKit lets users connect to a Safe by entering the Safe information in,
+ * and then connecting their EoA account through the other EoA wallet options.
+ *
+ * However, in this use-case, the connected account according to wagmi is still the EoA.
+ * This hook gets the WalletClient that could be the original EOA or the Safe's WalletClient,
+ * and then it calls the `writeContract` method on the client itself with the passed arguments.
+ * The returned values are the results of `useMutation` hook just like in wagmi's `useWriteContract`.
+ *
+ * @example
+ *
+ * function ComponentWithContractCall() {
+ *   const { data: walletClient } = useGraphAuthKitWalletClient()
+ *   const { writeContractAsync } = useGraphAuthKitWriteContract();
+ *
+ *   return (
+ *     <button
+ *        disabled={!walletClient}
+ *        onClick={() => writeContractAsync({ address: '0x...', abi: [], functionName: 'mint', args: [1] })}
+ *      >
+ *       {!walletClient ? "Loading..." : "Mint"}
+ *     </button>
+ *   )
+ * }
+ *
+ * @see https://wagmi.sh/react/api/hooks/useWriteContract
+ */
+export declare function useGraphAuthKitWriteContract<const config extends Config = ResolvedRegister['config'], context = unknown>(parameters?: UseWriteContractParameters<config, context>): UseWriteContractReturnType<config, context>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

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

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './client';
+export * from './Components';
+export * from './constants';
+export * from './ens';
+export * from './GraphAuthKit.context';
+export * from './hooks';
+export * from './safe';
+export * from './test-harness';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,OAAO,CAAA;AACrB,cAAc,wBAAwB,CAAA;AACtC,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}