@edgeandnode/graph-auth-kit 0.2.0

package/dist/test-harness/MockGraphAuthKit.context.d.ts

@@ -0,0 +1,102 @@
+import { type ReactNode } from 'react';
+import { type Chain } from 'viem';
+import { type State } from 'wagmi';
+import { type MockParameters } from 'wagmi/connectors';
+import { type GraphAuthKitInnerState } from '../GraphAuthKitInner.context';
+export type MockGraphAuthKitProviderProps<chains extends readonly [Chain, ...Chain[]] = readonly [Chain, ...Chain[]]> = {
+    infuraKey: string;
+    /**
+     * Provide an initial state to pass to the `WagmiConfig` that establishes if we have a connected (authenticated) user
+     * If a string, use the `cookieToInitialState` util to derive
+     * @see https://wagmi.sh/core/api/createConfig#state-1
+     */
+    initialState?: State<chains> | string;
+    /**
+     * Parameters that are passed to the `mock` connector constructor for building the mock connector.
+     * Includes:
+     * - accounts -> addresses to establish as connected for the user
+     *
+     * @see https://wagmi.sh/react/api/connectors/mock#parameters
+     */
+    mockConnectorParams: MockParameters;
+    /**
+     * Provide the default value for the inner context.
+     * Allows the mock to set the conntected state up with a safe, etc.
+     *
+     * @default {
+     * _infuraKey: '',
+     * _connectModalOpen: false,
+     * _setConnectModalOpen() {},
+     * _modalTitle: 'Connect your wallet',
+     * _setModalTitle() {},
+     * _setModalSubtitle() {},
+     * _modalState: 'primary',
+     * _setModalState() {},
+     * _setSafeInfo() {},
+     * _authenticating: false,
+     * _setAuthenticating() {},
+     * _connect() {},
+     * _connectMultisig() {},
+     * _reset() {},
+     * }
+     */
+    innerCtxState?: GraphAuthKitInnerState;
+    children: ReactNode;
+};
+/**
+ * Exposed mock `<GraphAuthKitProvider>` instance for testing components and hooks exposed
+ * by this library and wagmi.
+ *
+ * Allows for passing in addresses and information to establish an authenticated/connected `WagmiProvider` instance.
+ *
+ * @example <caption>User is not authenticated</caption>
+ * ```tsx
+ * import { MockGraphAuthKitProvider } from '@edgeandnode/graph-auth-kit/test-harness'
+ *
+ * <MockGraphAuthKitProvider infuraKey="abc123" mockConnectorParams={{ accounts: ['0x'] }}>
+ *  <RendersAccount />
+ * </MockGraphAuthKitProvider>
+ * ```
+ *
+ * @example <caption>User is authenticated</caption>
+ * ```tsx
+ * import { MockGraphAuthKitProvider } from '@edgeandnode/graph-auth-kit/test-harness'
+ *
+ * <MockGraphAuthKitProvider
+ *  infuraKey="abc123"
+ *  mockConnectorParams={{ accounts: ['0x8c1b521970fDAB85d71260E08ee1dA5Dd878c60D'] }}
+ *  initialState={{
+ *    chainId: 42161,
+ *    status: 'connected',
+ *    current: null,
+ *    connections: new Map<string, Connection>()
+ *  }}
+ *  innerCtxState={{...default, _connector: 'injected'}}
+ * >
+ *  <RendersAccount />
+ * </MockGraphAuthKitProvider>
+ * ```
+ *
+ * @example <caption>User is authenticated with a Safe</caption>
+ * ```tsx
+ * import { MockGraphAuthKitProvider } from '@edgeandnode/graph-auth-kit/test-harness'
+ *
+ * <MockGraphAuthKitProvider
+ *  infuraKey="abc123"
+ *  mockConnectorParams={{ accounts: ['0x8c1b521970fDAB85d71260E08ee1dA5Dd878c60D'] }}
+ *  initialState={{
+ *    chainId: 42161,
+ *    status: 'connected',
+ *    current: null,
+ *    connections: new Map<string, Connection>()
+ *  }}
+ *  innerCtxState={{...default, _connector: 'multisig', _enteredMultisigInfo: {address: '0x8c1b521970fDAB85d71260E08ee1dA5Dd878c60D',network:42161} }}
+ * >
+ *  <RendersAccount />
+ * </MockGraphAuthKitProvider>
+ * ```
+ *
+ * @param props used to initialize the wagmi and inner context state
+ */
+export declare function MockGraphAuthKitProvider(props: MockGraphAuthKitProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=MockGraphAuthKit.context.d.ts.map

package/dist/test-harness/MockGraphAuthKit.context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockGraphAuthKit.context.d.ts","sourceRoot":"","sources":["../../src/test-harness/MockGraphAuthKit.context.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,MAAM,CAAA;AACjC,OAAO,EAKL,KAAK,KAAK,EAGX,MAAM,OAAO,CAAA;AACd,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAK5D,OAAO,EAGL,KAAK,sBAAsB,EAE5B,MAAM,8BAA8B,CAAA;AAGrC,MAAM,MAAM,6BAA6B,CAAC,MAAM,SAAS,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,EAAE,CAAC,IAClH;IACE,SAAS,EAAE,MAAM,CAAA;IAEjB;;;;OAIG;IACH,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IACrC;;;;;;OAMG;IACH,mBAAmB,EAAE,cAAc,CAAA;IAEnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,CAAC,EAAE,sBAAsB,CAAA;IAEtC,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,6BAA6B,+BAsC5E"}

package/dist/test-harness/index.d.ts

@@ -0,0 +1,2 @@
+export * from './MockGraphAuthKit.context';
+//# sourceMappingURL=index.d.ts.map

package/dist/test-harness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-harness/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA"}

package/dist/test-harness/index.js

@@ -0,0 +1,63 @@
+import { jsx } from "@theme-ui/core/jsx-runtime";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createConfig, createStorage, cookieStorage, cookieToInitialState, WagmiProvider, useDisconnect } from "wagmi";
+import { mock } from "wagmi/connectors";
+import { c as chainIsSupportedChain, b as buildClient, G as GraphAuthKitInnerContext, d as defInnerState, u as useGraphAuthKitInnerContext, a as GraphAuthKitContext } from "../GraphAuthKit.context-DBwb2jco.js";
+import { L as L2Chain, e as L2ChainTestnet, g as L1Chain, h as L1ChainTestnet, D as DefChain, j as AUTH_STORAGE_KEY } from "../utils-KuRu9vB-.js";
+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._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);
+          innerContext._reset();
+        },
+        disconnect() {
+          disconnect(
+            {},
+            {
+              onSettled() {
+                innerContext._reset();
+              }
+            }
+          );
+        }
+      },
+      children
+    }
+  );
+}
+export {
+  MockGraphAuthKitProvider
+};

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+export declare const RequiredInfuraKey: z.ZodObject<{
+    infuraKey: z.ZodReadonly<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    infuraKey: string;
+}, {
+    infuraKey: string;
+}>;
+export type RequiredInfuraKey = z.infer<typeof RequiredInfuraKey>;
+export declare const RequiredWalletConnectProjectId: z.ZodObject<{
+    walletConnectProjectID: z.ZodReadonly<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    walletConnectProjectID: string;
+}, {
+    walletConnectProjectID: string;
+}>;
+export type RequiredWalletConnectProjectId = z.infer<typeof RequiredWalletConnectProjectId>;
+export declare const GraphAuthKitProps: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    infuraKey: z.ZodReadonly<z.ZodString>;
+}, {
+    walletConnectProjectID: z.ZodReadonly<z.ZodString>;
+}>, {
+    meta: z.ZodReadonly<z.ZodObject<{
+        name: z.ZodReadonly<z.ZodUnion<readonly [z.ZodLiteral<"Graph Explorer">, z.ZodLiteral<"Subgraph Studio">]>>;
+        url: z.ZodReadonly<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    }, "strip", z.ZodTypeAny, {
+        name: "Graph Explorer" | "Subgraph Studio";
+        url?: string | null | undefined;
+    }, {
+        name: "Graph Explorer" | "Subgraph Studio";
+        url?: string | null | undefined;
+    }>>;
+    chains: z.ZodReadonly<z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodLiteral<"MAINNET">, z.ZodLiteral<"TESTNET">]>>>;
+}>, "strip", z.ZodTypeAny, {
+    infuraKey: string;
+    walletConnectProjectID: string;
+    meta: Readonly<{
+        name: "Graph Explorer" | "Subgraph Studio";
+        url?: string | null | undefined;
+    }>;
+    chains: "ALL" | "MAINNET" | "TESTNET";
+}, {
+    infuraKey: string;
+    walletConnectProjectID: string;
+    meta: Readonly<{
+        name: "Graph Explorer" | "Subgraph Studio";
+        url?: string | null | undefined;
+    }>;
+    chains?: "ALL" | "MAINNET" | "TESTNET" | undefined;
+}>;
+export type GraphAuthKitProps = z.infer<typeof GraphAuthKitProps>;
+export declare const GraphAuthKitConnector: z.ZodReadonly<z.ZodUnion<readonly [z.ZodLiteral<"coinbaseWallet">, z.ZodLiteral<"injected">, z.ZodLiteral<"multisig">, z.ZodLiteral<"walletConnect">]>>;
+export type GraphAuthKitConnector = z.infer<typeof GraphAuthKitConnector>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB;;;;;;EAE5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,eAAO,MAAM,8BAA8B;;;;;;EAEzC,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,eAAO,MAAM,qBAAqB,yJAOrB,CAAA;AACb,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/utils-KuRu9vB-.js

@@ -0,0 +1,218 @@
+import { isAddress } from "viem";
+import { z } from "zod";
+import { mainnet, sepolia, arbitrum, arbitrumSepolia } from "viem/chains";
+const AUTH_STORAGE_KEY = "thegraph__authstate";
+const MULTISIG_AUTH_STORAGE_KEY = "multisig";
+const L1Chain = mainnet;
+const L1ChainTestnet = sepolia;
+const L2Chain = arbitrum;
+const L2ChainTestnet = arbitrumSepolia;
+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 SafeSupportedNetworks = z.union([z.literal(L1Chain.id), z.literal(L1ChainTestnet.id), z.literal(L2Chain.id)]).readonly();
+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: Safe } = await import("@safe-global/protocol-kit");
+  const SafeClass = typeof Safe === "function" ? Safe : Safe.default;
+  const protocolKit = await SafeClass.init(config);
+  return protocolKit;
+}
+async function isValidSafe(args) {
+  try {
+    await args.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 {
+    return await args.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,
+  DefChain as D,
+  L2Chain as L,
+  MULTISIG_AUTH_STORAGE_KEY as M,
+  SafeSupportedNetworks as S,
+  SafeSupportedNetworkNames as a,
+  createSafe as b,
+  createApiKit as c,
+  isSafeOwner as d,
+  L2ChainTestnet as e,
+  fetchOwnedSafes as f,
+  L1Chain as g,
+  L1ChainTestnet as h,
+  isValidSafe as i,
+  AUTH_STORAGE_KEY as j,
+  SupportedClientChainId as k,
+  SupportedClientChains as l
+};

package/dist/utils.d.ts

@@ -0,0 +1,18 @@
+import { providers } from 'ethers';
+import type { Account, Address, Chain, Client, Transport } from 'viem';
+import { type PublicClient } from './client';
+import { type SupportedClientChains } from './constants';
+export declare function chainIsSupportedChain(chain: Chain): chain is SupportedClientChains;
+export declare function isChainL2(chain: number): boolean;
+export declare function isChainL1(chain: number): boolean;
+export declare function isChainMainnet(chain: number): boolean;
+export declare function isChainTestnet(chain: number): boolean;
+export declare function clientToProvider(client: Client<Transport, Chain, Account>): providers.Web3Provider;
+/**
+ * Test whether the given wallet is a multisig or EoA
+ * @param client connected public client instance
+ * @param address the connected wallet to test
+ * @returns true if the connected wallet is an EoA, false if it is a multisig contract
+ */
+export declare function connectedWalletIsEoA(client: PublicClient, address: Address): Promise<boolean>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,MAAM,CAAA;AAEtE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAA;AAEpB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,qBAAqB,CAElF;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhD;AACD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhD;AACD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AACD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,0BASzE;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAInG"}

package/dist/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../src/utils.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@edgeandnode/graph-auth-kit",
+  "version": "0.2.0",
+  "private": false,
+  "description": "Wallet authentication connect kit in The Graph suite of applications",
+  "author": "Edge & Node",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/edgeandnode/components.git",
+    "directory": "packages/graph-auth-kit"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./safe": {
+      "types": "./dist/safe/index.d.ts",
+      "default": "./dist/safe/index.js"
+    },
+    "./test-harness": {
+      "types": "./dist/test-harness/index.d.ts",
+      "default": "./dist/test-harness/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "@emotion/react": "^11.13",
+    "@ethersproject/abstract-signer": "^5.7.0",
+    "@safe-global/api-kit": "2.4.3",
+    "@safe-global/protocol-kit": "4.0.3",
+    "@safe-global/safe-core-sdk-types": "5.0.3",
+    "@tanstack/react-query": "5.51.21",
+    "ethers": "5.7.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "theme-ui": "^0.16",
+    "viem": "2.18.6",
+    "wagmi": "2.12.1",
+    "@edgeandnode/common": "^6.18.0",
+    "@edgeandnode/go": "^6.42.0",
+    "@edgeandnode/gds": "^5.27.0"
+  },
+  "devDependencies": {
+    "@emotion/react": "^11.13",
+    "@ethersproject/abstract-provider": "^5.7.0",
+    "@ethersproject/properties": "^5.7.0",
+    "@safe-global/api-kit": "2.4.3",
+    "@safe-global/protocol-kit": "4.0.3",
+    "@safe-global/safe-core-sdk-types": "5.0.3",
+    "@tanstack/react-query": "5.51.21",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react-swc": "^3.5.0",
+    "autoprefixer": "^10.4.19",
+    "ethers": "5.7.2",
+    "postcss": "^8.4.40",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tailwindcss": "^3.4.7",
+    "ts-node": "^10.9.2",
+    "viem": "2.18.6",
+    "wagmi": "2.12.2",
+    "@edgeandnode/common": "^6.18.0",
+    "@edgeandnode/test-utils": "^2.0.0",
+    "@edgeandnode/go": "^6.42.0",
+    "@edgeandnode/gds": "^5.27.0"
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "scripts": {
+    "build": "vite build && tsc -P ./tsconfig.build.json --emitDeclarationOnly",
+    "check": "pnpm typecheck && pnpm lint && pnpm prettier:check",
+    "check:fix": "pnpm typecheck; pnpm lint:fix",
+    "typecheck": "tsc --noEmit --pretty",
+    "lint": "eslint src --ext .js,.jsx,.ts,.tsx --max-warnings 0",
+    "lint:fix": "eslint src --ext .js,.jsx,.ts,.tsx --fix; pnpm prettier",
+    "prettier": "prettier . !CHANGELOG.md --ignore-path ../../.prettierignore --write --list-different",
+    "prettier:check": "prettier . !CHANGELOG.md --ignore-path ../../.prettierignore --check",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage && jest-coverage-badges",
+    "test:watch": "vitest",
+    "npm:publish": "pnpm publish && git push"
+  }
+}