smart-multisig-engine 0.1.0

package/dist/index.cjs

@@ -0,0 +1,247 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  extractCallData: () => extractCallData,
+  fetchPendingTxs: () => fetchPendingTxs,
+  matchPendingTransaction: () => matchPendingTransaction,
+  safe: () => safe_exports,
+  simulate: () => simulate,
+  submitTx: () => submitTx,
+  waitForExecution: () => waitForExecution2,
+  write: () => write
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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/index.ts
+var safe_exports = {};
+__export(safe_exports, {
+  fetchPendingTransactions: () => fetchPendingTransactions,
+  simulateContractCall: () => simulateContractCall,
+  submitAndFindSafeTx: () => submitAndFindSafeTx,
+  waitForExecution: () => waitForExecution,
+  writeContractCall: () => writeContractCall
+});
+
+// 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/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(", ")}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractCallData,
+  fetchPendingTxs,
+  matchPendingTransaction,
+  safe,
+  simulate,
+  submitTx,
+  waitForExecution,
+  write
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/core/extract-call-data.ts","../src/core/match-pending-tx.ts","../src/adapters/safe/index.ts","../src/adapters/safe/simulate-contract-call.ts","../src/adapters/safe/write-contract-call.ts","../src/adapters/safe/fetch-pending-transactions.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"],"sourcesContent":["export * from \"./core/index.js\";\nexport * from \"./adapters/index.js\";\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","export * from \"./types.js\";\nexport * from \"./simulate-contract-call.js\";\nexport * from \"./write-contract-call.js\";\nexport * from \"./fetch-pending-transactions.js\";\nexport * from \"./submit-and-find-safe-tx.js\";\nexport * from \"./wait-for-execution.js\";\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 { 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"],"mappings":"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","names":["waitForExecution","import_core","SafeApiKit","import_api_kit","delay","SafeApiKit","waitForExecution"]}

package/dist/index.d.cts

@@ -0,0 +1,85 @@
+import { E as EncodedCallData, T as TxMatchCriteria, C as ContractCallParams, F as FetchPendingOptions, S as SimulateOptions, a as SubmitTxOptions, b as SubmitTxResult, W as WaitForExecutionOptions$1, c as WaitForExecutionResult$1, d as WriteOptions } from './types-BJD1jdcY.cjs';
+export { A as AdapterServiceOptions, e as AdapterType } from './types-BJD1jdcY.cjs';
+import * as viem from 'viem';
+import { Abi, Address, Hex } from 'viem';
+import { SafeMultisigTransactionResponse } from '@safe-global/types-kit';
+export { SafeMultisigTransactionResponse } from '@safe-global/types-kit';
+import { Config, writeContract } from '@wagmi/core';
+import * as abitype from 'abitype';
+
+declare function extractCallData(params: {
+    abi: Abi;
+    functionName: string;
+    args?: readonly unknown[];
+    address: Address;
+    value?: bigint;
+}): EncodedCallData;
+
+declare function matchPendingTransaction(pendingTxs: SafeMultisigTransactionResponse[], criteria: TxMatchCriteria): SafeMultisigTransactionResponse | undefined;
+
+interface SafeServiceOptions {
+    txServiceUrl?: string;
+    apiKey?: string;
+}
+interface SubmitAndFindSafeTxOptions extends ContractCallParams, SafeServiceOptions {
+    safeAddress: Address;
+    config: Config;
+    pollingInterval?: number;
+    maxAttempts?: number;
+}
+interface SubmitAndFindSafeTxResult {
+    safeTxHash: string;
+}
+interface WaitForExecutionOptions extends SafeServiceOptions {
+    safeTxHash: string;
+    chainId: bigint;
+    pollingInterval?: number;
+    maxAttempts?: number;
+}
+interface WaitForExecutionResult {
+    transactionHash: string;
+}
+
+declare function simulateContractCall(config: Config, params: ContractCallParams): Promise<viem.SimulateContractReturnType<abitype.Abi, string, unknown[], viem.Chain, viem.Account, viem.Chain> & {
+    chainId: number;
+    request: {
+        chainId: number;
+        chain: viem.Chain;
+    };
+}>;
+
+declare function writeContractCall(config: Config, request: Parameters<typeof writeContract>[1]): Promise<Hex>;
+
+interface FetchPendingTransactionsParams {
+    chainId: bigint;
+    safeAddress: string;
+    txServiceUrl?: string;
+    apiKey?: string;
+}
+declare function fetchPendingTransactions(params: FetchPendingTransactionsParams): Promise<SafeMultisigTransactionResponse[]>;
+
+declare function submitAndFindSafeTx(options: SubmitAndFindSafeTxOptions): Promise<SubmitAndFindSafeTxResult>;
+
+declare function waitForExecution$1(options: WaitForExecutionOptions): Promise<WaitForExecutionResult>;
+
+type index_FetchPendingTransactionsParams = FetchPendingTransactionsParams;
+type index_SafeServiceOptions = SafeServiceOptions;
+type index_SubmitAndFindSafeTxOptions = SubmitAndFindSafeTxOptions;
+type index_SubmitAndFindSafeTxResult = SubmitAndFindSafeTxResult;
+type index_WaitForExecutionOptions = WaitForExecutionOptions;
+type index_WaitForExecutionResult = WaitForExecutionResult;
+declare const index_fetchPendingTransactions: typeof fetchPendingTransactions;
+declare const index_simulateContractCall: typeof simulateContractCall;
+declare const index_submitAndFindSafeTx: typeof submitAndFindSafeTx;
+declare const index_writeContractCall: typeof writeContractCall;
+declare namespace index {
+  export { type index_FetchPendingTransactionsParams as FetchPendingTransactionsParams, type index_SafeServiceOptions as SafeServiceOptions, type index_SubmitAndFindSafeTxOptions as SubmitAndFindSafeTxOptions, type index_SubmitAndFindSafeTxResult as SubmitAndFindSafeTxResult, type index_WaitForExecutionOptions as WaitForExecutionOptions, type index_WaitForExecutionResult as WaitForExecutionResult, index_fetchPendingTransactions as fetchPendingTransactions, index_simulateContractCall as simulateContractCall, index_submitAndFindSafeTx as submitAndFindSafeTx, waitForExecution$1 as waitForExecution, index_writeContractCall as writeContractCall };
+}
+
+declare function submitTx(options: SubmitTxOptions): Promise<SubmitTxResult>;
+declare function waitForExecution(options: WaitForExecutionOptions$1): Promise<WaitForExecutionResult$1>;
+declare function fetchPendingTxs(options: FetchPendingOptions): Promise<unknown[]>;
+declare function simulate(options: SimulateOptions): Promise<unknown>;
+declare function write(options: WriteOptions): Promise<string>;
+
+export { ContractCallParams, EncodedCallData, FetchPendingOptions, SimulateOptions, SubmitTxOptions, SubmitTxResult, TxMatchCriteria, WaitForExecutionOptions$1 as WaitForExecutionOptions, WaitForExecutionResult$1 as WaitForExecutionResult, WriteOptions, extractCallData, fetchPendingTxs, matchPendingTransaction, index as safe, simulate, submitTx, waitForExecution, write };

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+import { E as EncodedCallData, T as TxMatchCriteria, C as ContractCallParams, F as FetchPendingOptions, S as SimulateOptions, a as SubmitTxOptions, b as SubmitTxResult, W as WaitForExecutionOptions$1, c as WaitForExecutionResult$1, d as WriteOptions } from './types-BJD1jdcY.js';
+export { A as AdapterServiceOptions, e as AdapterType } from './types-BJD1jdcY.js';
+import * as viem from 'viem';
+import { Abi, Address, Hex } from 'viem';
+import { SafeMultisigTransactionResponse } from '@safe-global/types-kit';
+export { SafeMultisigTransactionResponse } from '@safe-global/types-kit';
+import { Config, writeContract } from '@wagmi/core';
+import * as abitype from 'abitype';
+
+declare function extractCallData(params: {
+    abi: Abi;
+    functionName: string;
+    args?: readonly unknown[];
+    address: Address;
+    value?: bigint;
+}): EncodedCallData;
+
+declare function matchPendingTransaction(pendingTxs: SafeMultisigTransactionResponse[], criteria: TxMatchCriteria): SafeMultisigTransactionResponse | undefined;
+
+interface SafeServiceOptions {
+    txServiceUrl?: string;
+    apiKey?: string;
+}
+interface SubmitAndFindSafeTxOptions extends ContractCallParams, SafeServiceOptions {
+    safeAddress: Address;
+    config: Config;
+    pollingInterval?: number;
+    maxAttempts?: number;
+}
+interface SubmitAndFindSafeTxResult {
+    safeTxHash: string;
+}
+interface WaitForExecutionOptions extends SafeServiceOptions {
+    safeTxHash: string;
+    chainId: bigint;
+    pollingInterval?: number;
+    maxAttempts?: number;
+}
+interface WaitForExecutionResult {
+    transactionHash: string;
+}
+
+declare function simulateContractCall(config: Config, params: ContractCallParams): Promise<viem.SimulateContractReturnType<abitype.Abi, string, unknown[], viem.Chain, viem.Account, viem.Chain> & {
+    chainId: number;
+    request: {
+        chainId: number;
+        chain: viem.Chain;
+    };
+}>;
+
+declare function writeContractCall(config: Config, request: Parameters<typeof writeContract>[1]): Promise<Hex>;
+
+interface FetchPendingTransactionsParams {
+    chainId: bigint;
+    safeAddress: string;
+    txServiceUrl?: string;
+    apiKey?: string;
+}
+declare function fetchPendingTransactions(params: FetchPendingTransactionsParams): Promise<SafeMultisigTransactionResponse[]>;
+
+declare function submitAndFindSafeTx(options: SubmitAndFindSafeTxOptions): Promise<SubmitAndFindSafeTxResult>;
+
+declare function waitForExecution$1(options: WaitForExecutionOptions): Promise<WaitForExecutionResult>;
+
+type index_FetchPendingTransactionsParams = FetchPendingTransactionsParams;
+type index_SafeServiceOptions = SafeServiceOptions;
+type index_SubmitAndFindSafeTxOptions = SubmitAndFindSafeTxOptions;
+type index_SubmitAndFindSafeTxResult = SubmitAndFindSafeTxResult;
+type index_WaitForExecutionOptions = WaitForExecutionOptions;
+type index_WaitForExecutionResult = WaitForExecutionResult;
+declare const index_fetchPendingTransactions: typeof fetchPendingTransactions;
+declare const index_simulateContractCall: typeof simulateContractCall;
+declare const index_submitAndFindSafeTx: typeof submitAndFindSafeTx;
+declare const index_writeContractCall: typeof writeContractCall;
+declare namespace index {
+  export { type index_FetchPendingTransactionsParams as FetchPendingTransactionsParams, type index_SafeServiceOptions as SafeServiceOptions, type index_SubmitAndFindSafeTxOptions as SubmitAndFindSafeTxOptions, type index_SubmitAndFindSafeTxResult as SubmitAndFindSafeTxResult, type index_WaitForExecutionOptions as WaitForExecutionOptions, type index_WaitForExecutionResult as WaitForExecutionResult, index_fetchPendingTransactions as fetchPendingTransactions, index_simulateContractCall as simulateContractCall, index_submitAndFindSafeTx as submitAndFindSafeTx, waitForExecution$1 as waitForExecution, index_writeContractCall as writeContractCall };
+}
+
+declare function submitTx(options: SubmitTxOptions): Promise<SubmitTxResult>;
+declare function waitForExecution(options: WaitForExecutionOptions$1): Promise<WaitForExecutionResult$1>;
+declare function fetchPendingTxs(options: FetchPendingOptions): Promise<unknown[]>;
+declare function simulate(options: SimulateOptions): Promise<unknown>;
+declare function write(options: WriteOptions): Promise<string>;
+
+export { ContractCallParams, EncodedCallData, FetchPendingOptions, SimulateOptions, SubmitTxOptions, SubmitTxResult, TxMatchCriteria, WaitForExecutionOptions$1 as WaitForExecutionOptions, WaitForExecutionResult$1 as WaitForExecutionResult, WriteOptions, extractCallData, fetchPendingTxs, matchPendingTransaction, index as safe, simulate, submitTx, waitForExecution, write };

package/dist/index.js

@@ -0,0 +1,21 @@
+import {
+  extractCallData,
+  fetchPendingTxs,
+  matchPendingTransaction,
+  safe_exports,
+  simulate,
+  submitTx,
+  waitForExecution,
+  write
+} from "./chunk-YQE6NIEB.js";
+export {
+  extractCallData,
+  fetchPendingTxs,
+  matchPendingTransaction,
+  safe_exports as safe,
+  simulate,
+  submitTx,
+  waitForExecution,
+  write
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}