@edgeandnode/graph-auth-kit 0.2.0

package/dist/index.js

@@ -0,0 +1,442 @@
+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 { u as useGraphAuthKitInnerContext, e as clientToProvider } from "./GraphAuthKit.context-DBwb2jco.js";
+import { h, B, m, a, l, j, R, k, b, f, g, c, r, o, n, p, q, i } from "./GraphAuthKit.context-DBwb2jco.js";
+import { b as createSafe, c as createApiKit } from "./utils-KuRu9vB-.js";
+import { j as j2, A, D, g as g2, h as h2, L, e, M, a as a2, S, k as k2, l as l2, f as f2, d, i as i2 } from "./utils-KuRu9vB-.js";
+import { useMutation } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { encodeFunctionData, getAddress } from "viem";
+import { useChainId, useConnectorClient, useAccount, useWalletClient, useConfig } from "wagmi";
+import { writeContractMutationOptions } from "wagmi/query";
+import { VoidSigner } from "@ethersproject/abstract-signer";
+import { OperationType } from "@safe-global/safe-core-sdk-types";
+import { utils, BigNumber } from "ethers";
+const createLibAddress = "0x7cbB62EaA69F79e6873cD1ecB2392971036cFAa4";
+const createLibInterface = new utils.Interface([
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "newContract",
+        type: "address"
+      }
+    ],
+    name: "ContractCreation",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "deploymentData",
+        type: "bytes"
+      }
+    ],
+    name: "performCreate",
+    outputs: [
+      {
+        internalType: "address",
+        name: "newContract",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "deploymentData",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32"
+      }
+    ],
+    name: "performCreate2",
+    outputs: [
+      {
+        internalType: "address",
+        name: "newContract",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+]);
+const mapStatus = (receipt) => {
+  const success = receipt.logs.find(
+    (log) => log.topics[0] === "0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e"
+  );
+  return !!success ? 1 : 0;
+};
+const mapContractAddress = (receipt, safeTx) => {
+  if (safeTx.to.toLowerCase() === createLibAddress.toLowerCase()) {
+    const creationLog = receipt.logs.find(
+      (log) => log.topics[0] === "0x4db17dd5e4732fb6da34a148104a592783ca119a1e7bb8829eba6cbadef0b511"
+    );
+    if (creationLog) return utils.getAddress("0x" + creationLog.data.slice(creationLog.data.length - 40));
+  }
+  return receipt.contractAddress;
+};
+const mapReceipt = (receipt, safeTx) => {
+  receipt.status = mapStatus(receipt);
+  receipt.contractAddress = mapContractAddress(receipt, safeTx);
+  return receipt;
+};
+const sleep = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+class SafeEthersSigner extends VoidSigner {
+  constructor(safeAddress, provider, signerAddress, chainId, options) {
+    super(safeAddress, provider);
+    __publicField(this, "safeAddress");
+    __publicField(this, "signerAddress");
+    __publicField(this, "chainId");
+    __publicField(this, "options");
+    __publicField(this, "safe");
+    __publicField(this, "apiKit");
+    this.signerAddress = signerAddress;
+    this.safeAddress = safeAddress;
+    this.chainId = chainId;
+    this.options = options;
+  }
+  createSafeInstance() {
+    const eip1193Provider = {
+      request: async (args) => {
+        var _a;
+        return (_a = this.provider) == null ? void 0 : _a.send(args.method, args.params);
+      }
+    };
+    return createSafe({
+      provider: eip1193Provider,
+      signer: this.signerAddress,
+      safeAddress: this.safeAddress
+    });
+  }
+  async getSafeInstance() {
+    if (!this.safe) {
+      this.safe = await this.createSafeInstance();
+    }
+    return this.safe;
+  }
+  createApiKitInstance() {
+    return createApiKit(this.chainId);
+  }
+  async getApiKitInstance() {
+    if (!this.apiKit) {
+      this.apiKit = await this.createApiKitInstance();
+    }
+    return this.apiKit;
+  }
+  async buildTransactionResponse(safeTxHash, safeTx) {
+    const connectedSafe = await this.getSafeInstance();
+    const connectedService = await this.getApiKitInstance();
+    const chainIdBigInt = await connectedSafe.getChainId();
+    return {
+      to: safeTx.to,
+      value: BigNumber.from(safeTx.value),
+      data: safeTx.data,
+      operation: safeTx.operation,
+      gasLimit: BigNumber.from(safeTx.safeTxGas),
+      gasPrice: BigNumber.from(0),
+      nonce: safeTx.nonce,
+      chainId: parseInt(chainIdBigInt.toString()),
+      hash: safeTxHash,
+      from: this.address,
+      confirmations: 0,
+      wait: async (confirmations) => {
+        var _a, _b;
+        while (true) {
+          try {
+            const txDetails = await connectedService.getTransaction(safeTxHash);
+            if (txDetails.transactionHash) {
+              this._checkProvider("sendTransaction");
+              const receipt = await ((_a = this.provider) == null ? void 0 : _a.waitForTransaction(
+                txDetails.transactionHash,
+                confirmations
+              ));
+              return mapReceipt(receipt, safeTx);
+            }
+          } catch (e2) {
+          }
+          await sleep(((_b = this.options) == null ? void 0 : _b.pollingDelay) ?? 5e3);
+        }
+      }
+    };
+  }
+  /**
+   * Populates all fields in a transaction, signs it and sends it to the Safe transaction service
+   *
+   * @param transaction - The transaction what should be send
+   * @returns A promise that resolves to a SafeTransactionReponse, that contains all the information of the transaction.
+   */
+  async sendTransaction(transaction) {
+    var _a;
+    const tx = await transaction;
+    let operation = OperationType.Call;
+    let to = await tx.to;
+    let data = ((_a = await tx.data) == null ? void 0 : _a.toString()) ?? "0x";
+    let value = BigNumber.from(await tx.value ?? 0);
+    if (!to) {
+      to = createLibAddress;
+      data = createLibInterface.encodeFunctionData("performCreate", [value, data]);
+      value = BigNumber.from(0);
+      operation = OperationType.DelegateCall;
+    }
+    const baseTx = {
+      to,
+      data,
+      value: value.toString(),
+      operation
+    };
+    const apiKit = await this.getApiKitInstance();
+    const nonce = await apiKit.getNextNonce(this.address);
+    const safeTransactionData = {
+      ...baseTx,
+      nonce
+      //   baseGas,
+      //   gasPrice,
+      //   gasToken,
+      //   refundReceiver,
+    };
+    const estimateTx = await apiKit.estimateSafeTransaction(this.safeAddress, safeTransactionData);
+    safeTransactionData.safeTxGas = estimateTx.safeTxGas;
+    const connectedSafe = await this.getSafeInstance();
+    const safeTransaction = await connectedSafe.createTransaction({ transactions: [safeTransactionData] });
+    const safeTxHash = await connectedSafe.getTransactionHash(safeTransaction);
+    const senderSignature = await connectedSafe.signHash(safeTxHash);
+    await apiKit.proposeTransaction({
+      safeAddress: this.safeAddress,
+      safeTransactionData: safeTransaction.data,
+      safeTxHash,
+      senderAddress: this.signerAddress,
+      senderSignature: senderSignature.data
+    });
+    return this.buildTransactionResponse(safeTxHash, safeTransaction.data);
+  }
+}
+function safeViemActions(safeAddress, chainId) {
+  return (client) => {
+    return {
+      async writeContract(parameters) {
+        const eip1193Provider = {
+          async request({ method, params }) {
+            if (method === "eth_requestAccounts") {
+              return client.requestAddresses();
+            }
+            if (method === "eth_accounts") {
+              return client.getAddresses();
+            }
+            if (method === "eth_signTypedData_v4") {
+              const arg = params && Array.isArray(params) ? params[1] : void 0;
+              const json = JSON.parse(arg);
+              return client.signTypedData(json);
+            }
+            if (method === "eth_sendTransaction") {
+              const tx = params && Array.isArray(params) ? params[0] : void 0;
+              return client.sendTransaction({
+                account: client.account,
+                chain: client.chain,
+                to: (tx == null ? void 0 : tx.to) || "0x",
+                value: tx == null ? void 0 : tx.value,
+                data: tx == null ? void 0 : tx.data,
+                nonce: tx == null ? void 0 : tx.nonce
+              });
+            }
+            return client.request({ method, params });
+          }
+        };
+        const apiKit = await createApiKit(chainId);
+        const signerAddresses = await client.getAddresses();
+        const signerAddress = signerAddresses[0];
+        const protocolKit = await createSafe({ provider: eip1193Provider, signer: signerAddress, safeAddress });
+        const { abi, address, args, dataSuffix, functionName, value, ...request } = parameters;
+        const data = encodeFunctionData({
+          abi,
+          args,
+          functionName
+        });
+        const dataWithSuffix = `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`;
+        const operation = OperationType.Call;
+        const baseTx = {
+          to: address,
+          data: dataWithSuffix,
+          value: value ? value.toString() : "0",
+          operation
+        };
+        const nonce = await apiKit.getNextNonce(safeAddress);
+        const safeTransactionData = {
+          ...baseTx,
+          nonce
+          //   baseGas,
+          //   gasPrice,
+          //   gasToken,
+          //   refundReceiver,
+        };
+        const estimateTx = await apiKit.estimateSafeTransaction(safeAddress, safeTransactionData);
+        safeTransactionData.safeTxGas = estimateTx.safeTxGas;
+        const safeTransaction = await protocolKit.createTransaction({ transactions: [safeTransactionData] });
+        const safeTxHash = await protocolKit.getTransactionHash(safeTransaction);
+        const senderSignature = await protocolKit.signHash(safeTxHash);
+        await apiKit.proposeTransaction({
+          safeAddress,
+          safeTransactionData: safeTransaction.data,
+          safeTxHash,
+          senderAddress: signerAddress,
+          senderSignature: senderSignature.data
+        });
+        return safeTxHash;
+      }
+    };
+  };
+}
+function useClientToEthersSigner() {
+  const chainId = useChainId();
+  const { data: client } = useConnectorClient({ chainId });
+  const ctx = useGraphAuthKitInnerContext();
+  return useMemo(() => {
+    if (!client) return void 0;
+    const provider = clientToProvider(client);
+    if (ctx._connector === "multisig" && ctx._enteredMultisigInfo != null) {
+      const safeAddress = getAddress(ctx._enteredMultisigInfo.address);
+      const safeEthersSigner = new SafeEthersSigner(
+        safeAddress,
+        provider,
+        client.account.address,
+        chainId
+      );
+      return safeEthersSigner;
+    }
+    const signer = provider.getSigner();
+    return signer;
+  }, [chainId, client, ctx._connector, ctx._enteredMultisigInfo]);
+}
+function useGraphAuthKitConnector() {
+  const { _connector } = useGraphAuthKitInnerContext();
+  return _connector || null;
+}
+function useGraphAuthKitAccount() {
+  const data = useAccount();
+  const ctx = useGraphAuthKitInnerContext();
+  if (data.address == null || !data.isConnected || ctx._connector == null) {
+    return {
+      address: void 0,
+      addresses: void 0,
+      chain: void 0,
+      chainId: void 0,
+      connector: void 0,
+      isConnected: false,
+      isReconnecting: false,
+      isConnecting: false,
+      isDisconnected: true,
+      status: "disconnected",
+      eoa: void 0
+    };
+  }
+  if (ctx._connector === "multisig" && ctx._enteredMultisigInfo != null) {
+    const address = getAddress(ctx._enteredMultisigInfo.address);
+    const [, ...rest] = data.addresses ?? [];
+    return {
+      ...data,
+      address,
+      addresses: [address, data.address, ...rest],
+      eoa: data.address
+    };
+  }
+  return { ...data, eoa: void 0 };
+}
+function useGraphAuthKitWalletClient() {
+  const ctx = useGraphAuthKitInnerContext();
+  const walletClient = useWalletClient();
+  if (!walletClient.data) {
+    return walletClient;
+  }
+  if (ctx._connector === "multisig" && ctx._enteredMultisigInfo != null) {
+    const safeAddress = getAddress(ctx._enteredMultisigInfo.address);
+    const safeWalletClient = walletClient.data.extend(safeViemActions(safeAddress, ctx._enteredMultisigInfo.network));
+    return { ...walletClient, data: safeWalletClient };
+  }
+  return walletClient;
+}
+function useGraphAuthKitWriteContract(parameters = {}) {
+  const { data: walletClient } = useGraphAuthKitWalletClient();
+  const { mutation } = parameters;
+  const config = useConfig(parameters);
+  const mutationOptions = writeContractMutationOptions(config);
+  const customMutationFn = (variables) => {
+    if (!walletClient) {
+      throw new Error("WalletClient is not available");
+    }
+    return walletClient.writeContract(variables);
+  };
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+    mutationFn: customMutationFn
+  });
+  return {
+    ...result,
+    writeContract: mutate,
+    writeContractAsync: mutateAsync
+  };
+}
+export {
+  j2 as AUTH_STORAGE_KEY,
+  A as ApiKitUrlMap,
+  h as BuildClientArgs,
+  B as BuildPublicClientArgs,
+  D as DefChain,
+  m as GraphAuthKitConnector,
+  a as GraphAuthKitContext,
+  l as GraphAuthKitProps,
+  j as GraphAuthKitProvider,
+  g2 as L1Chain,
+  h2 as L1ChainTestnet,
+  L as L2Chain,
+  e as L2ChainTestnet,
+  M as MULTISIG_AUTH_STORAGE_KEY,
+  R as RequiredInfuraKey,
+  k as RequiredWalletConnectProjectId,
+  a2 as SafeSupportedNetworkNames,
+  S as SafeSupportedNetworks,
+  k2 as SupportedClientChainId,
+  l2 as SupportedClientChains,
+  b as buildClient,
+  f as buildInfuraHttpTransport,
+  g as buildPublicClient,
+  c as chainIsSupportedChain,
+  clientToProvider,
+  r as connectedWalletIsEoA,
+  createApiKit,
+  createSafe,
+  f2 as fetchOwnedSafes,
+  o as isChainL1,
+  n as isChainL2,
+  p as isChainMainnet,
+  q as isChainTestnet,
+  d as isSafeOwner,
+  i2 as isValidSafe,
+  useClientToEthersSigner,
+  i as useGraphAuthKit,
+  useGraphAuthKitAccount,
+  useGraphAuthKitConnector,
+  useGraphAuthKitWalletClient,
+  useGraphAuthKitWriteContract
+};

package/dist/safe/SafeEthersSigner.d.ts

@@ -0,0 +1,37 @@
+import { type TransactionReceipt, type TransactionRequest, type TransactionResponse } from '@ethersproject/abstract-provider';
+import { VoidSigner } from '@ethersproject/abstract-signer';
+import { type Deferrable } from '@ethersproject/properties';
+import type SafeApiKit from '@safe-global/api-kit';
+import type Safe from '@safe-global/protocol-kit';
+import { OperationType, type SafeTransactionData } from '@safe-global/safe-core-sdk-types';
+import { type providers } from 'ethers';
+import { type SafeSupportedNetworks } from './constants';
+export declare const mapReceipt: (receipt: providers.TransactionReceipt, safeTx: SafeTransactionData) => TransactionReceipt;
+export interface SafeTransactionResponse extends TransactionResponse {
+    operation: OperationType;
+}
+export interface SafeEthersSignerOptions {
+    pollingDelay?: number;
+}
+export declare class SafeEthersSigner extends VoidSigner {
+    readonly safeAddress: string;
+    readonly signerAddress: string;
+    readonly chainId: SafeSupportedNetworks;
+    readonly options?: SafeEthersSignerOptions;
+    safe?: Safe;
+    apiKit?: SafeApiKit;
+    constructor(safeAddress: string, provider: providers.Web3Provider, signerAddress: string, chainId: SafeSupportedNetworks, options?: SafeEthersSignerOptions);
+    createSafeInstance(): Promise<Safe>;
+    getSafeInstance(): Promise<Safe>;
+    createApiKitInstance(): Promise<SafeApiKit>;
+    getApiKitInstance(): Promise<SafeApiKit>;
+    buildTransactionResponse(safeTxHash: string, safeTx: SafeTransactionData): Promise<SafeTransactionResponse>;
+    /**
+     * Populates all fields in a transaction, signs it and sends it to the Safe transaction service
+     *
+     * @param transaction - The transaction what should be send
+     * @returns A promise that resolves to a SafeTransactionReponse, that contains all the information of the transaction.
+     */
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<SafeTransactionResponse>;
+}
+//# sourceMappingURL=SafeEthersSigner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SafeEthersSigner.d.ts","sourceRoot":"","sources":["../../src/safe/SafeEthersSigner.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAC3D,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,KAAK,UAAU,MAAM,sBAAsB,CAAA;AAClD,OAAO,KAAK,IAAI,MAAM,2BAA2B,CAAA;AAEjD,OAAO,EACL,aAAa,EACb,KAAK,mBAAmB,EAEzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAa,KAAK,SAAS,EAAS,MAAM,QAAQ,CAAA;AAEzD,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAgGxD,eAAO,MAAM,UAAU,YAAa,SAAS,CAAC,kBAAkB,UAAU,mBAAmB,uBAK5F,CAAA;AAID,MAAM,WAAW,uBAAwB,SAAQ,mBAAmB;IAClE,SAAS,EAAE,aAAa,CAAA;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAGD,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAA;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAA;IAC1C,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,MAAM,CAAC,EAAE,UAAU,CAAA;gBAGjB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,SAAS,CAAC,YAAY,EAChC,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,CAAC,EAAE,uBAAuB;IASnC,kBAAkB;IAcZ,eAAe;IAOrB,oBAAoB;IAId,iBAAiB;IAOjB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAsCjH;;;;;OAKG;IACG,eAAe,CAAC,WAAW,EAAE,UAAU,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAyDrG"}

package/dist/safe/SafeMinimal.abi.d.ts

@@ -0,0 +1,80 @@
+declare const _default: readonly [{
+    readonly inputs: readonly [];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "getThreshold";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "getOwners";
+    readonly outputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "";
+        readonly type: "address[]";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "_data";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "_signature";
+        readonly type: "bytes";
+    }];
+    readonly name: "isValidSignature";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "nonce";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "isOwner";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export default _default;
+//# sourceMappingURL=SafeMinimal.abi.d.ts.map

package/dist/safe/SafeMinimal.abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SafeMinimal.abi.d.ts","sourceRoot":"","sources":["../../src/safe/SafeMinimal.abi.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,wBAoGU"}

package/dist/safe/constants.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const SafeSupportedNetworks: z.ZodReadonly<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<11155111>, z.ZodLiteral<42161>]>>;
+export type SafeSupportedNetworks = z.infer<typeof SafeSupportedNetworks>;
+export declare const SafeSupportedNetworkNames: {
+    readonly 42161: {
+        readonly shortName: "arb1";
+        readonly name: "Arbitrum One";
+        readonly id: 42161;
+    };
+    readonly 1: {
+        readonly shortName: "eth";
+        readonly name: "Ethereum";
+        readonly id: 1;
+    };
+    readonly 11155111: {
+        readonly shortName: "sep";
+        readonly name: "Sepolia";
+        readonly id: 11155111;
+    };
+};
+export declare const ApiKitUrlMap: {
+    readonly 1: "https://safe-transaction-mainnet.safe.global/api";
+    readonly 11155111: "https://safe-transaction-sepolia.safe.global/api";
+    readonly 42161: "https://safe-transaction-arbitrum.safe.global/api";
+};
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/safe/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,qBAAqB,oGAErB,CAAA;AACb,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;CAWrC,CAAA;AAED,eAAO,MAAM,YAAY;;;;CAIiC,CAAA"}

package/dist/safe/index.d.ts

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

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

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

package/dist/safe/index.js

@@ -0,0 +1,11 @@
+import { A, a, S, c, b, f, d, i } from "../utils-KuRu9vB-.js";
+export {
+  A as ApiKitUrlMap,
+  a as SafeSupportedNetworkNames,
+  S as SafeSupportedNetworks,
+  c as createApiKit,
+  b as createSafe,
+  f as fetchOwnedSafes,
+  d as isSafeOwner,
+  i as isValidSafe
+};

package/dist/safe/safeViemActions.d.ts

@@ -0,0 +1,4 @@
+import { type Account, type Chain, type Transport, type WalletActions, type WalletClient } from 'viem';
+import { type SafeSupportedNetworks } from './constants';
+export declare function safeViemActions(safeAddress: string, chainId: SafeSupportedNetworks): <transport extends Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined>(client: WalletClient<transport, chain, account>) => Pick<WalletActions<chain, account>, "writeContract">;
+//# sourceMappingURL=safeViemActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safeViemActions.d.ts","sourceRoot":"","sources":["../../src/safe/safeViemActions.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAEV,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,MAAM,CAAA;AAGb,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAGxD,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,IAE/E,SAAS,SAAS,SAAS,EAC3B,KAAK,SAAS,KAAK,GAAG,SAAS,sBAC/B,OAAO,SAAS,OAAO,GAAG,SAAS,gCAE3B,YAAY,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,KAC9C,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,eAAe,CAAC,CAgGxD"}

package/dist/safe/utils.d.ts

@@ -0,0 +1,38 @@
+import type SafeApiKit from '@safe-global/api-kit';
+import type Safe from '@safe-global/protocol-kit';
+import { type SafeConfig } from '@safe-global/protocol-kit';
+import { type Address } from 'viem';
+import { type PublicClient } from '../client';
+import { type SafeSupportedNetworks } from './constants';
+export declare function createApiKit(chainId: SafeSupportedNetworks): Promise<SafeApiKit>;
+export declare function createSafe(config: SafeConfig): Promise<Safe>;
+export type IsValidSafeArgs = {
+    client: PublicClient;
+    chain: SafeSupportedNetworks;
+    safeAddress: Address;
+};
+export declare function isValidSafe(args: IsValidSafeArgs): Promise<boolean>;
+export type IsSafeOwnerArgs = {
+    client: PublicClient;
+    chain: SafeSupportedNetworks;
+    safeAddress: Address;
+    eoa: Address;
+};
+export declare function isSafeOwner(args: IsSafeOwnerArgs): Promise<boolean>;
+export type FetchOwnedSafesArgs<chains extends readonly [SafeSupportedNetworks, ...SafeSupportedNetworks[]]> = {
+    /** The EoA Safe signer to fetch owned Safes for */
+    signer: Address;
+    /**
+     * Which chains to retrieve the EoA owned Safes on.
+     * @default all
+     */
+    chains?: chains;
+};
+export declare function fetchOwnedSafes<const chains extends readonly [SafeSupportedNetworks, ...SafeSupportedNetworks[]]>(args: FetchOwnedSafesArgs<chains>): Promise<{
+    [K in chains[number]]: readonly Address[];
+}>;
+export type SafesByChain = {
+    address: Address;
+    chain: SafeSupportedNetworks;
+};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/safe/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,sBAAsB,CAAA;AAClD,OAAO,KAAK,IAAI,MAAM,2BAA2B,CAAA;AACjD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,KAAK,OAAO,EAAa,MAAM,MAAM,CAAA;AAG9C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AAG7C,OAAO,EAAgB,KAAK,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAGtE,wBAAsB,YAAY,CAAC,OAAO,EAAE,qBAAqB,uBAUhE;AAED,wBAAsB,UAAU,CAAC,MAAM,EAAE,UAAU,iBAOlD;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,YAAY,CAAA;IACpB,KAAK,EAAE,qBAAqB,CAAA;IAC5B,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AACD,wBAAsB,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAYzE;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,YAAY,CAAA;IACpB,KAAK,EAAE,qBAAqB,CAAA;IAC5B,WAAW,EAAE,OAAO,CAAA;IACpB,GAAG,EAAE,OAAO,CAAA;CACb,CAAA;AACD,wBAAsB,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAYzE;AAED,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,SAAS,CAAC,qBAAqB,EAAE,GAAG,qBAAqB,EAAE,CAAC,IAAI;IAC7G,mDAAmD;IACnD,MAAM,EAAE,OAAO,CAAA;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AACD,wBAAsB,eAAe,CACnC,KAAK,CAAC,MAAM,SAAS,SAAS,CAAC,qBAAqB,EAAE,GAAG,qBAAqB,EAAE,CAAC,EACjF,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,SAAS,OAAO,EAAE;CAAE,CAAC,CAQ3F;AAMD,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA"}

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

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

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

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