@graphprotocol/graph-auth-kit 7.8.1

package/dist/GraphAuthKitInner.context-B3nCqd7x.js

@@ -0,0 +1,629 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { buildEnsResolver } from "@graphprotocol/ens";
+import { createContext, useContext, useRef, useState } from "react";
+import { http, createPublicClient, createClient, isAddress } from "viem";
+import { useConnect, useDisconnect, useAccountEffect } from "wagmi";
+import { z } from "zod";
+import { l1Mainnet, l1Testnet, l2Mainnet, l2Testnet } from "@graphprotocol/common";
+import { mainnet, sepolia, arbitrum, arbitrumSepolia } from "viem/chains";
+import { injected, coinbaseWallet, walletConnect } from "wagmi/connectors";
+import "@safe-global/protocol-kit";
+import { providers } from "ethers";
+const AUTH_STORAGE_KEY = "thegraph__authstate";
+const MULTISIG_AUTH_STORAGE_KEY = "multisig";
+const L1Chain = { ...mainnet, graphCliName: l1Mainnet.id, caip2Id: l1Mainnet.caip2Id };
+const L1ChainTestnet = { ...sepolia, graphCliName: l1Testnet.id, caip2Id: l1Testnet.caip2Id };
+const L2Chain = { ...arbitrum, graphCliName: l2Mainnet.id, caip2Id: l2Mainnet.caip2Id };
+const L2ChainTestnet = { ...arbitrumSepolia, graphCliName: l2Testnet.id, caip2Id: l2Testnet.caip2Id };
+const DefChain = L2Chain;
+const SupportedClientChainId = z.union([
+  z.literal(L1Chain.id),
+  z.literal(L1ChainTestnet.id),
+  z.literal(L2Chain.id),
+  z.literal(L2ChainTestnet.id)
+]).readonly();
+const SupportedClientChains = [L2Chain, L2ChainTestnet, L1Chain, L1ChainTestnet];
+const SupportedL1ClientChainId = z.union([z.literal(L1Chain.id), z.literal(L1ChainTestnet.id)]).readonly();
+const SupportedL2ClientChainId = z.union([z.literal(L2Chain.id), z.literal(L2ChainTestnet.id)]).readonly();
+const RequiredInfuraKey = z.object({
+  infuraKey: z.string({ error: "The Infura Key is required" }).min(1).readonly()
+});
+const RequiredWalletConnectProjectId = z.object({
+  walletConnectProjectID: z.string({ error: "The WalletConnect Project ID is required" }).min(1).readonly()
+});
+const OptionalGatewayApiKey = z.object({
+  gatewayApiKey: z.string().min(32).max(32).optional().nullable().describe("The Graph Gateway API Key used to query Subgraphs published on The Graph Network")
+});
+const OptionalSafeApiKey = z.object({
+  safeApiKey: z.string().min(1).optional().describe("The Safe Transaction Service API Key")
+});
+const GraphAuthKitProps = RequiredInfuraKey.merge(OptionalGatewayApiKey).merge(OptionalSafeApiKey);
+const GraphAuthKitConnector = z.union([
+  z.literal(injected.type),
+  z.literal(coinbaseWallet.type),
+  z.literal(walletConnect.type),
+  z.literal("multisig")
+]);
+RequiredInfuraKey.extend({
+  chain: SupportedClientChainId.optional().nullable().default(DefChain.id)
+});
+function buildInfuraHttpTransport({
+  chain = DefChain.id,
+  infuraKey
+}) {
+  switch (chain) {
+    case L1Chain.id: {
+      return http(`https://mainnet.infura.io/v3/${infuraKey}`);
+    }
+    case L1ChainTestnet.id: {
+      return http(`https://sepolia.infura.io/v3/${infuraKey}`);
+    }
+    case L2ChainTestnet.id: {
+      return http(`https://arbitrum-sepolia.infura.io/v3/${infuraKey}`);
+    }
+    default: {
+      return http(`https://arbitrum-mainnet.infura.io/v3/${infuraKey}`);
+    }
+  }
+}
+const BuildPublicClientArgs = RequiredInfuraKey.extend({
+  chain: z.custom().optional().default(DefChain)
+});
+function isBuildPublicClientArgs(args) {
+  return args != null && typeof args === "object" && typeof args.infuraKey === "string";
+}
+function buildPublicClient({ chain = DefChain, infuraKey }) {
+  const transport = buildInfuraHttpTransport({
+    chain: chain.id,
+    infuraKey
+  });
+  return createPublicClient({
+    chain,
+    transport
+  });
+}
+const BuildClientArgs = RequiredInfuraKey.extend({
+  chain: z.custom().optional().default(DefChain)
+});
+function buildClient({ chain = DefChain, infuraKey }) {
+  const transport = buildInfuraHttpTransport({
+    chain: chain.id,
+    infuraKey
+  });
+  return createClient({
+    chain,
+    transport
+  });
+}
+const MultisigErrorMap = {
+  INVALID_SIGNER: {
+    title: "Signer Wallet is Invalid",
+    description: "This wallet is not a valid signing wallet for the Multisig. You can try again with a different wallet using the options below."
+  },
+  INVALID_NETWORK: {
+    title: "Invalid network",
+    description: "The signing wallet must be connected to the same network as the Multisig."
+  }
+};
+const SafeSupportedNetworks = z.union([z.literal(L1Chain.id), z.literal(L1ChainTestnet.id), z.literal(L2Chain.id)]).readonly();
+function isSafeSupportedNetwork(network) {
+  return SafeSupportedNetworks.safeParse(network).success;
+}
+const SafeSupportedNetworkNames = {
+  [L2Chain.id]: { shortName: "arb1", name: L2Chain.name, id: L2Chain.id },
+  [L1Chain.id]: { shortName: "eth", name: L1Chain.name, id: L1Chain.id },
+  [L1ChainTestnet.id]: { shortName: "sep", name: L1ChainTestnet.name, id: L1ChainTestnet.id }
+};
+const ApiKitUrlMap = {
+  [L1Chain.id]: "https://api.safe.global/tx-service/eth/api",
+  [L1ChainTestnet.id]: "https://api.safe.global/tx-service/sep/api",
+  [L2Chain.id]: "https://api.safe.global/tx-service/arb1/api"
+};
+const SafeMinimalAbi = [
+  {
+    inputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "getThreshold",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "getOwners",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "",
+        type: "address[]"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_data",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "_signature",
+        type: "bytes"
+      }
+    ],
+    name: "isValidSignature",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "nonce",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "isOwner",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  }
+];
+async function createApiKit(chainId, apiKey) {
+  const { default: SafeApiKit } = await import("@safe-global/api-kit");
+  const SafeApiKitClass = typeof SafeApiKit === "function" ? SafeApiKit : SafeApiKit.default;
+  const apiKit = new SafeApiKitClass({
+    chainId: BigInt(chainId),
+    apiKey
+  });
+  return apiKit;
+}
+async function createSafe(config) {
+  const { default: Safe2 } = await import("@safe-global/protocol-kit");
+  const SafeClass = typeof Safe2 === "function" ? Safe2 : Safe2.default;
+  return await SafeClass.init(config);
+}
+async function isValidSafe(args) {
+  try {
+    const client = isBuildPublicClientArgs(args.clientOrBuildClientArgs) ? buildPublicClient(args.clientOrBuildClientArgs) : args.clientOrBuildClientArgs;
+    await client.readContract({
+      address: args.safeAddress,
+      abi: SafeMinimalAbi,
+      functionName: "getThreshold"
+    });
+    return true;
+  } catch (err) {
+    console.warn("isValidSafe - failure checking safe", { err: err.message });
+    return false;
+  }
+}
+async function isSafeOwner(args) {
+  try {
+    const client = isBuildPublicClientArgs(args.clientOrBuildClientArgs) ? buildPublicClient(args.clientOrBuildClientArgs) : args.clientOrBuildClientArgs;
+    return await client.readContract({
+      address: args.safeAddress,
+      abi: SafeMinimalAbi,
+      functionName: "isOwner",
+      args: [args.eoa]
+    });
+  } catch (err) {
+    console.warn("isSafeOwner - failure checking if EoA is Safe owner", { err: err.message });
+    return false;
+  }
+}
+async function fetchOwnedSafes(args) {
+  let safes = {};
+  for (const chain of args.chains ?? [L2Chain.id, L1Chain.id, L1ChainTestnet.id]) {
+    const chainSafes = await fetchSafesByChain(args.signer, chain);
+    safes = { ...safes, [chain]: chainSafes };
+  }
+  return safes;
+}
+const OwnerResponseSchema = z.object({
+  safes: z.array(z.custom((val) => val != null && typeof val === "string" && isAddress(val)))
+});
+async function fetchSafesByChain(signer, chain) {
+  const txServiceUrl = ApiKitUrlMap[chain];
+  const response = await fetch(`${txServiceUrl}/v1/owners/${signer}/safes/`, {
+    method: "get",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    }
+  });
+  if (response.status !== 200) {
+    return [];
+  }
+  const json = await response.json();
+  const parsed = OwnerResponseSchema.safeParse(json);
+  if (!parsed.success) {
+    return [];
+  }
+  return parsed.data.safes;
+}
+function chainIsSupportedChain(chain) {
+  return SupportedClientChainId.safeParse(chain.id).success;
+}
+function isSupportedChainId(chainId) {
+  return SupportedClientChainId.safeParse(chainId).success;
+}
+function mapChainIdToChain(chainId) {
+  const _chainId = isSupportedChainId(chainId) ? chainId : DefChain.id;
+  switch (_chainId) {
+    case L1Chain.id: {
+      return L1Chain;
+    }
+    case L1ChainTestnet.id: {
+      return L1ChainTestnet;
+    }
+    case L2ChainTestnet.id: {
+      return L2ChainTestnet;
+    }
+    default: {
+      return L2Chain;
+    }
+  }
+}
+function isChainL2(chain) {
+  return chain === L2Chain.id || chain === L2ChainTestnet.id;
+}
+function isChainL1(chain) {
+  return chain === L1Chain.id || chain === L1ChainTestnet.id;
+}
+function isChainMainnet(chain) {
+  return chain === L1Chain.id || chain === L2Chain.id;
+}
+function isChainTestnet(chain) {
+  return chain === L1ChainTestnet.id || chain === L2ChainTestnet.id;
+}
+function clientToProvider(client) {
+  var _a, _b;
+  const { chain, transport } = client;
+  const network = {
+    chainId: chain.id,
+    name: chain.name,
+    ensAddress: (_b = (_a = chain.contracts) == null ? void 0 : _a.ensRegistry) == null ? void 0 : _b.address
+  };
+  const provider = new providers.Web3Provider(transport, network);
+  return provider;
+}
+async function connectedWalletIsEoA(client, address) {
+  const code = await client.getCode({ address });
+  return code == null || code === "0x";
+}
+const MultisigSchema = z.object({
+  network: z.custom(
+    (val) => val != null && typeof val === "number" && SafeSupportedNetworks.safeParse(val).success
+  ),
+  address: z.string().min(42),
+  enteredSafeIsValid: z.boolean().optional()
+});
+const defInnerState = {
+  _infuraKey: "",
+  _gatewayApiKey: null,
+  _safeApiKey: void 0,
+  // just a default value so that the context can be initialized. overridden in the provider
+  _ensResolver: {
+    async resolveEnsName() {
+      return null;
+    },
+    async resolveEnsNamesBatch() {
+      return {};
+    },
+    async resolveAvatar() {
+      return null;
+    },
+    async resolveAvatarsBatch() {
+      return {};
+    }
+  },
+  _connectModalOpen: false,
+  _setConnectModalOpen() {
+  },
+  _modalTitle: "Connect your wallet",
+  _setModalTitle() {
+  },
+  _setModalSubtitle() {
+  },
+  _setAfterConnectUrl() {
+  },
+  _modalState: "primary",
+  _setModalState() {
+  },
+  _setSafeInfo() {
+  },
+  _authenticating: false,
+  _setAuthenticating() {
+  },
+  _connect() {
+  },
+  _connectMultisig() {
+  },
+  _reset() {
+  }
+};
+const GraphAuthKitInnerContext = createContext(defInnerState);
+function useGraphAuthKitInnerContext() {
+  return useContext(GraphAuthKitInnerContext);
+}
+function GraphAuthKitInnerContextProvider({
+  config,
+  infuraKey,
+  gatewayApiKey,
+  safeApiKey,
+  children
+}) {
+  const { connect } = useConnect({ config });
+  const { disconnect } = useDisconnect({ config });
+  const firstConnectCheckRef = useRef();
+  const [_connectModalOpen, setConnectModalOpen] = useState(false);
+  const [_modalTitle, setModalTitle] = useState();
+  const [_modalSubtitle, setModalSubtitle] = useState();
+  const [_afterConnectUrl, setAfterConnectUrl] = useState();
+  const [_authenticating, setAuthenticating] = useState(false);
+  const [_connectFailureMessage, setConnectFailureMessage] = useState();
+  const [_modalState, setModalState] = useState("primary");
+  const [_enteredMultisigInfo, setEnteredMultisigInfo] = useState();
+  useAccountEffect({
+    async onConnect() {
+      var _a;
+      if (!firstConnectCheckRef.current) {
+        const multisigCookie = await ((_a = config.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)) {
+            setEnteredMultisigInfo(parsedMultisigSchema.data);
+          }
+        }
+        firstConnectCheckRef.current = true;
+      }
+    },
+    async onDisconnect() {
+      var _a;
+      await ((_a = config.storage) == null ? void 0 : _a.removeItem(`${AUTH_STORAGE_KEY}.store`));
+    }
+  });
+  const _connect = (connector) => {
+    setAuthenticating(true);
+    setConnectFailureMessage(void 0);
+    setEnteredMultisigInfo(void 0);
+    disconnect();
+    connect(
+      { connector },
+      {
+        onSuccess() {
+          setConnectModalOpen(false);
+          setModalTitle("Connect your wallet");
+          setModalSubtitle(void 0);
+          setModalState("primary");
+          if (_afterConnectUrl != null && typeof window !== "undefined") {
+            window.location.href = _afterConnectUrl;
+            setAfterConnectUrl(void 0);
+          }
+        },
+        onError(err) {
+          if (err.code === 4001) {
+            return;
+          }
+          console.error("GraphAuthKit.connect - failure connecting wallet", { err });
+          setConnectFailureMessage({ title: err.name, description: err.message });
+        },
+        onSettled() {
+          setAuthenticating(false);
+        }
+      }
+    );
+  };
+  const _connectMultisig = async (params) => {
+    var _a;
+    setAuthenticating(true);
+    setConnectFailureMessage(void 0);
+    disconnect();
+    const connectorChainId = await params.connector.getChainId();
+    if (connectorChainId !== params.network) {
+      void ((_a = config.storage) == null ? void 0 : _a.removeItem(MULTISIG_AUTH_STORAGE_KEY));
+      setConnectFailureMessage(MultisigErrorMap["INVALID_NETWORK"]);
+      setAuthenticating(false);
+      return;
+    }
+    connect(
+      { connector: params.connector },
+      {
+        async onSuccess(data) {
+          var _a2;
+          const [eoa] = data.accounts;
+          const client = buildPublicClient({
+            infuraKey,
+            chain: mapChainIdToChain(params.network)
+          });
+          const eoaIsSafeOwner = await isSafeOwner({
+            clientOrBuildClientArgs: client,
+            chain: params.network,
+            safeAddress: params.address,
+            eoa
+          });
+          if (!eoaIsSafeOwner) {
+            disconnect(
+              { connector: params.connector },
+              {
+                onSettled() {
+                  var _a3;
+                  void ((_a3 = config.storage) == null ? void 0 : _a3.removeItem(MULTISIG_AUTH_STORAGE_KEY));
+                  setConnectFailureMessage(MultisigErrorMap["INVALID_SIGNER"]);
+                  setAuthenticating(false);
+                }
+              }
+            );
+            return;
+          }
+          void ((_a2 = config.storage) == null ? void 0 : _a2.setItem(MULTISIG_AUTH_STORAGE_KEY, _enteredMultisigInfo));
+          setEnteredMultisigInfo({ address: params.address, network: params.network, enteredSafeIsValid: true });
+          setConnectModalOpen(false);
+          setModalTitle("Connect your wallet");
+          setModalSubtitle(void 0);
+          setModalState("primary");
+          if (_afterConnectUrl != null && typeof window !== "undefined") {
+            window.location.href = _afterConnectUrl;
+            setAfterConnectUrl(void 0);
+          }
+        },
+        onError(err) {
+          var _a2;
+          if (err.code === 4001) {
+            return;
+          }
+          void ((_a2 = config.storage) == null ? void 0 : _a2.removeItem(MULTISIG_AUTH_STORAGE_KEY));
+          setConnectFailureMessage({ title: err.name, description: err.message });
+        },
+        onSettled() {
+          setAuthenticating(false);
+        }
+      }
+    );
+  };
+  return /* @__PURE__ */ jsx(
+    GraphAuthKitInnerContext.Provider,
+    {
+      value: {
+        _infuraKey: infuraKey,
+        _gatewayApiKey: gatewayApiKey,
+        _safeApiKey: safeApiKey,
+        _ensResolver: buildEnsResolver({ infuraKey, gatewayApiKey }),
+        _connectModalOpen,
+        _setConnectModalOpen: setConnectModalOpen,
+        _modalTitle,
+        _setModalTitle: setModalTitle,
+        _modalSubtitle,
+        _setModalSubtitle: setModalSubtitle,
+        _setAfterConnectUrl: setAfterConnectUrl,
+        _modalState,
+        _setModalState(modalState) {
+          if (_modalState === "safe_eoa_signer" && modalState === "safe_entry") {
+            setConnectFailureMessage(void 0);
+          }
+          return setModalState(modalState);
+        },
+        _enteredMultisigInfo,
+        _setSafeInfo: setEnteredMultisigInfo,
+        _authenticating,
+        _setAuthenticating: setAuthenticating,
+        _connectFailureMessage,
+        _connect,
+        _connectMultisig,
+        _reset() {
+          var _a;
+          setAuthenticating(false);
+          setConnectFailureMessage(void 0);
+          setModalTitle("Connect your wallet");
+          setModalSubtitle(void 0);
+          setAfterConnectUrl(void 0);
+          setEnteredMultisigInfo(void 0);
+          setModalState("primary");
+          void ((_a = config.storage) == null ? void 0 : _a.removeItem(MULTISIG_AUTH_STORAGE_KEY));
+        }
+      },
+      children
+    }
+  );
+}
+export {
+  ApiKitUrlMap as A,
+  BuildPublicClientArgs as B,
+  isChainL2 as C,
+  DefChain as D,
+  isChainL1 as E,
+  isChainMainnet as F,
+  GraphAuthKitProps as G,
+  isChainTestnet as H,
+  clientToProvider as I,
+  connectedWalletIsEoA as J,
+  useGraphAuthKitInnerContext as K,
+  L1Chain as L,
+  MULTISIG_AUTH_STORAGE_KEY as M,
+  MultisigSchema as N,
+  OptionalGatewayApiKey as O,
+  GraphAuthKitInnerContextProvider as P,
+  GraphAuthKitInnerContext as Q,
+  RequiredInfuraKey as R,
+  SafeSupportedNetworks as S,
+  defInnerState as T,
+  SafeSupportedNetworkNames as a,
+  createSafe as b,
+  createApiKit as c,
+  isValidSafe as d,
+  isSafeOwner as e,
+  fetchOwnedSafes as f,
+  buildInfuraHttpTransport as g,
+  isBuildPublicClientArgs as h,
+  isSafeSupportedNetwork as i,
+  buildPublicClient as j,
+  BuildClientArgs as k,
+  buildClient as l,
+  AUTH_STORAGE_KEY as m,
+  L1ChainTestnet as n,
+  L2Chain as o,
+  L2ChainTestnet as p,
+  SupportedClientChainId as q,
+  SupportedClientChains as r,
+  SupportedL1ClientChainId as s,
+  SupportedL2ClientChainId as t,
+  RequiredWalletConnectProjectId as u,
+  OptionalSafeApiKey as v,
+  GraphAuthKitConnector as w,
+  chainIsSupportedChain as x,
+  isSupportedChainId as y,
+  mapChainIdToChain as z
+};