smart-multisig-engine 0.1.0

package/README.md

@@ -0,0 +1,409 @@
+# smart-multisig-engine
+
+A TypeScript utility library for submitting transactions to Safe multisig wallets and retrieving their `safeTxHash` from the Safe Transaction Service.
+
+Built on [wagmi](https://wagmi.sh) and [viem](https://viem.sh).
+
+## Install
+
+```bash
+pnpm add smart-multisig-engine
+```
+
+Peer dependencies: `@wagmi/core`, `viem`.
+
+## Quick Start
+
+Use `submitTx` with the generic adapter interface to submit transactions to any supported multisig:
+
+```typescript
+import { submitTx, waitForExecution } from "smart-multisig-engine";
+import { config } from "./wagmi-config";
+
+// Submit a transaction
+const { txHash } = await submitTx({
+  adapter: "safe",
+  config,
+  walletAddress: "0xYourSafeAddress",
+  address: "0xTargetContract",
+  abi: contractAbi,
+  functionName: "transfer",
+  args: [recipientAddress, amount],
+  value: 0n,
+  chainId: 1n,
+});
+
+console.log("Safe TX Hash:", txHash);
+
+// Wait for execution
+const { transactionHash } = await waitForExecution({
+  adapter: "safe",
+  txHash,
+  chainId: 1n,
+});
+
+console.log("On-chain TX Hash:", transactionHash);
+```
+
+Or use the Safe adapter directly for more control:
+
+```typescript
+import { safe } from "smart-multisig-engine";
+import { config } from "./wagmi-config";
+
+const { safeTxHash, txHash } = await safe.submitAndFindSafeTx({
+  config,
+  safeAddress: "0xYourSafeAddress",
+  address: "0xTargetContract",
+  abi: contractAbi,
+  functionName: "transfer",
+  args: [recipientAddress, amount],
+  value: 0n,
+  chainId: 1,
+});
+
+console.log("Safe TX Hash:", safeTxHash);
+console.log("On-chain TX Hash:", txHash);
+```
+
+## Architecture
+
+The library follows a **core/adapter** pattern:
+
+- **Core** — Pure functions with no I/O. Can be used independently for encoding, matching, or URL resolution.
+- **Adapters** — I/O implementations that wrap contract calls and external APIs. Currently supports Safe multisig.
+
+### Generic Adapter Interface
+
+The library provides adapter-agnostic entry points that route to the appropriate implementation:
+
+```typescript
+import { submitTx, waitForExecution, fetchPendingTxs, simulate, write } from "smart-multisig-engine";
+
+// All functions take an `adapter` parameter to select the implementation
+await submitTx({ adapter: "safe", ... });
+await waitForExecution({ adapter: "safe", ... });
+await fetchPendingTxs({ adapter: "safe", ... });
+await simulate({ adapter: "safe", ... });
+await write({ adapter: "safe", ... });
+```
+
+### Direct Adapter Access
+
+For adapter-specific features, import the adapter namespace directly:
+
+```typescript
+import { safe } from "smart-multisig-engine";
+
+// Access Safe-specific functions
+await safe.submitAndFindSafeTx({ ... });
+await safe.waitForExecution({ ... });
+await safe.fetchPendingTransactions({ ... });
+await safe.simulateContractCall(config, { ... });
+await safe.writeContractCall(config, request);
+```
+
+## API Reference
+
+### Generic Adapter Functions
+
+These functions provide a unified interface across all adapters.
+
+#### `submitTx(options): Promise<SubmitTxResult>`
+
+Submit a transaction through the specified adapter.
+
+```typescript
+interface SubmitTxOptions {
+  adapter: "safe";             // Adapter type
+  config: Config;              // wagmi Config instance
+  walletAddress: Address;      // The multisig wallet address
+  address: Address;            // Target contract address
+  abi: Abi;                    // Contract ABI
+  functionName: string;        // Function to call
+  args?: readonly unknown[];   // Function arguments
+  value?: bigint;              // ETH value (default: 0n)
+  chainId?: number;            // Chain ID
+  txServiceUrl?: string;       // Override service URL
+  apiKey?: string;             // API key for the service
+  pollingInterval?: number;    // Polling interval in ms
+  maxAttempts?: number;        // Max poll attempts
+}
+
+interface SubmitTxResult {
+  txHash: string;              // The transaction hash (safeTxHash for Safe)
+}
+```
+
+#### `waitForExecution(options): Promise<WaitForExecutionResult>`
+
+Wait for a transaction to be executed on-chain.
+
+```typescript
+interface WaitForExecutionOptions {
+  adapter: "safe";             // Adapter type
+  txHash: string;              // Transaction hash to wait for
+  chainId: bigint;             // Chain ID
+  txServiceUrl?: string;       // Override service URL
+  apiKey?: string;             // API key for the service
+  pollingInterval?: number;    // Polling interval in ms (default: 5000)
+  maxAttempts?: number;        // Max poll attempts (default: 60)
+}
+
+interface WaitForExecutionResult {
+  transactionHash: string;     // The on-chain transaction hash
+}
+```
+
+#### `fetchPendingTxs(options): Promise<unknown[]>`
+
+Fetch pending transactions for a wallet.
+
+```typescript
+interface FetchPendingOptions {
+  adapter: "safe";             // Adapter type
+  walletAddress: string;       // The multisig wallet address
+  chainId: bigint;             // Chain ID
+  txServiceUrl?: string;       // Override service URL
+  apiKey?: string;             // API key for the service
+}
+```
+
+#### `simulate(options): Promise<unknown>`
+
+Simulate a contract call before submission.
+
+```typescript
+interface SimulateOptions {
+  adapter: "safe";             // Adapter type
+  config: Config;              // wagmi Config instance
+  address: Address;            // Target contract address
+  abi: Abi;                    // Contract ABI
+  functionName: string;        // Function to call
+  args?: readonly unknown[];   // Function arguments
+  value?: bigint;              // ETH value
+  chainId?: number;            // Chain ID
+}
+```
+
+#### `write(options): Promise<string>`
+
+Write a contract call (submit the transaction).
+
+```typescript
+interface WriteOptions {
+  adapter: "safe";             // Adapter type
+  config: Config;              // wagmi Config instance
+  request: unknown;            // Request from simulation result
+}
+```
+
+---
+
+### Safe Adapter
+
+#### `safe.submitAndFindSafeTx(options): Promise<SubmitAndFindSafeTxResult>`
+
+Full flow: simulate → write → poll Safe TX Service → match → return `safeTxHash`.
+
+```typescript
+interface SubmitAndFindSafeTxOptions {
+  config: Config;              // wagmi Config instance
+  safeAddress: Address;        // The Safe wallet address to poll
+  address: Address;            // Target contract address
+  abi: Abi;                    // Contract ABI
+  functionName: string;        // Function to call
+  args?: readonly unknown[];   // Function arguments
+  value?: bigint;              // ETH value (default: 0n)
+  chainId?: number;            // Chain ID (auto-detected from config if omitted)
+  account?: Address;           // Signer address
+  serviceUrl?: string;         // Override Safe TX Service URL
+  pollingInterval?: number;    // Polling interval in ms (default: 3000)
+  maxAttempts?: number;        // Max poll attempts (default: 20)
+}
+
+interface SubmitAndFindSafeTxResult {
+  safeTxHash: string;          // The Safe transaction hash
+  txHash: `0x${string}`;       // The on-chain transaction hash
+}
+```
+
+#### `safe.waitForExecution(options): Promise<WaitForExecutionResult>`
+
+Poll the Safe Transaction Service until a transaction is executed.
+
+```typescript
+interface WaitForExecutionOptions {
+  safeTxHash: string;          // The Safe transaction hash to monitor
+  chainId: bigint;             // Chain ID
+  txServiceUrl?: string;       // Override Safe TX Service URL
+  apiKey?: string;             // API key for the Safe service
+  pollingInterval?: number;    // Polling interval in ms (default: 5000)
+  maxAttempts?: number;        // Max poll attempts (default: 60)
+}
+
+interface WaitForExecutionResult {
+  transactionHash: string;     // The on-chain transaction hash
+}
+```
+
+---
+
+### Core Utilities
+
+#### `extractCallData(params): EncodedCallData`
+
+Encodes a contract function call into `{ to, data, value }` using viem's `encodeFunctionData`. Pure function, no network calls.
+
+```typescript
+import { extractCallData } from "smart-multisig-engine";
+
+const callData = extractCallData({
+  abi: myAbi,
+  functionName: "transfer",
+  args: [recipient, amount],
+  address: "0xContractAddress",
+  value: 0n,
+});
+// { to: "0x...", data: "0x...", value: 0n }
+```
+
+#### `matchPendingTransaction(pendingTxs, criteria): SafePendingTransaction | undefined`
+
+Finds a pending Safe transaction matching `{ to, value, data }`. Comparison is case-insensitive for addresses and converts `bigint` value to string for matching.
+
+```typescript
+import { matchPendingTransaction } from "smart-multisig-engine";
+
+const match = matchPendingTransaction(pendingTransactions, {
+  to: "0xContractAddress",
+  value: 0n,
+  data: "0xEncodedCalldata",
+});
+```
+
+#### `getSafeServiceUrl(chainId): string`
+
+Resolves the Safe Transaction Service base URL for a chain ID. Throws if the chain is not in the known list.
+
+```typescript
+import { getSafeServiceUrl } from "smart-multisig-engine";
+
+getSafeServiceUrl(1);        // "https://safe-transaction-mainnet.safe.global"
+getSafeServiceUrl(11155111); // "https://safe-transaction-sepolia.safe.global"
+```
+
+#### `SAFE_TX_SERVICE_URLS`
+
+The `Record<number, string>` map of supported chain IDs:
+
+| Chain ID | Network |
+|----------|---------|
+| 1 | Ethereum Mainnet |
+| 10 | Optimism |
+| 56 | BSC |
+| 100 | Gnosis Chain |
+| 137 | Polygon |
+| 8453 | Base |
+| 42161 | Arbitrum |
+| 11155111 | Sepolia |
+| 84532 | Base Sepolia |
+
+---
+
+### Safe Low-Level Utilities
+
+#### `safe.simulateContractCall(config, params)`
+
+Wraps wagmi's `simulateContract`. Validates the transaction will succeed before submission.
+
+```typescript
+import { safe } from "smart-multisig-engine";
+
+const simulation = await safe.simulateContractCall(config, {
+  address: "0xContract",
+  abi: myAbi,
+  functionName: "transfer",
+  args: [recipient, amount],
+});
+```
+
+#### `safe.writeContractCall(config, request): Promise<Hex>`
+
+Wraps wagmi's `writeContract`. Accepts the `request` from a prior simulation result.
+
+```typescript
+import { safe } from "smart-multisig-engine";
+
+const txHash = await safe.writeContractCall(config, simulation.request);
+```
+
+#### `safe.fetchPendingTransactions(options): Promise<SafePendingTransaction[]>`
+
+Fetches pending (unexecuted) multisig transactions from the Safe Transaction Service REST API.
+
+```typescript
+import { safe } from "smart-multisig-engine";
+
+const pending = await safe.fetchPendingTransactions({
+  safeAddress: "0xSafeAddress",
+  chainId: 1n,
+  apiKey: "optional-api-key",
+});
+```
+
+---
+
+## Using Individual Bricks
+
+The high-level functions are convenience wrappers. You can compose the bricks yourself for custom flows:
+
+```typescript
+import {
+  extractCallData,
+  matchPendingTransaction,
+  safe,
+} from "smart-multisig-engine";
+
+// 1. Encode the call data
+const callData = extractCallData({ abi, functionName, args, address, value });
+
+// 2. Simulate
+const simulation = await safe.simulateContractCall(config, { abi, functionName, args, address, value });
+
+// 3. Submit on-chain
+const txHash = await safe.writeContractCall(config, simulation.request);
+
+// 4. Poll for the pending Safe transaction
+const pending = await safe.fetchPendingTransactions({
+  safeAddress,
+  chainId: 1n,
+});
+
+// 5. Match
+const match = matchPendingTransaction(pending, callData);
+console.log(match?.safeTxHash);
+
+// 6. Wait for execution
+const result = await safe.waitForExecution({
+  safeTxHash: match.safeTxHash,
+  chainId: 1n,
+});
+console.log("Executed:", result.transactionHash);
+```
+
+## Development
+
+```bash
+pnpm install
+pnpm build        # Bundle with tsup (ESM + CJS + .d.ts)
+pnpm dev          # Watch mode
+pnpm test         # Run vitest (watch mode)
+pnpm test --run   # Run tests once
+pnpm typecheck    # tsc --noEmit
+pnpm clean        # Remove dist/
+```
+
+## License
+
+ISC

package/dist/chunk-YQE6NIEB.js

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/extract-call-data.ts
+import { encodeFunctionData } from "viem";
+function extractCallData(params) {
+  const data = 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
+import { simulateContract } from "@wagmi/core";
+async function simulateContractCall(config, params) {
+  return 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
+import { writeContract } from "@wagmi/core";
+async function writeContractCall(config, request) {
+  return writeContract(config, request);
+}
+
+// src/adapters/safe/fetch-pending-transactions.ts
+import SafeApiKit from "@safe-global/api-kit";
+async function fetchPendingTransactions(params) {
+  const apiKit = new SafeApiKit({
+    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
+import SafeApiKit2 from "@safe-global/api-kit";
+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 SafeApiKit2({
+    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(", ")}`);
+  }
+}
+
+export {
+  extractCallData,
+  matchPendingTransaction,
+  safe_exports,
+  submitTx,
+  waitForExecution2 as waitForExecution,
+  fetchPendingTxs,
+  simulate,
+  write
+};
+//# sourceMappingURL=chunk-YQE6NIEB.js.map

package/dist/chunk-YQE6NIEB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../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":["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":["SafeApiKit","delay","waitForExecution"]}