@graphprotocol/graph-auth-kit 7.8.1

package/dist/utils-Br1fBg8o.js

@@ -0,0 +1,897 @@
+"use client";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { useConfig, WagmiProvider, useDisconnect, createConfig, createStorage, cookieStorage, cookieToInitialState } from "wagmi";
+import { injected, walletConnect, coinbaseWallet, mock } from "wagmi/connectors";
+import { K as useGraphAuthKitInnerContext, w as GraphAuthKitConnector, o as L2Chain, a as SafeSupportedNetworkNames, j as buildPublicClient, L as L1Chain, n as L1ChainTestnet, d as isValidSafe, S as SafeSupportedNetworks, P as GraphAuthKitInnerContextProvider, p as L2ChainTestnet, m as AUTH_STORAGE_KEY, x as chainIsSupportedChain, D as DefChain, l as buildClient, Q as GraphAuthKitInnerContext, T as defInnerState, R as RequiredInfuraKey, O as OptionalGatewayApiKey, q as SupportedClientChainId } from "./GraphAuthKitInner.context-B3nCqd7x.js";
+import { useState, useReducer, useId, useEffect, createContext, useContext } from "react";
+import { Icon, ExperimentalModal, ExperimentalButton, Alert, Link, ExperimentalLoadingIndicator, ExperimentalSelect, ExperimentalInput, Divider, List } from "@graphprotocol/gds";
+import { addrShortener } from "@graphprotocol/common";
+import { isAddress } from "viem";
+import { NetworkIcon } from "@graphprotocol/go";
+import { z } from "zod";
+import { buildEnsResolver } from "@graphprotocol/ens";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+function usePrimaryConnectOptions() {
+  const { connectors } = useConfig();
+  const ctx = useGraphAuthKitInnerContext();
+  const configuredConnectors = connectors.filter((c) => c.type === injected.type && c.name !== "Injected" || c.type !== injected.type).reduce((map, curr) => {
+    const connector = GraphAuthKitConnector.safeParse(curr.type);
+    return {
+      ...map,
+      [curr.name]: {
+        id: curr.id,
+        title: curr.name,
+        connector: connector.success ? connector.data : curr.type,
+        installed: curr.type === injected.type,
+        Image: correctConnectOptionIcon(curr),
+        async onConnect() {
+          void ctx._connect(curr);
+        }
+      }
+    };
+  }, {});
+  return [
+    ...Object.values(configuredConnectors).sort((a, b) => {
+      if (a.installed === b.installed) {
+        return 0;
+      }
+      return a.installed ? -1 : 1;
+    }),
+    {
+      id: "multisig",
+      title: "Safe",
+      connector: "multisig",
+      installed: false,
+      Image: /* @__PURE__ */ jsx(Icon.LogoSafeColor, { size: "24px" }),
+      onConnect() {
+        ctx._setModalState("safe_entry");
+      }
+    }
+  ];
+}
+function useMultisigConnectOptions() {
+  const { connectors } = useConfig();
+  const ctx = useGraphAuthKitInnerContext();
+  const configuredConnectors = connectors.filter((c) => c.type === injected.type && c.name !== "Injected" || c.type !== injected.type).reduce((map, curr) => {
+    const connector = GraphAuthKitConnector.safeParse(curr.type);
+    return {
+      ...map,
+      [curr.name]: {
+        id: curr.id,
+        title: curr.name,
+        connector: connector.success ? connector.data : curr.type,
+        installed: curr.type === injected.type,
+        Image: correctConnectOptionIcon(curr),
+        async onConnect() {
+          var _a, _b;
+          void ctx._connectMultisig({
+            connector: curr,
+            address: ((_a = ctx._enteredMultisigInfo) == null ? void 0 : _a.address) || "0x",
+            network: ((_b = ctx._enteredMultisigInfo) == null ? void 0 : _b.network) || L2Chain.id
+          });
+        }
+      }
+    };
+  }, {});
+  return Object.values(configuredConnectors).sort((a, b) => {
+    if (a.installed === b.installed) {
+      return 0;
+    }
+    return a.installed ? -1 : 1;
+  });
+}
+function correctConnectOptionIcon(conn) {
+  if (conn.icon != null) {
+    return /* @__PURE__ */ jsx("img", { src: conn.icon, alt: conn.name, className: "size-6" });
+  }
+  switch (conn.type) {
+    case coinbaseWallet.type: {
+      return /* @__PURE__ */ jsx(Icon.LogoCoinbaseWallet, { size: "24px" });
+    }
+    case walletConnect.type: {
+      return /* @__PURE__ */ jsx(Icon.LogoWalletConnectColor, { size: "24px" });
+    }
+    default: {
+      return /* @__PURE__ */ jsx(Icon.LogoMetaMaskColor, { size: "24px" });
+    }
+  }
+}
+function ConnectorOption(props) {
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      className: "flex w-full cursor-pointer items-center justify-between gap-x-2 rounded-4 border border-white/8 bg-white/4 p-3 text-white/48 hover:bg-white/8 hover:text-white aria-selected:border-purple aria-selected:text-white",
+      style: {
+        WebkitBackfaceVisibility: "hidden"
+      },
+      onClick: () => void props.onConnect(),
+      disabled: props.disabled,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-x-2", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex flex-col items-center justify-center", children: props.Image }),
+          /* @__PURE__ */ jsx("h6", { className: "text-h16 whitespace-nowrap text-inherit", children: props.title })
+        ] }),
+        props.installed ? /* @__PURE__ */ jsx("p", { className: "text-p12 text-white/48", children: "Installed" }) : null
+      ]
+    }
+  );
+}
+function MultisigSignerOptions() {
+  const config = useConfig();
+  const authKit = useGraphAuthKit();
+  const ctx = useGraphAuthKitInnerContext();
+  const multisigConnectOpts = useMultisigConnectOptions();
+  const [selectedConnector, setSelectedConnector] = useState(null);
+  if (ctx._enteredMultisigInfo == null || !ctx._enteredMultisigInfo.address) {
+    return /* @__PURE__ */ jsxs(ExperimentalModal.Step, { children: [
+      /* @__PURE__ */ jsx(ExperimentalModal.Header, { title: "Multisig Connection" }),
+      /* @__PURE__ */ jsx(ExperimentalModal.Body, { children: /* @__PURE__ */ jsx("h3", { className: "text-p18 text-center text-white/64", children: "No Safe address entered." }) }),
+      /* @__PURE__ */ jsx(
+        ExperimentalModal.Footer,
+        {
+          primaryButton: /* @__PURE__ */ jsx(ExperimentalButton, { iconBefore: /* @__PURE__ */ jsx(Icon.ArrowLeft, {}), onClick: () => ctx._setModalState("safe_entry"), children: "Enter Safe" }),
+          secondaryButton: /* @__PURE__ */ jsx(ExperimentalButton, { onClick: () => authKit.closeConnectModal(), children: "Cancel" })
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(ExperimentalModal.Step, { children: [
+    /* @__PURE__ */ jsx(ExperimentalModal.Header, { title: "Select a signing wallet" }),
+    /* @__PURE__ */ jsxs(ExperimentalModal.Body, { children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx(Icon.LogoSafeColor, { size: "16px" }),
+        /* @__PURE__ */ jsx("p", { className: "text-p12 text-white/64", children: addrShortener(ctx._enteredMultisigInfo.address) }),
+        /* @__PURE__ */ jsx(
+          ExperimentalButton,
+          {
+            variant: "tertiary",
+            size: "xsmall",
+            onClick: () => {
+              ctx._setSafeInfo(void 0);
+              ctx._setModalState("safe_entry");
+            },
+            children: "Change"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "mt-6", children: [
+        ctx._connectFailureMessage ? /* @__PURE__ */ jsx(
+          Alert,
+          {
+            severity: "error",
+            title: ctx._connectFailureMessage.title,
+            description: ctx._connectFailureMessage.description,
+            className: "mb-6"
+          }
+        ) : null,
+        /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-2", children: multisigConnectOpts.map((opt) => /* @__PURE__ */ jsx(
+          ConnectorOption,
+          {
+            ...opt,
+            disabled: ctx._authenticating,
+            selected: selectedConnector != null && selectedConnector.id === opt.id,
+            onConnect: () => {
+              const selected = config.connectors.find((c) => c.id === opt.id);
+              if (selected != null) {
+                setSelectedConnector(selected);
+                void opt.onConnect();
+              }
+            }
+          },
+          opt.id
+        )) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(ExperimentalModal.Footer, { children: /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx("p", { className: "text-p14", children: "Wallet didn't open?" }),
+        /* @__PURE__ */ jsxs(
+          Link.Secondary,
+          {
+            size: "14px",
+            onClick: () => {
+              if (selectedConnector == null || ctx._enteredMultisigInfo == null || !isAddress(ctx._enteredMultisigInfo.address)) {
+                return;
+              }
+              void ctx._connectMultisig({
+                connector: selectedConnector,
+                network: ctx._enteredMultisigInfo.network,
+                address: ctx._enteredMultisigInfo.address
+              });
+            },
+            children: [
+              "Try again ",
+              /* @__PURE__ */ jsx(Icon.RotateLeft, { size: "14px" })
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(ExperimentalButton, { variant: "tertiary", className: "hidden md:inline", onClick: () => authKit.closeConnectModal(), children: "Cancel" })
+    ] }) })
+  ] });
+}
+function PrimaryConnectOptions() {
+  const ctx = useGraphAuthKitInnerContext();
+  const primaryConnectOpts = usePrimaryConnectOptions();
+  const [selectedConnector, setSelectedConnector] = useState(null);
+  return /* @__PURE__ */ jsxs(ExperimentalModal.Step, { children: [
+    /* @__PURE__ */ jsx(
+      ExperimentalModal.Header,
+      {
+        title: ctx._modalTitle,
+        buttonBefore: ctx._authenticating ? /* @__PURE__ */ jsx(ExperimentalLoadingIndicator, {}) : void 0
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      ExperimentalModal.Body,
+      {
+        "aria-busy": ctx._authenticating ? "true" : void 0,
+        className: "aria-busy:opacity-64 aria-busy:pointer-events-none",
+        children: [
+          ctx._connectFailureMessage ? /* @__PURE__ */ jsx(
+            Alert,
+            {
+              severity: "error",
+              title: ctx._connectFailureMessage.title,
+              description: ctx._connectFailureMessage.description,
+              className: "mb-6"
+            }
+          ) : null,
+          /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-2", children: primaryConnectOpts.map((opt) => /* @__PURE__ */ jsx(
+            ConnectorOption,
+            {
+              ...opt,
+              disabled: ctx._authenticating,
+              selected: selectedConnector != null && selectedConnector === opt.id,
+              onConnect: () => {
+                setSelectedConnector(opt.connector);
+                void opt.onConnect();
+              }
+            },
+            opt.id
+          )) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(ExperimentalModal.Footer, { children: /* @__PURE__ */ jsxs("p", { className: "text-p12 text-white/64", children: [
+      "By connecting a wallet, you agree to The Graph's",
+      " ",
+      /* @__PURE__ */ jsx(Link.Inline, { href: "https://thegraph.com/terms-of-service/", target: "_blank", children: "Terms of Service" }),
+      " ",
+      "and acknowledge that you have read and understood the disclaimers therein."
+    ] }) })
+  ] });
+}
+z.union([
+  z.object({
+    action: z.literal("SET_NETWORK"),
+    payload: z.custom(
+      (val) => val != null && typeof val === "number" && SafeSupportedNetworks.safeParse(val).success
+    )
+  }),
+  z.object({
+    action: z.literal("SET_SAFE_ADDRESS"),
+    payload: z.string().min(42)
+  }),
+  z.object({
+    action: z.literal("SET_SAFE_VALID"),
+    payload: z.boolean().optional()
+  }),
+  z.object({
+    action: z.literal("RESET")
+  })
+]);
+function SafeInputFormReducer(state, action) {
+  switch (action.action) {
+    case "SET_NETWORK": {
+      return {
+        ...state,
+        network: action.payload
+      };
+    }
+    case "SET_SAFE_VALID": {
+      return {
+        ...state,
+        enteredSafeIsValid: action.payload
+      };
+    }
+    case "SET_SAFE_ADDRESS": {
+      return {
+        ...state,
+        address: action.payload
+      };
+    }
+    default: {
+      return {
+        ...state,
+        enteredSafeIsValid: void 0,
+        network: L2Chain.id,
+        address: "0x"
+      };
+    }
+  }
+}
+function SafeInputForm() {
+  const ctx = useGraphAuthKitInnerContext();
+  const previouslyUsedSafes = usePreviouslyUsedSafes();
+  const [state, dispatch] = useReducer(SafeInputFormReducer, {
+    network: L2Chain.id,
+    address: ""
+  });
+  async function validateMultisigSchema(_state) {
+    if (!isAddress(_state.address)) {
+      return dispatch({ action: "SET_SAFE_VALID", payload: false });
+    }
+    const client = buildPublicClient({
+      chain: _state.network === L2Chain.id ? L2Chain : _state.network === L1Chain.id ? L1Chain : L1ChainTestnet,
+      infuraKey: ctx._infuraKey
+    });
+    const valid = await isValidSafe({
+      clientOrBuildClientArgs: client,
+      chain: _state.network,
+      safeAddress: _state.address
+    });
+    dispatch({ action: "SET_SAFE_VALID", payload: valid });
+  }
+  const handleMultisigAddressChange = (entered) => {
+    var _a;
+    let networkId = void 0;
+    if (entered.includes(":")) {
+      const [shortName, address] = entered.split(":");
+      networkId = (_a = Object.values(SafeSupportedNetworkNames).find((supported) => supported.shortName === shortName)) == null ? void 0 : _a.id;
+      entered = address ?? "";
+      if (networkId) {
+        dispatch({ action: "SET_NETWORK", payload: networkId });
+      }
+    }
+    dispatch({ action: "SET_SAFE_ADDRESS", payload: entered });
+    void validateMultisigSchema({ ...state, network: networkId || state.network, address: entered });
+  };
+  const formId = useId();
+  const isSubmitDisabled = !state.address || !state.enteredSafeIsValid;
+  return /* @__PURE__ */ jsxs(ExperimentalModal.Step, { children: [
+    /* @__PURE__ */ jsx(ExperimentalModal.Header, { title: "Safe Multisig" }),
+    /* @__PURE__ */ jsx(ExperimentalModal.Body, { children: /* @__PURE__ */ jsxs(
+      "form",
+      {
+        id: formId,
+        noValidate: true,
+        onSubmit: (event) => {
+          event.preventDefault();
+          if (state.enteredSafeIsValid && state.address) {
+            previouslyUsedSafes.save(state.network, state.address);
+          }
+          ctx._setSafeInfo(state);
+          ctx._setModalState("safe_eoa_signer");
+        },
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-4", children: [
+            /* @__PURE__ */ jsx(
+              ExperimentalSelect,
+              {
+                placeholder: "Select Safe Network",
+                value: state.network,
+                onChange: (selected) => {
+                  dispatch({ action: "SET_NETWORK", payload: selected });
+                  void validateMultisigSchema({ ...state, network: selected });
+                },
+                valueLabel: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx(NetworkIcon, { network: { caip2Id: `eip155:${state.network}` } }),
+                  SafeSupportedNetworkNames[state.network].name
+                ] }),
+                children: Object.values(SafeSupportedNetworkNames).sort((a, b) => {
+                  if (a.id === L2Chain.id) {
+                    return -1;
+                  } else if (b.id === L2Chain.id) {
+                    return 1;
+                  }
+                  return a.id - b.id;
+                }).map((n) => /* @__PURE__ */ jsx(ExperimentalSelect.Option, { value: n.id, children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx(NetworkIcon, { network: { caip2Id: `eip155:${n.id}` } }),
+                  n.name
+                ] }) }, n.id))
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              ExperimentalInput,
+              {
+                id: "multisigAddress",
+                name: "multisigAddress",
+                label: "Multisig Address",
+                value: state.address || "",
+                onChange: handleMultisigAddressChange,
+                placeholder: "0x...",
+                status: state.enteredSafeIsValid !== void 0 && !state.enteredSafeIsValid && state.address ? "error" : state.enteredSafeIsValid ? "success" : void 0,
+                message: state.enteredSafeIsValid !== void 0 && !state.enteredSafeIsValid && state.address ? "Invalid Safe Adrress" : state.enteredSafeIsValid ? "Valid Safe Address" : void 0
+              }
+            )
+          ] }),
+          previouslyUsedSafes.values.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Divider, { className: "my-6" }),
+            /* @__PURE__ */ jsx("p", { className: "text-c12 text-white/64", children: "Previously used:" }),
+            /* @__PURE__ */ jsx(List.Bullets, { className: "mt-2", children: previouslyUsedSafes.values.map((safeAddress) => /* @__PURE__ */ jsx(List.Item, { children: /* @__PURE__ */ jsxs(
+              Link,
+              {
+                size: "12px",
+                autoIcon: false,
+                style: { transform: "translateY(-2.5px)" },
+                onClick: () => {
+                  var _a;
+                  const [shortName, address] = safeAddress.address.split(":");
+                  const networkId = (_a = Object.values(SafeSupportedNetworkNames).find(
+                    (supported) => supported.shortName === shortName
+                  )) == null ? void 0 : _a.id;
+                  if (networkId) {
+                    ctx._setSafeInfo({ network: networkId, address: address ?? "", enteredSafeIsValid: true });
+                    ctx._setModalState("safe_eoa_signer");
+                  } else {
+                    handleMultisigAddressChange(safeAddress.address);
+                  }
+                },
+                children: [
+                  /* @__PURE__ */ jsx("span", { className: "inline md:hidden", children: shortenMultisigAddress(safeAddress.address) }),
+                  /* @__PURE__ */ jsx("span", { className: "hidden md:inline", children: safeAddress.address })
+                ]
+              }
+            ) }, `${safeAddress.address}__${safeAddress.timestamp}`)) })
+          ] }) : null
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      ExperimentalModal.Footer,
+      {
+        primaryButton: /* @__PURE__ */ jsx(ExperimentalButton, { type: "submit", form: formId, disabled: isSubmitDisabled, iconAfter: /* @__PURE__ */ jsx(Icon.ArrowRight, { size: "16px" }), children: "Continue" }),
+        secondaryButton: /* @__PURE__ */ jsx(
+          ExperimentalButton,
+          {
+            onClick: () => {
+              dispatch({ action: "RESET" });
+              ctx._setModalState("primary");
+            },
+            children: "Back"
+          }
+        )
+      }
+    )
+  ] });
+}
+function shortenMultisigAddress(multisig) {
+  const [shortName, address] = multisig.split(":");
+  return `${shortName}:${addrShortener(address)}`;
+}
+function usePreviouslyUsedSafes() {
+  const SIZE = 3;
+  function safesDb(onSuccess) {
+    const openRequest = window.indexedDB.open("previouslyUsedSafes", 1);
+    openRequest.onerror = () => {
+    };
+    openRequest.onupgradeneeded = function() {
+      const db = this.result;
+      const store = db.createObjectStore("previouslyUsedSafes", { keyPath: "address" });
+      store.createIndex("timestamp", "timestamp", { unique: false });
+    };
+    openRequest.onsuccess = onSuccess;
+  }
+  const [previouslyUsedSafes, setPreviouslyUsedSafes] = useState([]);
+  useEffect(() => {
+    if (typeof window === "undefined" || !window.indexedDB) return;
+    safesDb(function() {
+      const db = this.result;
+      if (!db) return;
+      const transaction = db.transaction("previouslyUsedSafes", "readonly");
+      const objectStore = transaction.objectStore("previouslyUsedSafes");
+      const index = objectStore.index("timestamp");
+      const cursorRequest = index.openCursor(null, "prev");
+      const entries = [];
+      cursorRequest.onsuccess = function() {
+        const cursor = this.result;
+        if (cursor && entries.length < SIZE) {
+          entries.push(cursor.value);
+          cursor.continue();
+        }
+      };
+      transaction.oncomplete = function() {
+        setPreviouslyUsedSafes(entries);
+      };
+    });
+  }, []);
+  return {
+    values: [...new Set(previouslyUsedSafes)],
+    save(network, safeAddress) {
+      if (typeof window === "undefined" || !window.indexedDB || previouslyUsedSafes.some((entry2) => entry2.address === safeAddress)) {
+        return;
+      }
+      const shortName = SafeSupportedNetworkNames[network].shortName;
+      const entry = {
+        address: `${shortName}:${safeAddress}`,
+        timestamp: (/* @__PURE__ */ new Date()).getTime()
+      };
+      setPreviouslyUsedSafes((prev) => [...prev, entry].slice(0, SIZE));
+      safesDb(function() {
+        const db = this.result;
+        if (!db) {
+          return;
+        }
+        const transaction = db.transaction("previouslyUsedSafes", "readwrite");
+        const objectStore = transaction.objectStore("previouslyUsedSafes");
+        objectStore.put(entry);
+      });
+    }
+  };
+}
+function ConnectModal() {
+  const ctx = useGraphAuthKitInnerContext();
+  const steps = ["primary", "safe_entry", "safe_eoa_signer"];
+  const currentStep = ctx._modalState;
+  return /* @__PURE__ */ jsx(
+    ExperimentalModal,
+    {
+      open: ctx._connectModalOpen,
+      onClose: ctx._setConnectModalOpen,
+      steps: currentStep === "primary" ? [currentStep] : steps,
+      currentStep,
+      onCurrentStepChange: ctx._setModalState,
+      suppressHydrationWarning: true,
+      children: /* @__PURE__ */ jsx(ExperimentalModal.Step, { children: (() => {
+        switch (currentStep) {
+          case "primary":
+            return /* @__PURE__ */ jsx(PrimaryConnectOptions, {});
+          case "safe_entry":
+            return /* @__PURE__ */ jsx(SafeInputForm, {});
+          case "safe_eoa_signer":
+            return /* @__PURE__ */ jsx(MultisigSignerOptions, {});
+        }
+      })() })
+    }
+  );
+}
+const GraphAuthKitContext = createContext({
+  openConnectModal() {
+  },
+  closeConnectModal() {
+  },
+  disconnect() {
+  }
+});
+function useGraphAuthKit() {
+  return useContext(GraphAuthKitContext);
+}
+function GraphAuthKitProvider(props) {
+  const queryClient = props.queryClient ?? new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 60 * 1e3
+      }
+    }
+  });
+  return /* @__PURE__ */ jsx(WagmiProvider, { config: props.config, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(
+    GraphAuthKitInnerContextProvider,
+    {
+      config: props.config,
+      infuraKey: props.infuraKey,
+      gatewayApiKey: props.gatewayApiKey,
+      safeApiKey: props.safeApiKey,
+      children: /* @__PURE__ */ jsx(GraphAuthKitContent, { config: props.config, children: props.children })
+    }
+  ) }) });
+}
+function GraphAuthKitContent({
+  config,
+  children
+}) {
+  const { disconnect: disconnectAccount } = useDisconnect({ config });
+  const innerContext = useGraphAuthKitInnerContext();
+  return /* @__PURE__ */ jsxs(
+    GraphAuthKitContext.Provider,
+    {
+      value: {
+        openConnectModal(props) {
+          innerContext._reset();
+          innerContext._setConnectModalOpen(true);
+          innerContext._setModalTitle((props == null ? void 0 : props.title) ?? "Connect your wallet");
+          innerContext._setModalSubtitle(props == null ? void 0 : props.subtitle);
+          innerContext._setAfterConnectUrl(props == null ? void 0 : props.afterConnectUrl);
+        },
+        closeConnectModal() {
+          innerContext._setConnectModalOpen(false);
+        },
+        disconnect() {
+          disconnectAccount();
+          innerContext._reset();
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsx(ConnectModal, {}),
+        children
+      ]
+    }
+  );
+}
+function MockGraphAuthKitProvider(props) {
+  const mockConfig = createConfig({
+    chains: [L2Chain, L2ChainTestnet, L1Chain, L1ChainTestnet],
+    connectors: [mock(props.mockConnectorParams)],
+    client(params) {
+      const chain = chainIsSupportedChain(params.chain) ? params.chain : DefChain;
+      return buildClient({ chain, infuraKey: props.infuraKey });
+    },
+    storage: createStorage({
+      storage: cookieStorage,
+      key: AUTH_STORAGE_KEY
+    })
+  });
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false
+      }
+    }
+  });
+  const initialState = props.initialState == null ? void 0 : typeof props.initialState === "string" ? cookieToInitialState(mockConfig, props.initialState) : props.initialState;
+  return /* @__PURE__ */ jsx(WagmiProvider, { config: mockConfig, initialState, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(GraphAuthKitInnerContext.Provider, { value: props.innerCtxState ?? defInnerState, children: /* @__PURE__ */ jsx(MockGraphAuthKitContent, { children: props.children }) }) }) });
+}
+function MockGraphAuthKitContent({ children }) {
+  const { disconnect } = useDisconnect();
+  const innerContext = useGraphAuthKitInnerContext();
+  return /* @__PURE__ */ jsx(
+    GraphAuthKitContext.Provider,
+    {
+      value: {
+        openConnectModal(props) {
+          innerContext._reset();
+          innerContext._setConnectModalOpen(true);
+          innerContext._setModalTitle((props == null ? void 0 : props.title) ?? "Connect your wallet");
+          innerContext._setModalSubtitle(props == null ? void 0 : props.subtitle);
+        },
+        closeConnectModal() {
+          innerContext._setConnectModalOpen(false);
+        },
+        disconnect() {
+          disconnect(
+            {},
+            {
+              onSettled() {
+                innerContext._reset();
+              }
+            }
+          );
+        }
+      },
+      children
+    }
+  );
+}
+z.union([
+  RequiredInfuraKey.merge(OptionalGatewayApiKey).extend({ status: z.literal("disconnected") }),
+  RequiredInfuraKey.merge(OptionalGatewayApiKey).extend({
+    status: z.literal("connected"),
+    account: z.union([
+      z.object({ type: z.literal("generated") }),
+      z.object({
+        type: z.literal("provided"),
+        /** If the specified connection is with a multisig, this is the multisig address */
+        address: z.custom((val) => val != null && typeof val === "string" && isAddress(val)),
+        chain: SupportedClientChainId.optional().default(L2Chain.id),
+        connector: z.union([
+          z.object({
+            type: z.union([
+              z.literal(injected.type),
+              z.literal(coinbaseWallet.type),
+              z.literal(walletConnect.type)
+            ])
+          }),
+          /** If specified as a multsig, provide the EoA and Safe supported chain */
+          z.object({
+            type: z.literal("multisig"),
+            eoa: z.custom((val) => val != null && typeof val === "string" && isAddress(val)),
+            network: SafeSupportedNetworks.optional().default(L2Chain.id)
+          })
+        ])
+      })
+    ])
+  })
+]);
+function buildMockProviderState(args) {
+  if (args.status === "disconnected") {
+    return {
+      props: {
+        infuraKey: args.infuraKey,
+        gatewayApiKey: args.gatewayApiKey,
+        initialState: void 0,
+        innerCtxState: {
+          ...defInnerState,
+          _infuraKey: args.infuraKey,
+          _gatewayApiKey: args.gatewayApiKey,
+          _ensResolver: buildEnsResolver({ infuraKey: args.infuraKey, gatewayApiKey: args.gatewayApiKey })
+        },
+        mockConnectorParams: {
+          accounts: ["0x"]
+        }
+      },
+      connectedAddress: null,
+      connector: null,
+      graphAuthKitConnector: null,
+      chain: null
+    };
+  }
+  const getConnectorFunctions = (address, chain) => {
+    return {
+      getAccounts: async () => {
+        return [{ address }];
+      },
+      getChainId: async () => {
+        return chain;
+      },
+      getProvider: async () => {
+        return {
+          request: async () => {
+          }
+        };
+      }
+    };
+  };
+  if (args.account.type === "generated") {
+    const privKey = generatePrivateKey();
+    const account = privateKeyToAccount(privKey);
+    const address = account.address;
+    const connector2 = selectedTypeToMockConnector("injected");
+    return {
+      props: {
+        infuraKey: args.infuraKey,
+        gatewayApiKey: args.gatewayApiKey,
+        initialState: {
+          status: "connected",
+          chainId: L2Chain.id,
+          connections: /* @__PURE__ */ new Map([
+            [
+              connector2.uid,
+              {
+                accounts: [address],
+                chainId: L2Chain.id,
+                connector: {
+                  ...connector2,
+                  ...getConnectorFunctions(address, L2Chain.id)
+                }
+              }
+            ]
+          ]),
+          current: connector2.uid
+        },
+        innerCtxState: {
+          ...defInnerState,
+          _infuraKey: args.infuraKey,
+          _gatewayApiKey: args.gatewayApiKey,
+          _ensResolver: buildEnsResolver({ infuraKey: args.infuraKey, gatewayApiKey: args.gatewayApiKey })
+        },
+        mockConnectorParams: {
+          accounts: [address]
+        }
+      },
+      connectedAddress: address,
+      connector: connector2,
+      graphAuthKitConnector: "injected",
+      chain: L2Chain.id
+    };
+  }
+  if (args.account.connector.type === "multisig") {
+    const connector2 = selectedTypeToMockConnector("injected");
+    return {
+      props: {
+        infuraKey: args.infuraKey,
+        gatewayApiKey: args.gatewayApiKey,
+        initialState: {
+          status: "connected",
+          chainId: args.account.connector.network,
+          connections: /* @__PURE__ */ new Map([
+            [
+              connector2.uid,
+              {
+                accounts: [args.account.connector.eoa],
+                chainId: args.account.connector.network,
+                connector: {
+                  ...connector2,
+                  ...getConnectorFunctions(args.account.connector.eoa, args.account.connector.network)
+                }
+              }
+            ]
+          ]),
+          current: connector2.uid
+        },
+        innerCtxState: {
+          ...defInnerState,
+          _infuraKey: args.infuraKey,
+          _gatewayApiKey: args.gatewayApiKey,
+          _ensResolver: buildEnsResolver({ infuraKey: args.infuraKey, gatewayApiKey: args.gatewayApiKey }),
+          _enteredMultisigInfo: {
+            address: args.account.address,
+            network: args.account.connector.network,
+            enteredSafeIsValid: true
+          }
+        },
+        mockConnectorParams: {
+          accounts: [args.account.address, args.account.connector.eoa]
+        }
+      },
+      connectedAddress: args.account.address,
+      connector: connector2,
+      graphAuthKitConnector: "multisig",
+      chain: args.account.connector.network
+    };
+  }
+  const connector = selectedTypeToMockConnector(args.account.connector.type);
+  return {
+    props: {
+      infuraKey: args.infuraKey,
+      gatewayApiKey: args.gatewayApiKey,
+      initialState: {
+        status: "connected",
+        chainId: args.account.chain,
+        connections: /* @__PURE__ */ new Map([
+          [
+            connector.uid,
+            {
+              accounts: [args.account.address],
+              chainId: args.account.chain,
+              connector: {
+                ...connector,
+                ...getConnectorFunctions(args.account.address, args.account.chain)
+              }
+            }
+          ]
+        ]),
+        current: connector.uid
+      },
+      innerCtxState: {
+        ...defInnerState,
+        _infuraKey: args.infuraKey,
+        _gatewayApiKey: args.gatewayApiKey,
+        _ensResolver: buildEnsResolver({ infuraKey: args.infuraKey, gatewayApiKey: args.gatewayApiKey })
+      },
+      mockConnectorParams: {
+        accounts: [args.account.address]
+      }
+    },
+    connectedAddress: args.account.address,
+    connector,
+    graphAuthKitConnector: args.account.connector.type,
+    chain: args.account.chain
+  };
+}
+const disconnectedMockState = buildMockProviderState({
+  infuraKey: "doesnotmatter.notconnected",
+  status: "disconnected"
+});
+function selectedTypeToMockConnector(connector) {
+  switch (connector) {
+    case "coinbaseWallet": {
+      return {
+        id: "coinbaseWalletSDK",
+        name: "Coinbase Wallet",
+        uid: "192a483cf83",
+        type: "coinbaseWallet"
+      };
+    }
+    case "walletConnect": {
+      return {
+        id: "walletConnect",
+        name: "WalletConnect",
+        uid: "92a483cf83b",
+        type: "walletConnect"
+      };
+    }
+    case "multisig":
+    default: {
+      return { id: "io.metamask", name: "MetaMask", type: "injected", uid: "27cbd81134e" };
+    }
+  }
+}
+export {
+  GraphAuthKitContext as G,
+  MockGraphAuthKitProvider as M,
+  GraphAuthKitProvider as a,
+  buildMockProviderState as b,
+  disconnectedMockState as d,
+  useGraphAuthKit as u
+};