@edgeandnode/graph-auth-kit 6.2.0 → 6.2.2-events-link-1740076450695-36a01e7eaa09e01865e3eeea5508ce128b336a34

package/dist/{GraphAuthKitInner.context-DkY5ODsb.js → GraphAuthKitInner.context-B8vsvUDy.js}

@@ -1,11 +1,97 @@
 import { jsx } from "react/jsx-runtime";
 import { buildEnsResolver } from "@edgeandnode/ens";
 import { createContext, useContext, useRef, useState } from "react";
-import { isAddress } from "viem";
+import { http, createPublicClient, createClient, isAddress } from "viem";
 import { useConnect, useDisconnect, useAccountEffect } from "wagmi";
 import { z } from "zod";
-import { q as SupportedClientChainId, D as DefChain, o as L2Chain, p as L2ChainTestnet, n as L1ChainTestnet, L as L1Chain, m as AUTH_STORAGE_KEY, M as MULTISIG_AUTH_STORAGE_KEY, S as SafeSupportedNetworks, j as buildPublicClient, e as isSafeOwner } from "./utils-DP_AxKkW.js";
+import { l1Mainnet, l1Testnet, l2Mainnet, l2Testnet } from "@edgeandnode/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({ required_error: "The Infura Key is required" }).min(1).readonly()
+});
+const RequiredWalletConnectProjectId = z.object({
+  walletConnectProjectID: z.string({ required_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 GraphAuthKitProps = RequiredInfuraKey.merge(OptionalGatewayApiKey);
+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",
@@ -16,6 +102,193 @@ const MultisigErrorMap = {
     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://safe-transaction-mainnet.safe.global/api",
+  [L1ChainTestnet.id]: "https://safe-transaction-sepolia.safe.global/api",
+  [L2Chain.id]: "https://safe-transaction-arbitrum.safe.global/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) {
+  const { default: SafeApiKit } = await import("@safe-global/api-kit");
+  const SafeApiKitClass = typeof SafeApiKit === "function" ? SafeApiKit : SafeApiKit.default;
+  const apiKit = new SafeApiKitClass({
+    chainId: BigInt(chainId),
+    txServiceUrl: ApiKitUrlMap[chainId]
+  });
+  return apiKit;
+}
+async function createSafe(config) {
+  const { default: Safe2 } = await import("@safe-global/protocol-kit");
+  const SafeClass = typeof Safe2 === "function" ? Safe2 : Safe2.default;
+  const protocolKit = await SafeClass.init(config);
+  return protocolKit;
+}
+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;
 }
@@ -301,18 +574,49 @@ function GraphAuthKitInnerContextProvider({
   );
 }
 export {
-  GraphAuthKitInnerContextProvider as G,
-  MultisigSchema as M,
-  isChainL2 as a,
-  isChainL1 as b,
-  chainIsSupportedChain as c,
-  isChainMainnet as d,
-  isChainTestnet as e,
-  clientToProvider as f,
-  connectedWalletIsEoA as g,
-  GraphAuthKitInnerContext as h,
-  isSupportedChainId as i,
-  defInnerState as j,
-  mapChainIdToChain as m,
-  useGraphAuthKitInnerContext as u
+  ApiKitUrlMap as A,
+  BuildPublicClientArgs as B,
+  isChainL1 as C,
+  DefChain as D,
+  isChainMainnet as E,
+  isChainTestnet as F,
+  GraphAuthKitProps as G,
+  clientToProvider as H,
+  connectedWalletIsEoA as I,
+  useGraphAuthKitInnerContext as J,
+  MultisigSchema as K,
+  L1Chain as L,
+  MULTISIG_AUTH_STORAGE_KEY as M,
+  GraphAuthKitInnerContextProvider as N,
+  OptionalGatewayApiKey as O,
+  GraphAuthKitInnerContext as P,
+  defInnerState as Q,
+  RequiredInfuraKey as R,
+  SafeSupportedNetworks as S,
+  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,
+  GraphAuthKitConnector as v,
+  chainIsSupportedChain as w,
+  isSupportedChainId as x,
+  mapChainIdToChain as y,
+  isChainL2 as z
 };

package/dist/ens/index.js

@@ -1,4 +1,4 @@
-import { u, a, b, c } from "../useGraphAuthKitEnsNames-FYkTkbYz.js";
+import { u, a, b, c } from "../useGraphAuthKitEnsNames-BEajLdia.js";
 export {
   u as useGraphAuthKitAvatar,
   a as useGraphAuthKitAvatars,

package/dist/{useGraphAuthKitEnsNames-FYkTkbYz.js → hooks-ClXeFY-j.js}

@@ -1,17 +1,13 @@
-"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 { createIdenticon } from "@edgeandnode/gds";
-import { getEnsAvatarQueryKey, getEnsNameQueryKey } from "@wagmi/core/query";
-import { writeContractMutationOptions, useQuery } from "wagmi/query";
-import { b as createSafe, c as createApiKit, v as GraphAuthKitConnector, M as MULTISIG_AUTH_STORAGE_KEY, o as L2Chain, n as L1ChainTestnet, p as L2ChainTestnet, L as L1Chain } from "./utils-DP_AxKkW.js";
-import { f as clientToProvider, u as useGraphAuthKitInnerContext, M as MultisigSchema, i as isSupportedChainId } from "./GraphAuthKitInner.context-DkY5ODsb.js";
-import { useChainId, useConnectorClient, useAccount, useConfig, useAccountEffect, useWalletClient } from "wagmi";
 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, H as clientToProvider, J as useGraphAuthKitInnerContext, v as GraphAuthKitConnector, M as MULTISIG_AUTH_STORAGE_KEY, K as MultisigSchema } from "./GraphAuthKitInner.context-B8vsvUDy.js";
 import { VoidSigner } from "@ethersproject/abstract-signer";
 import "@safe-global/protocol-kit";
 import { OperationType } from "@safe-global/types-kit";
@@ -477,215 +473,13 @@ function useGraphAuthKitWriteContract(parameters = {}) {
     writeContractAsync: mutateAsync
   };
 }
-function useGraphAuthKitAvatar(args = {}) {
-  const innerCtx = useGraphAuthKitInnerContext();
-  const account = useGraphAuthKitAccount();
-  const address = args.address || account.address || void 0;
-  const chain = args.chain != null ? args.chain : account.chainId != null && isSupportedChainId(account.chainId) ? account.chainId : L2Chain.id;
-  return useQuery({
-    queryKey: getEnsAvatarQueryKey({
-      chainId: chain,
-      blockTag: "latest",
-      name: address
-    }),
-    async queryFn() {
-      if (address == null) {
-        return createIdenticon("0x0000000000000000000000000000000000000000");
-      }
-      const avatar = await innerCtx._ensResolver.resolveAvatar({
-        ...args,
-        address,
-        chain
-      });
-      return avatar || createIdenticon(address);
-    }
-  });
-}
-function useGraphAuthKitAvatars(args) {
-  const innerCtx = useGraphAuthKitInnerContext();
-  const account = useGraphAuthKitAccount();
-  const chain = args.chain != null ? args.chain : account.chainId != null && isSupportedChainId(account.chainId) ? account.chainId : L2Chain.id;
-  return useQuery({
-    queryKey: getAvatarsBatchQueryKey({
-      chainId: chain,
-      blockTag: "latest",
-      addresses: args.addresses
-    }),
-    async queryFn() {
-      if (args.addresses.length === 0) {
-        return {};
-      }
-      const map = await innerCtx._ensResolver.resolveAvatarsBatch({
-        ...args,
-        addresses: args.addresses,
-        chain
-      });
-      return Object.entries(map).reduce((accum, [addr, avatar]) => {
-        accum[addr] = avatar || createIdenticon(addr);
-        return accum;
-      }, map);
-    }
-  });
-}
-function filterQueryOptions$1(options) {
-  const {
-    // import('@tanstack/query-core').QueryOptions
-    _defaulted,
-    behavior,
-    gcTime,
-    initialData,
-    initialDataUpdatedAt,
-    maxPages,
-    meta,
-    networkMode,
-    queryFn,
-    queryHash,
-    queryKey,
-    queryKeyHashFn,
-    retry,
-    retryDelay,
-    structuralSharing,
-    // import('@tanstack/query-core').InfiniteQueryObserverOptions
-    getPreviousPageParam,
-    getNextPageParam,
-    initialPageParam,
-    // import('@tanstack/react-query').UseQueryOptions
-    _optimisticResults,
-    enabled,
-    notifyOnChangeProps,
-    placeholderData,
-    refetchInterval,
-    refetchIntervalInBackground,
-    refetchOnMount,
-    refetchOnReconnect,
-    refetchOnWindowFocus,
-    retryOnMount,
-    select,
-    staleTime,
-    suspense,
-    throwOnError,
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // wagmi
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    config,
-    connector,
-    query,
-    ...rest
-  } = options;
-  return rest;
-}
-function getAvatarsBatchQueryKey(options = { addresses: [] }) {
-  return ["ensAvatars", filterQueryOptions$1(options)];
-}
-function useGraphAuthKitEnsName(args = {}) {
-  const innerCtx = useGraphAuthKitInnerContext();
-  const chainId = useChainId();
-  const account = useGraphAuthKitAccount();
-  const address = args.address || account.address || void 0;
-  const testnet = args.testnet ?? (chainId === L1ChainTestnet.id || chainId === L2ChainTestnet.id);
-  return useQuery({
-    queryKey: getEnsNameQueryKey({
-      chainId: testnet ? L1ChainTestnet.id : L1Chain.id,
-      blockTag: "latest",
-      address
-    }),
-    async queryFn() {
-      if (address == null) {
-        return null;
-      }
-      return await innerCtx._ensResolver.resolveEnsName({
-        ...args,
-        address,
-        testnet
-      });
-    },
-    enabled: args.address != null
-  });
-}
-function useGraphAuthKitEnsNames(args) {
-  const innerCtx = useGraphAuthKitInnerContext();
-  const chainId = useChainId();
-  const testnet = args.testnet ?? (chainId === L1ChainTestnet.id || chainId === L2ChainTestnet.id);
-  return useQuery({
-    queryKey: getEnsNamesBatchQueryKey({
-      chainId: testnet ? L1ChainTestnet.id : L1Chain.id,
-      blockTag: "latest",
-      addresses: args.addresses
-    }),
-    async queryFn() {
-      if (args.addresses.length === 0) {
-        return {};
-      }
-      return await innerCtx._ensResolver.resolveEnsNamesBatch({
-        ...args,
-        addresses: args.addresses,
-        testnet
-      });
-    },
-    enabled: args.addresses.length > 0
-  });
-}
-function filterQueryOptions(options) {
-  const {
-    // import('@tanstack/query-core').QueryOptions
-    _defaulted,
-    behavior,
-    gcTime,
-    initialData,
-    initialDataUpdatedAt,
-    maxPages,
-    meta,
-    networkMode,
-    queryFn,
-    queryHash,
-    queryKey,
-    queryKeyHashFn,
-    retry,
-    retryDelay,
-    structuralSharing,
-    // import('@tanstack/query-core').InfiniteQueryObserverOptions
-    getPreviousPageParam,
-    getNextPageParam,
-    initialPageParam,
-    // import('@tanstack/react-query').UseQueryOptions
-    _optimisticResults,
-    enabled,
-    notifyOnChangeProps,
-    placeholderData,
-    refetchInterval,
-    refetchIntervalInBackground,
-    refetchOnMount,
-    refetchOnReconnect,
-    refetchOnWindowFocus,
-    retryOnMount,
-    select,
-    staleTime,
-    suspense,
-    throwOnError,
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // wagmi
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    config,
-    connector,
-    query,
-    ...rest
-  } = options;
-  return rest;
-}
-function getEnsNamesBatchQueryKey(options = { addresses: [] }) {
-  return ["ensName", filterQueryOptions(options)];
-}
 export {
-  useGraphAuthKitAvatars as a,
-  useGraphAuthKitEnsName as b,
-  useGraphAuthKitEnsNames as c,
-  useGraphAuthKitAccount as d,
-  useGraphAuthKitConnector as e,
-  useClientToEthersSigner as f,
-  useAuthAccount as g,
-  useMultisigInfo as h,
-  useGraphAuthKitAccountEffect as i,
-  useGraphAuthKitWalletClient as j,
-  useGraphAuthKitWriteContract as k,
-  useGraphAuthKitAvatar as u
+  useGraphAuthKitAccount as a,
+  useGraphAuthKitConnector as b,
+  useClientToEthersSigner as c,
+  useAuthAccount as d,
+  useGraphAuthKitAccountEffect as e,
+  useGraphAuthKitWalletClient as f,
+  useGraphAuthKitWriteContract as g,
+  useMultisigInfo as u
 };

package/dist/index.js

@@ -1,12 +1,13 @@
 "use client";
-import { m, A, k, B, D, v, G, L, n, o, p, M, O, R, u, a, S, q, r, s, t, l, g, j, c, b, f, h, e, i, d } from "./utils-DP_AxKkW.js";
-import { G as G2, a as a2, M as M2, b as b2, d as d2, u as u2 } from "./utils-C_72bAxT.js";
-import { d as useGraphAuthKitAccount, e as useGraphAuthKitConnector } from "./useGraphAuthKitEnsNames-FYkTkbYz.js";
-import { g as g2, f as f2, i as i2, u as u3, a as a3, b as b3, c as c2, j as j2, k as k2, h as h2 } from "./useGraphAuthKitEnsNames-FYkTkbYz.js";
-import { c as c3, f as f3, g as g3, b as b4, a as a4, d as d3, e as e2, i as i3, m as m2 } from "./GraphAuthKitInner.context-DkY5ODsb.js";
+import { m, A, k, B, D, v, G, L, n, o, p, M, O, R, u, a, S, q, r, s, t, l, g, j, w, H, I, c, b, f, h, C, z, E, F, e, i, x, d, y } from "./GraphAuthKitInner.context-B8vsvUDy.js";
+import { G as G2, a as a2, M as M2, b as b2, d as d2, u as u2 } from "./utils-DuHz-YHi.js";
+import { a as useGraphAuthKitAccount, b as useGraphAuthKitConnector } from "./hooks-ClXeFY-j.js";
+import { d as d3, c as c2, e as e2, f as f2, g as g2, u as u3 } from "./hooks-ClXeFY-j.js";
+import { g as g3, u as u4, w as w2 } from "./useWaitForSafeTransaction-D4k3ZLSB.js";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Alert, ExperimentalButton } from "@edgeandnode/gds";
 import { useConfig, useSwitchChain } from "wagmi";
+import { u as u5, a as a3, b as b3, c as c3 } from "./useGraphAuthKitEnsNames-BEajLdia.js";
 function Connected({ children }) {
   const account = useGraphAuthKitAccount();
   const connector = useGraphAuthKitConnector();
@@ -101,34 +102,37 @@ export {
   g as buildInfuraHttpTransport,
   b2 as buildMockProviderState,
   j as buildPublicClient,
-  c3 as chainIsSupportedChain,
-  f3 as clientToProvider,
-  g3 as connectedWalletIsEoA,
+  w as chainIsSupportedChain,
+  H as clientToProvider,
+  I as connectedWalletIsEoA,
   c as createApiKit,
   b as createSafe,
   d2 as disconnectedMockState,
   f as fetchOwnedSafes,
+  g3 as getSafeTransaction,
   h as isBuildPublicClientArgs,
-  b4 as isChainL1,
-  a4 as isChainL2,
-  d3 as isChainMainnet,
-  e2 as isChainTestnet,
+  C as isChainL1,
+  z as isChainL2,
+  E as isChainMainnet,
+  F as isChainTestnet,
   e as isSafeOwner,
   i as isSafeSupportedNetwork,
-  i3 as isSupportedChainId,
+  x as isSupportedChainId,
   d as isValidSafe,
-  m2 as mapChainIdToChain,
-  g2 as useAuthAccount,
-  f2 as useClientToEthersSigner,
+  y as mapChainIdToChain,
+  d3 as useAuthAccount,
+  c2 as useClientToEthersSigner,
   u2 as useGraphAuthKit,
   useGraphAuthKitAccount,
-  i2 as useGraphAuthKitAccountEffect,
-  u3 as useGraphAuthKitAvatar,
+  e2 as useGraphAuthKitAccountEffect,
+  u5 as useGraphAuthKitAvatar,
   a3 as useGraphAuthKitAvatars,
   useGraphAuthKitConnector,
   b3 as useGraphAuthKitEnsName,
-  c2 as useGraphAuthKitEnsNames,
-  j2 as useGraphAuthKitWalletClient,
-  k2 as useGraphAuthKitWriteContract,
-  h2 as useMultisigInfo
+  c3 as useGraphAuthKitEnsNames,
+  f2 as useGraphAuthKitWalletClient,
+  g2 as useGraphAuthKitWriteContract,
+  u3 as useMultisigInfo,
+  u4 as useWaitForSafeTransaction,
+  w2 as waitForSafeTransation
 };

package/dist/safe/index.d.ts

@@ -1,3 +1,4 @@
 export * from './constants';
+export * from './useWaitForSafeTransaction';
 export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/safe/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/safe/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/safe/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,SAAS,CAAA"}

package/dist/safe/index.js

@@ -1,4 +1,5 @@
-import { A, a, S, c, b, f, e, i, d } from "../utils-DP_AxKkW.js";
+import { A, a, S, c, b, f, e, i, d } from "../GraphAuthKitInner.context-B8vsvUDy.js";
+import { g, u, w } from "../useWaitForSafeTransaction-D4k3ZLSB.js";
 export {
   A as ApiKitUrlMap,
   a as SafeSupportedNetworkNames,
@@ -6,7 +7,10 @@ export {
   c as createApiKit,
   b as createSafe,
   f as fetchOwnedSafes,
+  g as getSafeTransaction,
   e as isSafeOwner,
   i as isSafeSupportedNetwork,
-  d as isValidSafe
+  d as isValidSafe,
+  u as useWaitForSafeTransaction,
+  w as waitForSafeTransation
 };

package/dist/safe/useWaitForSafeTransaction.d.ts

@@ -0,0 +1,9 @@
+import { SafeMultisigTransactionResponse } from '@safe-global/types-kit';
+import { Config, ResolvedRegister } from 'wagmi';
+import { SafeSupportedNetworks } from './constants';
+export declare function getSafeTransaction(safeTxHash: string, network: SafeSupportedNetworks): Promise<SafeMultisigTransactionResponse>;
+export declare function waitForSafeTransation(safeTxHash: string, network: SafeSupportedNetworks, pollingInterval?: number): Promise<SafeMultisigTransactionResponse>;
+export declare function useWaitForSafeTransaction<const config extends Config = ResolvedRegister['config']>({ safeTxHash, }: {
+    safeTxHash: string | undefined;
+}): import('@tanstack/react-query').UseQueryResult<SafeMultisigTransactionResponse | undefined, Error>;
+//# sourceMappingURL=useWaitForSafeTransaction.d.ts.map

package/dist/safe/useWaitForSafeTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWaitForSafeTransaction.d.ts","sourceRoot":"","sources":["../../src/safe/useWaitForSafeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAA;AAE7E,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,gBAAgB,EAAa,MAAM,OAAO,CAAA;AAIrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAGnD,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,4CAI1F;AAED,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,qBAAqB,EAC9B,eAAe,GAAE,MAAc,4CAWhC;AAED,wBAAgB,yBAAyB,CAAC,KAAK,CAAC,MAAM,SAAS,MAAM,GAAG,gBAAgB,CAAC,QAAQ,CAAC,EAAE,EAClG,UAAU,GACX,EAAE;IACD,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,sGAiBA"}

package/dist/test-harness/index.js

@@ -1,4 +1,4 @@
-import { M, b, d } from "../utils-C_72bAxT.js";
+import { M, b, d } from "../utils-DuHz-YHi.js";
 export {
   M as MockGraphAuthKitProvider,
   b as buildMockProviderState,

package/dist/useGraphAuthKitEnsNames-BEajLdia.js

@@ -0,0 +1,211 @@
+"use client";
+import { createIdenticon } from "@edgeandnode/gds";
+import { getEnsAvatarQueryKey, getEnsNameQueryKey } from "@wagmi/core/query";
+import { useQuery } from "wagmi/query";
+import { J as useGraphAuthKitInnerContext, x as isSupportedChainId, o as L2Chain, n as L1ChainTestnet, p as L2ChainTestnet, L as L1Chain } from "./GraphAuthKitInner.context-B8vsvUDy.js";
+import { a as useGraphAuthKitAccount } from "./hooks-ClXeFY-j.js";
+import { useChainId } from "wagmi";
+function useGraphAuthKitAvatar(args = {}) {
+  const innerCtx = useGraphAuthKitInnerContext();
+  const account = useGraphAuthKitAccount();
+  const address = args.address || account.address || void 0;
+  const chain = args.chain != null ? args.chain : account.chainId != null && isSupportedChainId(account.chainId) ? account.chainId : L2Chain.id;
+  return useQuery({
+    queryKey: getEnsAvatarQueryKey({
+      chainId: chain,
+      blockTag: "latest",
+      name: address
+    }),
+    async queryFn() {
+      if (address == null) {
+        return createIdenticon("0x0000000000000000000000000000000000000000");
+      }
+      const avatar = await innerCtx._ensResolver.resolveAvatar({
+        ...args,
+        address,
+        chain
+      });
+      return avatar || createIdenticon(address);
+    }
+  });
+}
+function useGraphAuthKitAvatars(args) {
+  const innerCtx = useGraphAuthKitInnerContext();
+  const account = useGraphAuthKitAccount();
+  const chain = args.chain != null ? args.chain : account.chainId != null && isSupportedChainId(account.chainId) ? account.chainId : L2Chain.id;
+  return useQuery({
+    queryKey: getAvatarsBatchQueryKey({
+      chainId: chain,
+      blockTag: "latest",
+      addresses: args.addresses
+    }),
+    async queryFn() {
+      if (args.addresses.length === 0) {
+        return {};
+      }
+      const map = await innerCtx._ensResolver.resolveAvatarsBatch({
+        ...args,
+        addresses: args.addresses,
+        chain
+      });
+      return Object.entries(map).reduce((accum, [addr, avatar]) => {
+        accum[addr] = avatar || createIdenticon(addr);
+        return accum;
+      }, map);
+    }
+  });
+}
+function filterQueryOptions$1(options) {
+  const {
+    // import('@tanstack/query-core').QueryOptions
+    _defaulted,
+    behavior,
+    gcTime,
+    initialData,
+    initialDataUpdatedAt,
+    maxPages,
+    meta,
+    networkMode,
+    queryFn,
+    queryHash,
+    queryKey,
+    queryKeyHashFn,
+    retry,
+    retryDelay,
+    structuralSharing,
+    // import('@tanstack/query-core').InfiniteQueryObserverOptions
+    getPreviousPageParam,
+    getNextPageParam,
+    initialPageParam,
+    // import('@tanstack/react-query').UseQueryOptions
+    _optimisticResults,
+    enabled,
+    notifyOnChangeProps,
+    placeholderData,
+    refetchInterval,
+    refetchIntervalInBackground,
+    refetchOnMount,
+    refetchOnReconnect,
+    refetchOnWindowFocus,
+    retryOnMount,
+    select,
+    staleTime,
+    suspense,
+    throwOnError,
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // wagmi
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    config,
+    connector,
+    query,
+    ...rest
+  } = options;
+  return rest;
+}
+function getAvatarsBatchQueryKey(options = { addresses: [] }) {
+  return ["ensAvatars", filterQueryOptions$1(options)];
+}
+function useGraphAuthKitEnsName(args = {}) {
+  const innerCtx = useGraphAuthKitInnerContext();
+  const chainId = useChainId();
+  const account = useGraphAuthKitAccount();
+  const address = args.address || account.address || void 0;
+  const testnet = args.testnet ?? (chainId === L1ChainTestnet.id || chainId === L2ChainTestnet.id);
+  return useQuery({
+    queryKey: getEnsNameQueryKey({
+      chainId: testnet ? L1ChainTestnet.id : L1Chain.id,
+      blockTag: "latest",
+      address
+    }),
+    async queryFn() {
+      if (address == null) {
+        return null;
+      }
+      return await innerCtx._ensResolver.resolveEnsName({
+        ...args,
+        address,
+        testnet
+      });
+    },
+    enabled: args.address != null
+  });
+}
+function useGraphAuthKitEnsNames(args) {
+  const innerCtx = useGraphAuthKitInnerContext();
+  const chainId = useChainId();
+  const testnet = args.testnet ?? (chainId === L1ChainTestnet.id || chainId === L2ChainTestnet.id);
+  return useQuery({
+    queryKey: getEnsNamesBatchQueryKey({
+      chainId: testnet ? L1ChainTestnet.id : L1Chain.id,
+      blockTag: "latest",
+      addresses: args.addresses
+    }),
+    async queryFn() {
+      if (args.addresses.length === 0) {
+        return {};
+      }
+      return await innerCtx._ensResolver.resolveEnsNamesBatch({
+        ...args,
+        addresses: args.addresses,
+        testnet
+      });
+    },
+    enabled: args.addresses.length > 0
+  });
+}
+function filterQueryOptions(options) {
+  const {
+    // import('@tanstack/query-core').QueryOptions
+    _defaulted,
+    behavior,
+    gcTime,
+    initialData,
+    initialDataUpdatedAt,
+    maxPages,
+    meta,
+    networkMode,
+    queryFn,
+    queryHash,
+    queryKey,
+    queryKeyHashFn,
+    retry,
+    retryDelay,
+    structuralSharing,
+    // import('@tanstack/query-core').InfiniteQueryObserverOptions
+    getPreviousPageParam,
+    getNextPageParam,
+    initialPageParam,
+    // import('@tanstack/react-query').UseQueryOptions
+    _optimisticResults,
+    enabled,
+    notifyOnChangeProps,
+    placeholderData,
+    refetchInterval,
+    refetchIntervalInBackground,
+    refetchOnMount,
+    refetchOnReconnect,
+    refetchOnWindowFocus,
+    retryOnMount,
+    select,
+    staleTime,
+    suspense,
+    throwOnError,
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // wagmi
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    config,
+    connector,
+    query,
+    ...rest
+  } = options;
+  return rest;
+}
+function getEnsNamesBatchQueryKey(options = { addresses: [] }) {
+  return ["ensName", filterQueryOptions(options)];
+}
+export {
+  useGraphAuthKitAvatars as a,
+  useGraphAuthKitEnsName as b,
+  useGraphAuthKitEnsNames as c,
+  useGraphAuthKitAvatar as u
+};

package/dist/useWaitForSafeTransaction-D4k3ZLSB.js

@@ -0,0 +1,44 @@
+import { useQuery } from "@tanstack/react-query";
+import { useConfig } from "wagmi";
+import { u as useMultisigInfo } from "./hooks-ClXeFY-j.js";
+import { c as createApiKit } from "./GraphAuthKitInner.context-B8vsvUDy.js";
+async function getSafeTransaction(safeTxHash, network) {
+  const apiKit = await createApiKit(network);
+  const txDetails = await apiKit.getTransaction(safeTxHash);
+  return txDetails;
+}
+async function waitForSafeTransation(safeTxHash, network, pollingInterval = 4e3) {
+  return new Promise((resolve) => {
+    const poll = async () => {
+      const txDetails = await getSafeTransaction(safeTxHash, network);
+      if (txDetails.transactionHash) {
+        resolve(txDetails);
+      } else setTimeout(poll, pollingInterval);
+    };
+    void poll();
+  });
+}
+function useWaitForSafeTransaction({
+  safeTxHash
+}) {
+  const config = useConfig();
+  const _enteredMultisigInfo = useMultisigInfo();
+  return useQuery({
+    queryKey: ["SafeMultisigTransactionResponse", safeTxHash],
+    queryFn: async () => {
+      if (!_enteredMultisigInfo || !safeTxHash) return;
+      const txDetails = await waitForSafeTransation(
+        safeTxHash,
+        _enteredMultisigInfo.network,
+        config.getClient().pollingInterval
+      );
+      return txDetails;
+    },
+    enabled: _enteredMultisigInfo != null && safeTxHash != null
+  });
+}
+export {
+  getSafeTransaction as g,
+  useWaitForSafeTransaction as u,
+  waitForSafeTransation as w
+};

package/dist/{utils-C_72bAxT.js → utils-DuHz-YHi.js}

@@ -3,10 +3,9 @@ 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 { v 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 L2ChainTestnet, m as AUTH_STORAGE_KEY, D as DefChain, l as buildClient, R as RequiredInfuraKey, O as OptionalGatewayApiKey, q as SupportedClientChainId } from "./utils-DP_AxKkW.js";
+import { J as useGraphAuthKitInnerContext, v as GraphAuthKitConnector, o as L2Chain, a as SafeSupportedNetworkNames, j as buildPublicClient, L as L1Chain, n as L1ChainTestnet, d as isValidSafe, S as SafeSupportedNetworks, N as GraphAuthKitInnerContextProvider, p as L2ChainTestnet, m as AUTH_STORAGE_KEY, w as chainIsSupportedChain, D as DefChain, l as buildClient, P as GraphAuthKitInnerContext, Q as defInnerState, R as RequiredInfuraKey, O as OptionalGatewayApiKey, q as SupportedClientChainId } from "./GraphAuthKitInner.context-B8vsvUDy.js";
 import { useState, useReducer, useId, useEffect, createContext, useContext } from "react";
 import { Icon, ExperimentalModal, ExperimentalButton, Alert, Link, ExperimentalLoadingIndicator, ExperimentalSelect, ExperimentalInput, Divider, List } from "@edgeandnode/gds";
-import { u as useGraphAuthKitInnerContext, G as GraphAuthKitInnerContextProvider, c as chainIsSupportedChain, h as GraphAuthKitInnerContext, j as defInnerState } from "./GraphAuthKitInner.context-DkY5ODsb.js";
 import { addrShortener } from "@edgeandnode/common";
 import { isAddress } from "viem";
 import { NetworkIcon } from "@edgeandnode/go";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@edgeandnode/graph-auth-kit",
   "private": false,
-  "version": "6.2.0",
+  "version": "6.2.2-events-link-1740076450695-36a01e7eaa09e01865e3eeea5508ce128b336a34",
   "description": "Wallet authentication connect kit in The Graph suite of applications",
   "author": "Edge & Node",
   "license": "UNLICENSED",
@@ -56,8 +56,8 @@
     "wagmi": "^2.12",
     "@edgeandnode/common": "^7.0.1",
     "@edgeandnode/ens": "^2.1.0",
-    "@edgeandnode/gds": "^6.4.0",
-    "@edgeandnode/go": "^9.2.0"
+    "@edgeandnode/gds": "^6.4.1-events-link-1740076450695-36a01e7eaa09e01865e3eeea5508ce128b336a34",
+    "@edgeandnode/go": "^9.2.1-events-link-1740076450695-36a01e7eaa09e01865e3eeea5508ce128b336a34"
   },
   "devDependencies": {
     "@emotion/react": "^11.14",
@@ -76,8 +76,8 @@
     "wagmi": "^2.14.11",
     "@edgeandnode/common": "^7.0.1",
     "@edgeandnode/ens": "^2.1.0",
-    "@edgeandnode/gds": "^6.4.0",
-    "@edgeandnode/go": "^9.2.0",
+    "@edgeandnode/gds": "^6.4.1-events-link-1740076450695-36a01e7eaa09e01865e3eeea5508ce128b336a34",
+    "@edgeandnode/go": "^9.2.1-events-link-1740076450695-36a01e7eaa09e01865e3eeea5508ce128b336a34",
     "@edgeandnode/jsx": "^1.1.0",
     "@edgeandnode/test-utils": "^2.1.0"
   },

package/dist/utils-DP_AxKkW.js

@@ -1,309 +0,0 @@
-import "@safe-global/protocol-kit";
-import { http, createPublicClient, createClient, isAddress } from "viem";
-import { z } from "zod";
-import { l1Mainnet, l1Testnet, l2Mainnet, l2Testnet } from "@edgeandnode/common";
-import { mainnet, sepolia, arbitrum, arbitrumSepolia } from "viem/chains";
-import { injected, coinbaseWallet, walletConnect } from "wagmi/connectors";
-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({ required_error: "The Infura Key is required" }).min(1).readonly()
-});
-const RequiredWalletConnectProjectId = z.object({
-  walletConnectProjectID: z.string({ required_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 GraphAuthKitProps = RequiredInfuraKey.merge(OptionalGatewayApiKey);
-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 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://safe-transaction-mainnet.safe.global/api",
-  [L1ChainTestnet.id]: "https://safe-transaction-sepolia.safe.global/api",
-  [L2Chain.id]: "https://safe-transaction-arbitrum.safe.global/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) {
-  const { default: SafeApiKit } = await import("@safe-global/api-kit");
-  const SafeApiKitClass = typeof SafeApiKit === "function" ? SafeApiKit : SafeApiKit.default;
-  const apiKit = new SafeApiKitClass({
-    chainId: BigInt(chainId),
-    txServiceUrl: ApiKitUrlMap[chainId]
-  });
-  return apiKit;
-}
-async function createSafe(config) {
-  const { default: Safe2 } = await import("@safe-global/protocol-kit");
-  const SafeClass = typeof Safe2 === "function" ? Safe2 : Safe2.default;
-  const protocolKit = await SafeClass.init(config);
-  return protocolKit;
-}
-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;
-}
-export {
-  ApiKitUrlMap as A,
-  BuildPublicClientArgs as B,
-  DefChain as D,
-  GraphAuthKitProps as G,
-  L1Chain as L,
-  MULTISIG_AUTH_STORAGE_KEY as M,
-  OptionalGatewayApiKey as O,
-  RequiredInfuraKey as R,
-  SafeSupportedNetworks as S,
-  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,
-  GraphAuthKitConnector as v
-};