smart-multisig-engine 0.1.0

package/dist/react.cjs

@@ -0,0 +1,324 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  useFetchPendingTxs: () => useFetchPendingTxs,
+  useSimulate: () => useSimulate,
+  useSubmitTx: () => useSubmitTx,
+  useWaitForExecution: () => useWaitForExecution,
+  useWrite: () => useWrite
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/use-submit-tx.ts
+var import_react_query = require("@tanstack/react-query");
+
+// src/adapters/safe/simulate-contract-call.ts
+var import_core = require("@wagmi/core");
+async function simulateContractCall(config, params) {
+  return (0, import_core.simulateContract)(config, {
+    address: params.address,
+    abi: params.abi,
+    functionName: params.functionName,
+    args: params.args,
+    value: params.value,
+    chainId: params.chainId,
+    account: params.account
+  });
+}
+
+// src/adapters/safe/write-contract-call.ts
+var import_core2 = require("@wagmi/core");
+async function writeContractCall(config, request) {
+  return (0, import_core2.writeContract)(config, request);
+}
+
+// src/adapters/safe/fetch-pending-transactions.ts
+var import_api_kit = __toESM(require("@safe-global/api-kit"), 1);
+async function fetchPendingTransactions(params) {
+  const apiKit = new import_api_kit.default({
+    chainId: params.chainId,
+    ...params.txServiceUrl && { txServiceUrl: params.txServiceUrl },
+    apiKey: params.apiKey
+  });
+  const response = await apiKit.getPendingTransactions(params.safeAddress);
+  return response.results;
+}
+
+// src/core/extract-call-data.ts
+var import_viem = require("viem");
+function extractCallData(params) {
+  const data = (0, import_viem.encodeFunctionData)({
+    abi: params.abi,
+    functionName: params.functionName,
+    args: params.args
+  });
+  return {
+    to: params.address,
+    data,
+    value: params.value ?? 0n
+  };
+}
+
+// src/core/match-pending-tx.ts
+function matchPendingTransaction(pendingTxs, criteria) {
+  return pendingTxs.find(
+    (tx) => tx.to.toLowerCase() === criteria.to.toLowerCase() && tx.value === String(criteria.value) && tx.data?.toLowerCase() === criteria.data.toLowerCase()
+  );
+}
+
+// src/adapters/safe/submit-and-find-safe-tx.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function submitAndFindSafeTx(options) {
+  const {
+    config,
+    safeAddress,
+    txServiceUrl,
+    apiKey,
+    pollingInterval = 3e3,
+    maxAttempts = 20,
+    ...callParams
+  } = options;
+  const callData = extractCallData(callParams);
+  const simulation = await simulateContractCall(config, callParams);
+  await writeContractCall(config, simulation.request);
+  const chainId = BigInt(callParams.chainId ?? await getChainId(config));
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await delay(pollingInterval);
+    const pendingTxs = await fetchPendingTransactions({
+      chainId,
+      safeAddress,
+      txServiceUrl,
+      apiKey
+    });
+    const match = matchPendingTransaction(pendingTxs, callData);
+    if (match) {
+      return {
+        safeTxHash: match.safeTxHash
+      };
+    }
+  }
+  throw new Error(
+    `Could not find matching Safe transaction after ${maxAttempts} attempts`
+  );
+}
+async function getChainId(config) {
+  const { getChainId: wagmiGetChainId } = await import("@wagmi/core");
+  return wagmiGetChainId(config);
+}
+
+// src/adapters/safe/wait-for-execution.ts
+var import_api_kit2 = __toESM(require("@safe-global/api-kit"), 1);
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForExecution(options) {
+  const {
+    safeTxHash,
+    chainId,
+    txServiceUrl,
+    apiKey,
+    pollingInterval = 5e3,
+    maxAttempts = 60
+  } = options;
+  const apiKit = new import_api_kit2.default({
+    chainId,
+    ...txServiceUrl && { txServiceUrl },
+    apiKey
+  });
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const tx = await apiKit.getTransaction(safeTxHash);
+    if (tx.isExecuted && tx.transactionHash) {
+      return {
+        transactionHash: tx.transactionHash
+      };
+    }
+    await delay2(pollingInterval);
+  }
+  throw new Error(
+    `Safe transaction ${safeTxHash} was not executed after ${maxAttempts} attempts`
+  );
+}
+
+// src/adapters/registry.ts
+var adapters = {
+  safe: {
+    submitTx: submitAndFindSafeTx,
+    waitForExecution,
+    fetchPending: fetchPendingTransactions,
+    simulate: simulateContractCall,
+    write: writeContractCall
+  }
+};
+
+// src/adapters/index.ts
+async function submitTx(options) {
+  const { adapter, walletAddress, ...rest } = options;
+  assertAdapter(adapter);
+  const result = await adapters[adapter].submitTx({
+    safeAddress: walletAddress,
+    ...rest
+  });
+  return { txHash: result.safeTxHash };
+}
+async function waitForExecution2(options) {
+  const { adapter, txHash, ...rest } = options;
+  assertAdapter(adapter);
+  const result = await adapters[adapter].waitForExecution({
+    safeTxHash: txHash,
+    ...rest
+  });
+  return { transactionHash: result.transactionHash };
+}
+async function fetchPendingTxs(options) {
+  const { adapter, walletAddress, ...rest } = options;
+  assertAdapter(adapter);
+  return adapters[adapter].fetchPending({
+    safeAddress: walletAddress,
+    ...rest
+  });
+}
+async function simulate(options) {
+  const { adapter, config, ...params } = options;
+  assertAdapter(adapter);
+  return adapters[adapter].simulate(config, params);
+}
+async function write(options) {
+  const { adapter, config, request } = options;
+  assertAdapter(adapter);
+  return adapters[adapter].write(config, request);
+}
+function assertAdapter(adapter) {
+  if (!(adapter in adapters)) {
+    throw new Error(`Unknown adapter: ${adapter}. Available: ${Object.keys(adapters).join(", ")}`);
+  }
+}
+
+// src/react/use-submit-tx.ts
+function useSubmitTx() {
+  return (0, import_react_query.useMutation)({
+    mutationFn: (options) => submitTx(options)
+  });
+}
+
+// src/react/use-wait-for-execution.ts
+var import_react_query2 = require("@tanstack/react-query");
+function useWaitForExecution(options) {
+  const {
+    enabled = true,
+    pollingInterval = 5e3,
+    timeout = 12e4,
+    ...waitOptions
+  } = options;
+  const maxAttempts = Math.ceil(timeout / pollingInterval);
+  return (0, import_react_query2.useQuery)({
+    queryKey: [
+      "adapter",
+      options.adapter,
+      "waitForExecution",
+      options.txHash,
+      options.chainId.toString()
+    ],
+    queryFn: () => waitForExecution2({
+      ...waitOptions,
+      pollingInterval,
+      maxAttempts
+    }),
+    enabled: enabled && !!options.txHash,
+    // Don't refetch - the query handles polling internally
+    refetchInterval: false,
+    refetchOnWindowFocus: false,
+    refetchOnMount: false,
+    refetchOnReconnect: false,
+    // Don't retry on error - timeout is intentional
+    retry: false,
+    // Keep data fresh
+    staleTime: Infinity,
+    // Cache result for this specific txHash
+    gcTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+}
+
+// src/react/use-fetch-pending-txs.ts
+var import_react_query3 = require("@tanstack/react-query");
+function useFetchPendingTxs(options) {
+  const { enabled = true, refetchInterval = false, ...fetchOptions } = options;
+  return (0, import_react_query3.useQuery)({
+    queryKey: [
+      "adapter",
+      options.adapter,
+      "pendingTxs",
+      options.walletAddress,
+      options.chainId.toString()
+    ],
+    queryFn: () => fetchPendingTxs(fetchOptions),
+    enabled: enabled && !!options.walletAddress,
+    refetchInterval
+  });
+}
+
+// src/react/use-simulate.ts
+var import_react_query4 = require("@tanstack/react-query");
+function useSimulate(options) {
+  const { enabled = true, ...simulateOptions } = options;
+  return (0, import_react_query4.useQuery)({
+    queryKey: [
+      "adapter",
+      options.adapter,
+      "simulate",
+      options.address,
+      options.functionName,
+      JSON.stringify(options.args)
+    ],
+    queryFn: () => simulate(simulateOptions),
+    enabled
+  });
+}
+
+// src/react/use-write.ts
+var import_react_query5 = require("@tanstack/react-query");
+function useWrite() {
+  return (0, import_react_query5.useMutation)({
+    mutationFn: (options) => write(options)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFetchPendingTxs,
+  useSimulate,
+  useSubmitTx,
+  useWaitForExecution,
+  useWrite
+});
+//# sourceMappingURL=react.cjs.map

package/dist/react.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react/index.ts","../src/react/use-submit-tx.ts","../src/adapters/safe/simulate-contract-call.ts","../src/adapters/safe/write-contract-call.ts","../src/adapters/safe/fetch-pending-transactions.ts","../src/core/extract-call-data.ts","../src/core/match-pending-tx.ts","../src/adapters/safe/submit-and-find-safe-tx.ts","../src/adapters/safe/wait-for-execution.ts","../src/adapters/registry.ts","../src/adapters/index.ts","../src/react/use-wait-for-execution.ts","../src/react/use-fetch-pending-txs.ts","../src/react/use-simulate.ts","../src/react/use-write.ts"],"sourcesContent":["export * from \"./use-submit-tx.js\";\nexport * from \"./use-wait-for-execution.js\";\nexport * from \"./use-fetch-pending-txs.js\";\nexport * from \"./use-simulate.js\";\nexport * from \"./use-write.js\";\n","import { useMutation } from \"@tanstack/react-query\";\nimport { submitTx } from \"../adapters/index.js\";\nimport type { SubmitTxOptions, SubmitTxResult } from \"../adapters/types.js\";\n\nexport type UseSubmitTxOptions = Omit<SubmitTxOptions, \"config\"> & {\n  config: SubmitTxOptions[\"config\"];\n};\n\nexport function useSubmitTx() {\n  return useMutation<SubmitTxResult, Error, UseSubmitTxOptions>({\n    mutationFn: (options) => submitTx(options),\n  });\n}\n","import { simulateContract, type Config } from \"@wagmi/core\";\nimport type { ContractCallParams } from \"../../core/types.js\";\n\nexport async function simulateContractCall(\n  config: Config,\n  params: ContractCallParams,\n) {\n  return simulateContract(config, {\n    address: params.address,\n    abi: params.abi,\n    functionName: params.functionName,\n    args: params.args as unknown[],\n    value: params.value,\n    chainId: params.chainId,\n    account: params.account,\n  });\n}\n","import { writeContract, type Config } from \"@wagmi/core\";\nimport type { Hex } from \"viem\";\n\nexport async function writeContractCall(\n  config: Config,\n  request: Parameters<typeof writeContract>[1],\n): Promise<Hex> {\n  return writeContract(config, request);\n}\n","import SafeApiKit from \"@safe-global/api-kit\";\nimport type { SafeMultisigTransactionResponse } from \"@safe-global/types-kit\";\n\nexport interface FetchPendingTransactionsParams {\n  chainId: bigint;\n  safeAddress: string;\n  txServiceUrl?: string;\n  apiKey?: string;\n}\n\nexport async function fetchPendingTransactions(\n  params: FetchPendingTransactionsParams,\n): Promise<SafeMultisigTransactionResponse[]> {\n  const apiKit = new SafeApiKit({\n    chainId: params.chainId,\n    ...(params.txServiceUrl && { txServiceUrl: params.txServiceUrl }),\n    apiKey: params.apiKey,\n  });\n\n  const response = await apiKit.getPendingTransactions(params.safeAddress);\n  return response.results;\n}\n","import type { Abi, Address } from \"viem\";\nimport { encodeFunctionData } from \"viem\";\nimport type { EncodedCallData } from \"./types.js\";\n\nexport function extractCallData(params: {\n  abi: Abi;\n  functionName: string;\n  args?: readonly unknown[];\n  address: Address;\n  value?: bigint;\n}): EncodedCallData {\n  const data = encodeFunctionData({\n    abi: params.abi,\n    functionName: params.functionName,\n    args: params.args as unknown[],\n  });\n\n  return {\n    to: params.address,\n    data,\n    value: params.value ?? 0n,\n  };\n}\n","import type { SafeMultisigTransactionResponse } from \"@safe-global/types-kit\";\nimport type { TxMatchCriteria } from \"./types.js\";\n\nexport function matchPendingTransaction(\n  pendingTxs: SafeMultisigTransactionResponse[],\n  criteria: TxMatchCriteria,\n): SafeMultisigTransactionResponse | undefined {\n  return pendingTxs.find(\n    (tx) =>\n      tx.to.toLowerCase() === criteria.to.toLowerCase() &&\n      tx.value === String(criteria.value) &&\n      tx.data?.toLowerCase() === criteria.data.toLowerCase(),\n  );\n}\n","import { extractCallData } from \"../../core/extract-call-data.js\";\nimport { matchPendingTransaction } from \"../../core/match-pending-tx.js\";\nimport { fetchPendingTransactions } from \"./fetch-pending-transactions.js\";\nimport { simulateContractCall } from \"./simulate-contract-call.js\";\nimport { writeContractCall } from \"./write-contract-call.js\";\nimport type {\n  SubmitAndFindSafeTxOptions,\n  SubmitAndFindSafeTxResult,\n} from \"./types.js\";\n\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nexport async function submitAndFindSafeTx(\n  options: SubmitAndFindSafeTxOptions,\n): Promise<SubmitAndFindSafeTxResult> {\n  const {\n    config,\n    safeAddress,\n    txServiceUrl,\n    apiKey,\n    pollingInterval = 3000,\n    maxAttempts = 20,\n    ...callParams\n  } = options;\n\n  const callData = extractCallData(callParams);\n\n  const simulation = await simulateContractCall(config, callParams);\n\n  await writeContractCall(config, simulation.request as Parameters<typeof writeContractCall>[1]);\n\n  const chainId = BigInt(callParams.chainId ?? (await getChainId(config)));\n\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    await delay(pollingInterval);\n\n    const pendingTxs = await fetchPendingTransactions({\n      chainId,\n      safeAddress,\n      txServiceUrl,\n      apiKey,\n    });\n    const match = matchPendingTransaction(pendingTxs, callData);\n\n    if (match) {\n      return {\n        safeTxHash: match.safeTxHash,\n      };\n    }\n  }\n\n  throw new Error(\n    `Could not find matching Safe transaction after ${maxAttempts} attempts`,\n  );\n}\n\nasync function getChainId(config: Parameters<typeof simulateContractCall>[0]): Promise<number> {\n  const { getChainId: wagmiGetChainId } = await import(\"@wagmi/core\");\n  return wagmiGetChainId(config);\n}\n","import SafeApiKit from \"@safe-global/api-kit\";\nimport type {\n  WaitForExecutionOptions,\n  WaitForExecutionResult,\n} from \"./types.js\";\n\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nexport async function waitForExecution(\n  options: WaitForExecutionOptions,\n): Promise<WaitForExecutionResult> {\n  const {\n    safeTxHash,\n    chainId,\n    txServiceUrl,\n    apiKey,\n    pollingInterval = 5000,\n    maxAttempts = 60,\n  } = options;\n\n  const apiKit = new SafeApiKit({\n    chainId,\n    ...(txServiceUrl && { txServiceUrl }),\n    apiKey,\n  });\n\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    const tx = await apiKit.getTransaction(safeTxHash);\n\n    if (tx.isExecuted && tx.transactionHash) {\n      return {\n        transactionHash: tx.transactionHash,\n      };\n    }\n\n    await delay(pollingInterval);\n  }\n\n  throw new Error(\n    `Safe transaction ${safeTxHash} was not executed after ${maxAttempts} attempts`,\n  );\n}\n","import * as safe from \"./safe/index.js\";\n\nexport const adapters = {\n  safe: {\n    submitTx: safe.submitAndFindSafeTx,\n    waitForExecution: safe.waitForExecution,\n    fetchPending: safe.fetchPendingTransactions,\n    simulate: safe.simulateContractCall,\n    write: safe.writeContractCall,\n  },\n} as const;\n\nexport type AdapterRegistry = typeof adapters;\n","import { adapters } from \"./registry.js\";\nimport type {\n  AdapterType,\n  SubmitTxOptions,\n  SubmitTxResult,\n  WaitForExecutionOptions,\n  WaitForExecutionResult,\n  FetchPendingOptions,\n  SimulateOptions,\n  WriteOptions,\n} from \"./types.js\";\n\n// Re-export types\nexport * from \"./types.js\";\n\n// Re-export Safe adapter for direct access\nexport * as safe from \"./safe/index.js\";\n\n// Generic entry functions\n\nexport async function submitTx(\n  options: SubmitTxOptions,\n): Promise<SubmitTxResult> {\n  const { adapter, walletAddress, ...rest } = options;\n  assertAdapter(adapter);\n\n  const result = await adapters[adapter].submitTx({\n    safeAddress: walletAddress,\n    ...rest,\n  });\n\n  return { txHash: result.safeTxHash };\n}\n\nexport async function waitForExecution(\n  options: WaitForExecutionOptions,\n): Promise<WaitForExecutionResult> {\n  const { adapter, txHash, ...rest } = options;\n  assertAdapter(adapter);\n\n  const result = await adapters[adapter].waitForExecution({\n    safeTxHash: txHash,\n    ...rest,\n  });\n\n  return { transactionHash: result.transactionHash };\n}\n\nexport async function fetchPendingTxs(\n  options: FetchPendingOptions,\n): Promise<unknown[]> {\n  const { adapter, walletAddress, ...rest } = options;\n  assertAdapter(adapter);\n\n  return adapters[adapter].fetchPending({\n    safeAddress: walletAddress,\n    ...rest,\n  });\n}\n\nexport async function simulate(\n  options: SimulateOptions,\n): Promise<unknown> {\n  const { adapter, config, ...params } = options;\n  assertAdapter(adapter);\n\n  return adapters[adapter].simulate(config, params);\n}\n\nexport async function write(\n  options: WriteOptions,\n): Promise<string> {\n  const { adapter, config, request } = options;\n  assertAdapter(adapter);\n\n  return adapters[adapter].write(config, request as Parameters<typeof adapters.safe.write>[1]);\n}\n\nfunction assertAdapter(adapter: AdapterType): asserts adapter is keyof typeof adapters {\n  if (!(adapter in adapters)) {\n    throw new Error(`Unknown adapter: ${adapter}. Available: ${Object.keys(adapters).join(\", \")}`);\n  }\n}\n","import { useQuery } from \"@tanstack/react-query\";\nimport { waitForExecution } from \"../adapters/index.js\";\nimport type { WaitForExecutionOptions, WaitForExecutionResult } from \"../adapters/types.js\";\n\nexport interface UseWaitForExecutionOptions extends Omit<WaitForExecutionOptions, \"maxAttempts\"> {\n  /** Enable/disable the query. Defaults to true. */\n  enabled?: boolean;\n  /** Polling interval in ms. Defaults to 5000. */\n  pollingInterval?: number;\n  /** Timeout in ms. After this duration, the query will fail. Defaults to 120000 (2 min). */\n  timeout?: number;\n}\n\n/**\n * Hook to wait for a Safe transaction to be executed on-chain.\n *\n * Unlike standard polling queries, this hook maintains a stable loading state\n * throughout the polling process (similar to wagmi's useWaitForTransactionReceipt):\n * - `isLoading` = true while waiting for execution\n * - `isSuccess` = true once transaction is executed\n * - `isError` = true if timeout is reached\n */\nexport function useWaitForExecution(options: UseWaitForExecutionOptions) {\n  const {\n    enabled = true,\n    pollingInterval = 5000,\n    timeout = 120000,\n    ...waitOptions\n  } = options;\n\n  // Calculate max attempts from timeout and polling interval\n  const maxAttempts = Math.ceil(timeout / pollingInterval);\n\n  return useQuery<WaitForExecutionResult, Error>({\n    queryKey: [\n      \"adapter\",\n      options.adapter,\n      \"waitForExecution\",\n      options.txHash,\n      options.chainId.toString(),\n    ],\n    queryFn: () =>\n      waitForExecution({\n        ...waitOptions,\n        pollingInterval,\n        maxAttempts,\n      }),\n    enabled: enabled && !!options.txHash,\n    // Don't refetch - the query handles polling internally\n    refetchInterval: false,\n    refetchOnWindowFocus: false,\n    refetchOnMount: false,\n    refetchOnReconnect: false,\n    // Don't retry on error - timeout is intentional\n    retry: false,\n    // Keep data fresh\n    staleTime: Infinity,\n    // Cache result for this specific txHash\n    gcTime: 1000 * 60 * 5, // 5 minutes\n  });\n}\n","import { useQuery } from \"@tanstack/react-query\";\nimport { fetchPendingTxs } from \"../adapters/index.js\";\nimport type { FetchPendingOptions } from \"../adapters/types.js\";\n\nexport interface UseFetchPendingTxsOptions extends FetchPendingOptions {\n  enabled?: boolean;\n  refetchInterval?: number | false;\n}\n\nexport function useFetchPendingTxs(options: UseFetchPendingTxsOptions) {\n  const { enabled = true, refetchInterval = false, ...fetchOptions } = options;\n\n  return useQuery<unknown[], Error>({\n    queryKey: [\n      \"adapter\",\n      options.adapter,\n      \"pendingTxs\",\n      options.walletAddress,\n      options.chainId.toString(),\n    ],\n    queryFn: () => fetchPendingTxs(fetchOptions),\n    enabled: enabled && !!options.walletAddress,\n    refetchInterval,\n  });\n}\n","import { useQuery } from \"@tanstack/react-query\";\nimport { simulate } from \"../adapters/index.js\";\nimport type { SimulateOptions } from \"../adapters/types.js\";\n\nexport interface UseSimulateOptions extends SimulateOptions {\n  enabled?: boolean;\n}\n\nexport function useSimulate(options: UseSimulateOptions) {\n  const { enabled = true, ...simulateOptions } = options;\n\n  return useQuery<unknown, Error>({\n    queryKey: [\n      \"adapter\",\n      options.adapter,\n      \"simulate\",\n      options.address,\n      options.functionName,\n      JSON.stringify(options.args),\n    ],\n    queryFn: () => simulate(simulateOptions),\n    enabled,\n  });\n}\n","import { useMutation } from \"@tanstack/react-query\";\nimport { write } from \"../adapters/index.js\";\nimport type { WriteOptions } from \"../adapters/types.js\";\n\nexport function useWrite() {\n  return useMutation<string, Error, WriteOptions>({\n    mutationFn: (options) => write(options),\n  });\n}\n"],"mappings":"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","names":["import_core","SafeApiKit","import_api_kit","delay","SafeApiKit","waitForExecution","import_react_query","waitForExecution","import_react_query","import_react_query","import_react_query"]}

package/dist/react.d.cts

@@ -0,0 +1,43 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { a as SubmitTxOptions, b as SubmitTxResult, W as WaitForExecutionOptions, c as WaitForExecutionResult, F as FetchPendingOptions, S as SimulateOptions, d as WriteOptions } from './types-BJD1jdcY.cjs';
+import '@wagmi/core';
+import 'viem';
+
+type UseSubmitTxOptions = Omit<SubmitTxOptions, "config"> & {
+    config: SubmitTxOptions["config"];
+};
+declare function useSubmitTx(): _tanstack_react_query.UseMutationResult<SubmitTxResult, Error, UseSubmitTxOptions, unknown>;
+
+interface UseWaitForExecutionOptions extends Omit<WaitForExecutionOptions, "maxAttempts"> {
+    /** Enable/disable the query. Defaults to true. */
+    enabled?: boolean;
+    /** Polling interval in ms. Defaults to 5000. */
+    pollingInterval?: number;
+    /** Timeout in ms. After this duration, the query will fail. Defaults to 120000 (2 min). */
+    timeout?: number;
+}
+/**
+ * Hook to wait for a Safe transaction to be executed on-chain.
+ *
+ * Unlike standard polling queries, this hook maintains a stable loading state
+ * throughout the polling process (similar to wagmi's useWaitForTransactionReceipt):
+ * - `isLoading` = true while waiting for execution
+ * - `isSuccess` = true once transaction is executed
+ * - `isError` = true if timeout is reached
+ */
+declare function useWaitForExecution(options: UseWaitForExecutionOptions): _tanstack_react_query.UseQueryResult<WaitForExecutionResult, Error>;
+
+interface UseFetchPendingTxsOptions extends FetchPendingOptions {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}
+declare function useFetchPendingTxs(options: UseFetchPendingTxsOptions): _tanstack_react_query.UseQueryResult<unknown[], Error>;
+
+interface UseSimulateOptions extends SimulateOptions {
+    enabled?: boolean;
+}
+declare function useSimulate(options: UseSimulateOptions): _tanstack_react_query.UseQueryResult<unknown, Error>;
+
+declare function useWrite(): _tanstack_react_query.UseMutationResult<string, Error, WriteOptions, unknown>;
+
+export { type UseFetchPendingTxsOptions, type UseSimulateOptions, type UseSubmitTxOptions, type UseWaitForExecutionOptions, useFetchPendingTxs, useSimulate, useSubmitTx, useWaitForExecution, useWrite };

package/dist/react.d.ts

@@ -0,0 +1,43 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { a as SubmitTxOptions, b as SubmitTxResult, W as WaitForExecutionOptions, c as WaitForExecutionResult, F as FetchPendingOptions, S as SimulateOptions, d as WriteOptions } from './types-BJD1jdcY.js';
+import '@wagmi/core';
+import 'viem';
+
+type UseSubmitTxOptions = Omit<SubmitTxOptions, "config"> & {
+    config: SubmitTxOptions["config"];
+};
+declare function useSubmitTx(): _tanstack_react_query.UseMutationResult<SubmitTxResult, Error, UseSubmitTxOptions, unknown>;
+
+interface UseWaitForExecutionOptions extends Omit<WaitForExecutionOptions, "maxAttempts"> {
+    /** Enable/disable the query. Defaults to true. */
+    enabled?: boolean;
+    /** Polling interval in ms. Defaults to 5000. */
+    pollingInterval?: number;
+    /** Timeout in ms. After this duration, the query will fail. Defaults to 120000 (2 min). */
+    timeout?: number;
+}
+/**
+ * Hook to wait for a Safe transaction to be executed on-chain.
+ *
+ * Unlike standard polling queries, this hook maintains a stable loading state
+ * throughout the polling process (similar to wagmi's useWaitForTransactionReceipt):
+ * - `isLoading` = true while waiting for execution
+ * - `isSuccess` = true once transaction is executed
+ * - `isError` = true if timeout is reached
+ */
+declare function useWaitForExecution(options: UseWaitForExecutionOptions): _tanstack_react_query.UseQueryResult<WaitForExecutionResult, Error>;
+
+interface UseFetchPendingTxsOptions extends FetchPendingOptions {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}
+declare function useFetchPendingTxs(options: UseFetchPendingTxsOptions): _tanstack_react_query.UseQueryResult<unknown[], Error>;
+
+interface UseSimulateOptions extends SimulateOptions {
+    enabled?: boolean;
+}
+declare function useSimulate(options: UseSimulateOptions): _tanstack_react_query.UseQueryResult<unknown, Error>;
+
+declare function useWrite(): _tanstack_react_query.UseMutationResult<string, Error, WriteOptions, unknown>;
+
+export { type UseFetchPendingTxsOptions, type UseSimulateOptions, type UseSubmitTxOptions, type UseWaitForExecutionOptions, useFetchPendingTxs, useSimulate, useSubmitTx, useWaitForExecution, useWrite };

package/dist/react.js

@@ -0,0 +1,106 @@
+import {
+  fetchPendingTxs,
+  simulate,
+  submitTx,
+  waitForExecution,
+  write
+} from "./chunk-YQE6NIEB.js";
+
+// src/react/use-submit-tx.ts
+import { useMutation } from "@tanstack/react-query";
+function useSubmitTx() {
+  return useMutation({
+    mutationFn: (options) => submitTx(options)
+  });
+}
+
+// src/react/use-wait-for-execution.ts
+import { useQuery } from "@tanstack/react-query";
+function useWaitForExecution(options) {
+  const {
+    enabled = true,
+    pollingInterval = 5e3,
+    timeout = 12e4,
+    ...waitOptions
+  } = options;
+  const maxAttempts = Math.ceil(timeout / pollingInterval);
+  return useQuery({
+    queryKey: [
+      "adapter",
+      options.adapter,
+      "waitForExecution",
+      options.txHash,
+      options.chainId.toString()
+    ],
+    queryFn: () => waitForExecution({
+      ...waitOptions,
+      pollingInterval,
+      maxAttempts
+    }),
+    enabled: enabled && !!options.txHash,
+    // Don't refetch - the query handles polling internally
+    refetchInterval: false,
+    refetchOnWindowFocus: false,
+    refetchOnMount: false,
+    refetchOnReconnect: false,
+    // Don't retry on error - timeout is intentional
+    retry: false,
+    // Keep data fresh
+    staleTime: Infinity,
+    // Cache result for this specific txHash
+    gcTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+}
+
+// src/react/use-fetch-pending-txs.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useFetchPendingTxs(options) {
+  const { enabled = true, refetchInterval = false, ...fetchOptions } = options;
+  return useQuery2({
+    queryKey: [
+      "adapter",
+      options.adapter,
+      "pendingTxs",
+      options.walletAddress,
+      options.chainId.toString()
+    ],
+    queryFn: () => fetchPendingTxs(fetchOptions),
+    enabled: enabled && !!options.walletAddress,
+    refetchInterval
+  });
+}
+
+// src/react/use-simulate.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+function useSimulate(options) {
+  const { enabled = true, ...simulateOptions } = options;
+  return useQuery3({
+    queryKey: [
+      "adapter",
+      options.adapter,
+      "simulate",
+      options.address,
+      options.functionName,
+      JSON.stringify(options.args)
+    ],
+    queryFn: () => simulate(simulateOptions),
+    enabled
+  });
+}
+
+// src/react/use-write.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function useWrite() {
+  return useMutation2({
+    mutationFn: (options) => write(options)
+  });
+}
+export {
+  useFetchPendingTxs,
+  useSimulate,
+  useSubmitTx,
+  useWaitForExecution,
+  useWrite
+};
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react/use-submit-tx.ts","../src/react/use-wait-for-execution.ts","../src/react/use-fetch-pending-txs.ts","../src/react/use-simulate.ts","../src/react/use-write.ts"],"sourcesContent":["import { useMutation } from \"@tanstack/react-query\";\nimport { submitTx } from \"../adapters/index.js\";\nimport type { SubmitTxOptions, SubmitTxResult } from \"../adapters/types.js\";\n\nexport type UseSubmitTxOptions = Omit<SubmitTxOptions, \"config\"> & {\n  config: SubmitTxOptions[\"config\"];\n};\n\nexport function useSubmitTx() {\n  return useMutation<SubmitTxResult, Error, UseSubmitTxOptions>({\n    mutationFn: (options) => submitTx(options),\n  });\n}\n","import { useQuery } from \"@tanstack/react-query\";\nimport { waitForExecution } from \"../adapters/index.js\";\nimport type { WaitForExecutionOptions, WaitForExecutionResult } from \"../adapters/types.js\";\n\nexport interface UseWaitForExecutionOptions extends Omit<WaitForExecutionOptions, \"maxAttempts\"> {\n  /** Enable/disable the query. Defaults to true. */\n  enabled?: boolean;\n  /** Polling interval in ms. Defaults to 5000. */\n  pollingInterval?: number;\n  /** Timeout in ms. After this duration, the query will fail. Defaults to 120000 (2 min). */\n  timeout?: number;\n}\n\n/**\n * Hook to wait for a Safe transaction to be executed on-chain.\n *\n * Unlike standard polling queries, this hook maintains a stable loading state\n * throughout the polling process (similar to wagmi's useWaitForTransactionReceipt):\n * - `isLoading` = true while waiting for execution\n * - `isSuccess` = true once transaction is executed\n * - `isError` = true if timeout is reached\n */\nexport function useWaitForExecution(options: UseWaitForExecutionOptions) {\n  const {\n    enabled = true,\n    pollingInterval = 5000,\n    timeout = 120000,\n    ...waitOptions\n  } = options;\n\n  // Calculate max attempts from timeout and polling interval\n  const maxAttempts = Math.ceil(timeout / pollingInterval);\n\n  return useQuery<WaitForExecutionResult, Error>({\n    queryKey: [\n      \"adapter\",\n      options.adapter,\n      \"waitForExecution\",\n      options.txHash,\n      options.chainId.toString(),\n    ],\n    queryFn: () =>\n      waitForExecution({\n        ...waitOptions,\n        pollingInterval,\n        maxAttempts,\n      }),\n    enabled: enabled && !!options.txHash,\n    // Don't refetch - the query handles polling internally\n    refetchInterval: false,\n    refetchOnWindowFocus: false,\n    refetchOnMount: false,\n    refetchOnReconnect: false,\n    // Don't retry on error - timeout is intentional\n    retry: false,\n    // Keep data fresh\n    staleTime: Infinity,\n    // Cache result for this specific txHash\n    gcTime: 1000 * 60 * 5, // 5 minutes\n  });\n}\n","import { useQuery } from \"@tanstack/react-query\";\nimport { fetchPendingTxs } from \"../adapters/index.js\";\nimport type { FetchPendingOptions } from \"../adapters/types.js\";\n\nexport interface UseFetchPendingTxsOptions extends FetchPendingOptions {\n  enabled?: boolean;\n  refetchInterval?: number | false;\n}\n\nexport function useFetchPendingTxs(options: UseFetchPendingTxsOptions) {\n  const { enabled = true, refetchInterval = false, ...fetchOptions } = options;\n\n  return useQuery<unknown[], Error>({\n    queryKey: [\n      \"adapter\",\n      options.adapter,\n      \"pendingTxs\",\n      options.walletAddress,\n      options.chainId.toString(),\n    ],\n    queryFn: () => fetchPendingTxs(fetchOptions),\n    enabled: enabled && !!options.walletAddress,\n    refetchInterval,\n  });\n}\n","import { useQuery } from \"@tanstack/react-query\";\nimport { simulate } from \"../adapters/index.js\";\nimport type { SimulateOptions } from \"../adapters/types.js\";\n\nexport interface UseSimulateOptions extends SimulateOptions {\n  enabled?: boolean;\n}\n\nexport function useSimulate(options: UseSimulateOptions) {\n  const { enabled = true, ...simulateOptions } = options;\n\n  return useQuery<unknown, Error>({\n    queryKey: [\n      \"adapter\",\n      options.adapter,\n      \"simulate\",\n      options.address,\n      options.functionName,\n      JSON.stringify(options.args),\n    ],\n    queryFn: () => simulate(simulateOptions),\n    enabled,\n  });\n}\n","import { useMutation } from \"@tanstack/react-query\";\nimport { write } from \"../adapters/index.js\";\nimport type { WriteOptions } from \"../adapters/types.js\";\n\nexport function useWrite() {\n  return useMutation<string, Error, WriteOptions>({\n    mutationFn: (options) => write(options),\n  });\n}\n"],"mappings":";;;;;;;;;AAAA,SAAS,mBAAmB;AAQrB,SAAS,cAAc;AAC5B,SAAO,YAAuD;AAAA,IAC5D,YAAY,CAAC,YAAY,SAAS,OAAO;AAAA,EAC3C,CAAC;AACH;;;ACZA,SAAS,gBAAgB;AAsBlB,SAAS,oBAAoB,SAAqC;AACvE,QAAM;AAAA,IACJ,UAAU;AAAA,IACV,kBAAkB;AAAA,IAClB,UAAU;AAAA,IACV,GAAG;AAAA,EACL,IAAI;AAGJ,QAAM,cAAc,KAAK,KAAK,UAAU,eAAe;AAEvD,SAAO,SAAwC;AAAA,IAC7C,UAAU;AAAA,MACR;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,MACA,QAAQ;AAAA,MACR,QAAQ,QAAQ,SAAS;AAAA,IAC3B;AAAA,IACA,SAAS,MACP,iBAAiB;AAAA,MACf,GAAG;AAAA,MACH;AAAA,MACA;AAAA,IACF,CAAC;AAAA,IACH,SAAS,WAAW,CAAC,CAAC,QAAQ;AAAA;AAAA,IAE9B,iBAAiB;AAAA,IACjB,sBAAsB;AAAA,IACtB,gBAAgB;AAAA,IAChB,oBAAoB;AAAA;AAAA,IAEpB,OAAO;AAAA;AAAA,IAEP,WAAW;AAAA;AAAA,IAEX,QAAQ,MAAO,KAAK;AAAA;AAAA,EACtB,CAAC;AACH;;;AC5DA,SAAS,YAAAA,iBAAgB;AASlB,SAAS,mBAAmB,SAAoC;AACrE,QAAM,EAAE,UAAU,MAAM,kBAAkB,OAAO,GAAG,aAAa,IAAI;AAErE,SAAOC,UAA2B;AAAA,IAChC,UAAU;AAAA,MACR;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,MACA,QAAQ;AAAA,MACR,QAAQ,QAAQ,SAAS;AAAA,IAC3B;AAAA,IACA,SAAS,MAAM,gBAAgB,YAAY;AAAA,IAC3C,SAAS,WAAW,CAAC,CAAC,QAAQ;AAAA,IAC9B;AAAA,EACF,CAAC;AACH;;;ACxBA,SAAS,YAAAC,iBAAgB;AAQlB,SAAS,YAAY,SAA6B;AACvD,QAAM,EAAE,UAAU,MAAM,GAAG,gBAAgB,IAAI;AAE/C,SAAOC,UAAyB;AAAA,IAC9B,UAAU;AAAA,MACR;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,MACA,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,KAAK,UAAU,QAAQ,IAAI;AAAA,IAC7B;AAAA,IACA,SAAS,MAAM,SAAS,eAAe;AAAA,IACvC;AAAA,EACF,CAAC;AACH;;;ACvBA,SAAS,eAAAC,oBAAmB;AAIrB,SAAS,WAAW;AACzB,SAAOC,aAAyC;AAAA,IAC9C,YAAY,CAAC,YAAY,MAAM,OAAO;AAAA,EACxC,CAAC;AACH;","names":["useQuery","useQuery","useQuery","useQuery","useMutation","useMutation"]}

package/dist/types-BJD1jdcY.d.cts

@@ -0,0 +1,64 @@
+import { Config } from '@wagmi/core';
+import { Address, Abi, Hex } from 'viem';
+
+interface ContractCallParams {
+    address: Address;
+    abi: Abi;
+    functionName: string;
+    args?: readonly unknown[];
+    value?: bigint;
+    chainId?: number;
+    account?: Address;
+}
+interface EncodedCallData {
+    to: Address;
+    data: Hex;
+    value: bigint;
+}
+interface TxMatchCriteria {
+    to: Address;
+    value: bigint;
+    data: Hex;
+}
+
+type AdapterType = "safe";
+interface AdapterServiceOptions {
+    txServiceUrl?: string;
+    apiKey?: string;
+}
+interface SubmitTxOptions extends ContractCallParams, AdapterServiceOptions {
+    adapter: AdapterType;
+    walletAddress: Address;
+    config: Config;
+    pollingInterval?: number;
+    maxAttempts?: number;
+}
+interface SubmitTxResult {
+    txHash: string;
+}
+interface WaitForExecutionOptions extends AdapterServiceOptions {
+    adapter: AdapterType;
+    txHash: string;
+    chainId: bigint;
+    pollingInterval?: number;
+    maxAttempts?: number;
+}
+interface WaitForExecutionResult {
+    transactionHash: string;
+}
+interface FetchPendingOptions extends AdapterServiceOptions {
+    adapter: AdapterType;
+    walletAddress: string;
+    chainId: bigint;
+}
+interface SimulateOptions extends ContractCallParams {
+    adapter: AdapterType;
+    config: Config;
+}
+interface WriteOptions {
+    adapter: AdapterType;
+    config: Config;
+    request: unknown;
+}
+
+export type { AdapterServiceOptions as A, ContractCallParams as C, EncodedCallData as E, FetchPendingOptions as F, SimulateOptions as S, TxMatchCriteria as T, WaitForExecutionOptions as W, SubmitTxOptions as a, SubmitTxResult as b, WaitForExecutionResult as c, WriteOptions as d, AdapterType as e };