@quip.network/quip-swap-sdk 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,3136 @@
+import { Address, Hex, PublicClient, Abi, BlockNumber, BlockTag, Log, Hash, TransactionReceipt, WalletClient } from 'viem';
+
+/**
+ * Core protocol types mirroring `src/TermsLib.sol` and
+ * `src/interfaces/IOmnibus.sol` exactly.
+ *
+ * Every Solidity integer (`uint256`, token ids, amounts, chain ids,
+ * timestamps, fees) is represented as `bigint` — never `number` — because
+ * `uint256` exceeds `Number.MAX_SAFE_INTEGER`.
+ */
+
+/**
+ * The type of asset in a swap leg.
+ *
+ * Mirrors the Solidity `enum AssetType` (encoded as `uint8` in the ABI).
+ * The numeric values MUST match the Solidity declaration order — they are
+ * part of the terms digest, so a mismatch breaks hash agreement with the
+ * contract.
+ *
+ * @see TermsLib (enum AssetType)
+ */
+declare enum AssetType {
+    /** Native chain currency (ETH on mainnet, etc.). */
+    Native = 0,
+    /** An ERC-20 fungible token. */
+    ERC20 = 1,
+    /** An ERC-721 non-fungible token (one specific token id). */
+    ERC721 = 2,
+    /** An ERC-1155 semi-fungible token (a quantity of one token id). */
+    ERC1155 = 3
+}
+/**
+ * Lifecycle state of a hashlock in the Omnibus contract.
+ *
+ * Mirrors the Solidity `enum LockState`. Valid transitions (enforced
+ * on-chain by `Omnibus._advanceLockTo`):
+ *
+ * ```text
+ * Unused -> Free        (first same-chain commit)
+ * Unused -> Committed   (cross-chain local commit)
+ * Free   -> Committed   (second same-chain commit, other side)
+ * Free   -> Spent       (reclaim of a half-committed same-chain swap)
+ * Committed -> Spent    (claim or reclaim)
+ * ```
+ *
+ * @see IOmnibus (enum LockState), Omnibus._advanceLockTo
+ */
+declare enum LockState {
+    /** Default — the lock has never been used. */
+    Unused = 0,
+    /** Same-chain only: one party has committed, waiting for the counterparty. */
+    Free = 1,
+    /** Ready for claim (same-chain: both committed; cross-chain: the single local commit). */
+    Committed = 2,
+    /** Terminal — claimed or reclaimed. */
+    Spent = 3
+}
+/**
+ * An asset to be transferred as part of a swap.
+ *
+ * Mirrors the Solidity `struct Asset` field-for-field. All four fields are
+ * part of the terms digest, so canonical field values matter: two assets
+ * that move the same tokens but differ in any field produce different
+ * digests and therefore different swaps.
+ *
+ * @see TermsLib (struct Asset)
+ */
+interface Asset {
+    /** The kind of asset; encoded as `uint8` in the ABI. */
+    readonly assetType: AssetType;
+    /** Token contract address; MUST be the zero address for {@link AssetType.Native}. */
+    readonly target: Address;
+    /**
+     * Token id; used by ERC-721 and ERC-1155 and MUST be `0n` for Native and
+     * ERC-20 (the contract rejects a non-zero id for ERC-20 with
+     * `InvalidERC20Asset`). Token id `0n` is explicitly VALID for ERC-721 and
+     * ERC-1155.
+     */
+    readonly id: bigint;
+    /**
+     * Quantity in the token's base units (wei for native). MUST be greater
+     * than zero for every asset type — including ERC-721, where the SDK
+     * canonicalizes the value to `1n` (see {@link erc721Asset}).
+     */
+    readonly amount: bigint;
+}
+/**
+ * The terms for a single party (one "leg") of an Omnibus swap.
+ *
+ * Mirrors the Solidity `struct Terms` field-for-field. A swap consists of
+ * two `Terms` whose lifecycle timestamps strictly interleave (see
+ * {@link validateTermPairing}); the side with the earlier
+ * `commitmentDeadline` is the PROPOSER and commits first.
+ *
+ * @see TermsLib (struct Terms)
+ */
+interface Terms {
+    /**
+     * The chain id where THIS side's assets are held and escrowed. The two
+     * sides may name different chains (cross-chain swap) or the same chain
+     * (same-chain swap). Must be non-zero.
+     */
+    readonly chainId: bigint;
+    /**
+     * The address that receives this side's own assets back if the swap is
+     * reclaimed instead of claimed. Must be non-zero.
+     */
+    readonly reclaimRecipient: Address;
+    /**
+     * The address that receives the COUNTERPARTY's assets when the swap is
+     * claimed — not this side's own assets. Must be non-zero.
+     */
+    readonly recipient: Address;
+    /**
+     * Unix timestamp (seconds) at and after which this side may no longer
+     * commit. Also the instant the counterparty-taker's commit window opens
+     * when this side proposes. Must be non-zero.
+     */
+    readonly commitmentDeadline: bigint;
+    /**
+     * Unix timestamp (seconds) at and after which claiming gated by this
+     * side's claim schedule is forbidden. Must be strictly greater than
+     * `commitmentDeadline`.
+     */
+    readonly claimDeadline: bigint;
+    /**
+     * Unix timestamp (seconds) at and after which this side's escrowed assets
+     * may be reclaimed to `reclaimRecipient`. Must be strictly greater than
+     * `claimDeadline`.
+     */
+    readonly reclaimRelease: bigint;
+    /** The assets this side escrows. Must be non-empty and each asset valid. */
+    readonly assets: readonly Asset[];
+}
+/** A 32-byte hex value (`0x` + 64 hex chars), e.g. a secret, lock, or digest. */
+type Hex32 = Hex;
+/**
+ * A freshly generated hashlock pair.
+ *
+ * Secrecy lifecycle:
+ * - `lock` may be shared freely — it is published on-chain at commit time.
+ * - `secret` MUST remain private until the holder claims; the `Claim` event
+ *   reveals it publicly.
+ * - Revealing the secret early lets anyone in the proposer-claim window
+ *   claim, compromising a cross-chain flow.
+ * - Losing the secret makes claiming impossible; the assets can then only
+ *   be recovered via reclaim after `reclaimRelease`.
+ */
+interface SecretLockPair {
+    /** The 32-byte preimage. Keep private until claim. */
+    readonly secret: Hex32;
+    /** `keccak256(secret)` — safe to share. */
+    readonly lock: Hex32;
+}
+
+/**
+ * Stable machine-readable SDK error codes.
+ *
+ * Codes prefixed with contract semantics (e.g. `CONTRACT_REVERT`) wrap an
+ * on-chain revert; the rest are produced by SDK-side preflight validation
+ * BEFORE any transaction is sent. SDK validation mirrors but never replaces
+ * contract enforcement.
+ */
+type QuipSwapErrorCode = 'ZERO_AMOUNT' | 'INVALID_NATIVE_ASSET' | 'INVALID_ERC20_ASSET' | 'INVALID_ERC721_ASSET' | 'INVALID_ERC1155_ASSET' | 'INVALID_ASSET_TYPE' | 'EMPTY_ASSETS' | 'ZERO_ADDRESS_RECIPIENT' | 'ZERO_DEADLINE' | 'DISORDERED_DEADLINES' | 'ZERO_CHAIN_ID' | 'INVALID_RANGE' | 'WINDOW_VIOLATED' | 'INVALID_HEX32' | 'CHAIN_ID_MISMATCH' | 'NOT_QUIP_WALLET' | 'MISSING_WALLET_CLIENT' | 'MISSING_ACCOUNT' | 'TERMS_NOT_ON_CHAIN' | 'INVALID_LOCK_STATE' | 'TERMS_ALREADY_POSTED' | 'GAS_ESTIMATION_FAILED' | 'BALANCE_TOO_LOW' | 'SECRET_HOLDER_NOT_PROPOSER' | 'INSUFFICIENT_BUFFER' | 'UNKNOWN_DEPLOYMENT' | 'TRANSACTION_REVERTED' | 'EVENT_NOT_FOUND' | 'CONTRACT_REVERT';
+/**
+ * Structured details carried by every {@link QuipSwapError}.
+ */
+interface QuipSwapErrorDetails {
+    /** Stable machine-readable code; safe to branch on. */
+    readonly code: QuipSwapErrorCode;
+    /** Human-readable explanation with remediation guidance. */
+    readonly message: string;
+    /**
+     * The decoded Solidity custom-error name (e.g. `CallerNotQuipWallet`,
+     * `WindowViolated`) when the error wraps an on-chain revert and the error
+     * was decodable from the Omnibus ABI.
+     */
+    readonly contractErrorName?: string;
+    /** The original underlying error (e.g. the Viem error), never discarded. */
+    readonly cause?: unknown;
+    /** Additional structured context (offending values, window bounds, ...). */
+    readonly details?: unknown;
+}
+/**
+ * The error class thrown by every SDK function.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await client.commit({lock, party, counterparty})
+ * } catch (err) {
+ *   if (err instanceof QuipSwapError && err.code === 'CONTRACT_REVERT') {
+ *     // a contract revert; err.contractErrorName names the Solidity error
+ *     // (e.g. 'IncorrectNativeAmountReceived', 'CallerNotQuipWallet')
+ *   }
+ * }
+ * ```
+ */
+declare class QuipSwapError extends Error implements QuipSwapErrorDetails {
+    readonly name = "QuipSwapError";
+    readonly code: QuipSwapErrorCode;
+    readonly contractErrorName?: string;
+    readonly cause?: unknown;
+    readonly details?: unknown;
+    constructor(args: QuipSwapErrorDetails);
+}
+/**
+ * Extracts the decoded Solidity custom-error name from a Viem error, if any.
+ *
+ * Viem decodes custom errors against the contract ABI during
+ * `simulateContract` / `readContract`; this helper walks the error chain
+ * (structured decoding — no parsing of human-readable strings) and returns
+ * e.g. `"CallerNotQuipWallet"` or `"WindowViolated"`.
+ *
+ * @param error - Any error thrown by a Viem contract action.
+ * @returns The custom error name, or `undefined` when the revert could not
+ *   be decoded (e.g. an out-of-ABI token error with no registered ABI).
+ */
+declare function extractContractErrorName(error: unknown): string | undefined;
+/**
+ * Wraps an error thrown by a Viem contract action into a
+ * {@link QuipSwapError} with code `CONTRACT_REVERT`, preserving the original
+ * error in `cause` and the decoded custom-error name (when available) in
+ * `contractErrorName`.
+ *
+ * @param error - The original error thrown by Viem.
+ * @param context - Short description of the operation that failed.
+ * @returns A `QuipSwapError` wrapping the original error.
+ */
+declare function wrapContractError(error: unknown, context: string): QuipSwapError;
+
+/**
+ * Builds a native-currency asset (ETH or the chain's equivalent).
+ *
+ * Canonical fields enforced — mirrors the contract's native-asset rule:
+ * `target` must be the zero address and `id` must be `0`, otherwise the
+ * contract reverts with `InvalidNativeAsset`.
+ *
+ * @param amount - Amount of native currency in wei; must be `> 0n`.
+ * @returns A canonical, frozen `Asset` with `assetType: Native`.
+ * @throws QuipSwapError `ZERO_AMOUNT` if `amount` is zero or negative.
+ * @see TermsLib.validateAsset
+ * @example
+ * ```ts
+ * const oneEth = nativeAsset(10n ** 18n)
+ * ```
+ */
+declare function nativeAsset(amount: bigint): Asset;
+/**
+ * Builds an ERC-20 asset.
+ *
+ * The id is fixed at `0n`: the contract REJECTS a non-zero id for ERC-20
+ * with `InvalidERC20Asset` (the id field is meaningless for fungible
+ * tokens but is still hashed into the terms digest).
+ *
+ * @param target - The ERC-20 token contract address; must be non-zero.
+ * @param amount - Token amount in the token's base units; must be `> 0n`.
+ * @returns A canonical, frozen `Asset` with `assetType: ERC20` and `id: 0n`.
+ * @throws QuipSwapError `INVALID_ERC20_ASSET` if `target` is the zero address
+ *   or not a valid address; `ZERO_AMOUNT` if `amount <= 0n`.
+ * @see TermsLib.validateAsset
+ * @example
+ * ```ts
+ * const usdc = erc20Asset('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1_000_000n)
+ * ```
+ */
+declare function erc20Asset(target: Address, amount: bigint): Asset;
+/**
+ * Builds an ERC-721 asset for one specific NFT.
+ *
+ * Token id `0n` is explicitly VALID — do not pre-filter it out; the
+ * contract permits id 0 for ERC-721 (see the comment in
+ * `TermsLib.validateAsset`).
+ *
+ * SDK-STRICTER-THAN-CONTRACT: the amount is canonicalized to `1n`. The
+ * contract only enforces `amount != 0`, but the amount is hashed into the
+ * terms digest while the transfer always moves exactly the one NFT
+ * identified by `tokenId` — so two different amounts would yield two
+ * different digests describing the same effective transfer. Canonicalizing
+ * to `1n` (matching the repository's `AssetHelper.makeERC721`) prevents
+ * that ambiguity. Validation of externally supplied assets
+ * ({@link validateAsset}) follows the contract and accepts any non-zero
+ * amount.
+ *
+ * @param target - The ERC-721 token contract address; must be non-zero.
+ * @param tokenId - The NFT's token id; `0n` is valid.
+ * @returns A canonical, frozen `Asset` with `assetType: ERC721` and `amount: 1n`.
+ * @throws QuipSwapError `INVALID_ERC721_ASSET` if `target` is the zero
+ *   address or not a valid address.
+ * @see TermsLib.validateAsset
+ * @example
+ * ```ts
+ * const punk = erc721Asset('0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB', 42n)
+ * // punk.amount === 1n always
+ * ```
+ */
+declare function erc721Asset(target: Address, tokenId: bigint): Asset;
+/**
+ * Builds an ERC-1155 asset (a quantity of one token id).
+ *
+ * Token id `0n` is explicitly VALID, mirroring the contract.
+ *
+ * @param target - The ERC-1155 token contract address; must be non-zero.
+ * @param tokenId - The token id; `0n` is valid.
+ * @param amount - Quantity of the token id; must be `> 0n`.
+ * @returns A canonical, frozen `Asset` with `assetType: ERC1155`.
+ * @throws QuipSwapError `INVALID_ERC1155_ASSET` if `target` is invalid;
+ *   `ZERO_AMOUNT` if `amount <= 0n`.
+ * @see TermsLib.validateAsset
+ * @example
+ * ```ts
+ * const gameItems = erc1155Asset('0x495f947276749Ce646f68AC8c248420045cb7b5e', 7n, 25n)
+ * ```
+ */
+declare function erc1155Asset(target: Address, tokenId: bigint, amount: bigint): Asset;
+/**
+ * Validates an asset object received from an untrusted source (JSON, an
+ * API, a database, another application).
+ *
+ * This is a faithful transcription of `TermsLib.validateAsset`:
+ *
+ * ```solidity
+ * if (asset.amount == 0) revert ZeroAmount();
+ * if (isNative && (!isZeroTarget || !isZeroId)) revert InvalidNativeAsset();
+ * if (isERC20 && (isZeroTarget || !isZeroId)) revert InvalidERC20Asset();
+ * // ERC721/ERC1155 token id 0 is valid; only a zero target is rejected
+ * if (isERC721 && isZeroTarget) revert InvalidERC721Asset();
+ * if (isERC1155 && isZeroTarget) revert InvalidERC1155Asset();
+ * ```
+ *
+ * Unlike {@link erc721Asset}, this accepts any non-zero ERC-721 amount,
+ * matching the contract exactly (validation must not be stricter than the
+ * contract for objects that may already exist in committed terms).
+ *
+ * @param asset - The asset to validate.
+ * @throws QuipSwapError `ZERO_AMOUNT` | `INVALID_NATIVE_ASSET` |
+ *   `INVALID_ERC20_ASSET` | `INVALID_ERC721_ASSET` | `INVALID_ERC1155_ASSET`
+ *   | `INVALID_ASSET_TYPE`, each naming the matching contract error.
+ * @see TermsLib.validateAsset
+ * @example
+ * ```ts
+ * validateAsset(JSON.parse(payload, bigintReviver)) // throws on bad input
+ * ```
+ */
+declare function validateAsset(asset: Asset): void;
+/**
+ * Sums the native amounts in a side's terms — the amount of wei the
+ * committer must escrow (before the commitment fee).
+ *
+ * Transcribes `TermsLib.totalNative`: only assets with
+ * `assetType === Native` contribute; all other types are ignored.
+ *
+ * The exact commit transaction value is
+ * `totalNative(party) + commitmentFee`, checked by the contract for strict
+ * equality (`IncorrectNativeAmountReceived`) — see
+ * {@link OmnibusClient.commit}, which re-reads the fee immediately before
+ * simulating.
+ *
+ * @param terms - The side's terms (only `assets` is read).
+ * @returns The sum of all native-asset amounts in wei (`0n` when none).
+ * @see TermsLib.totalNative
+ * @example
+ * ```ts
+ * totalNative({...terms, assets: [nativeAsset(5n), erc20Asset(token, 100n)]}) // 5n
+ * ```
+ */
+declare function totalNative(terms: Pick<Terms, 'assets'>): bigint;
+
+/** Input shape for {@link createTerms}; identical to {@link Terms}. */
+interface CreateTermsArgs {
+    /** Chain id where this side's assets live; must be `> 0n`. */
+    readonly chainId: bigint;
+    /** Receives this side's own assets on reclaim; non-zero. */
+    readonly reclaimRecipient: Address;
+    /** Receives the COUNTERPARTY's assets on claim; non-zero. */
+    readonly recipient: Address;
+    /** Unix seconds; commitment forbidden at/after this instant; non-zero. */
+    readonly commitmentDeadline: bigint;
+    /** Unix seconds; strictly after `commitmentDeadline`. */
+    readonly claimDeadline: bigint;
+    /** Unix seconds; strictly after `claimDeadline`. */
+    readonly reclaimRelease: bigint;
+    /** Non-empty list of structurally valid assets. */
+    readonly assets: readonly Asset[];
+}
+/**
+ * Builds and validates a {@link Terms} object.
+ *
+ * The returned object is frozen (including a defensive copy of the asset
+ * array) so later mutation of caller-supplied inputs cannot desynchronize a
+ * digest already shared with a counterparty.
+ *
+ * @param args - The seven Terms fields; see {@link CreateTermsArgs} for
+ *   units and constraints.
+ * @returns A frozen, structurally valid `Terms`.
+ * @throws QuipSwapError - every code listed on {@link validateTerms}.
+ * @see TermsLib.validateTerms
+ * @example
+ * ```ts
+ * const terms = createTerms({
+ *   chainId: 8453n,
+ *   reclaimRecipient: wallet,
+ *   recipient: wallet,
+ *   commitmentDeadline: now + 600n,
+ *   claimDeadline: now + 1800n,
+ *   reclaimRelease: now + 3600n,
+ *   assets: [nativeAsset(10n ** 18n)],
+ * })
+ * ```
+ */
+declare function createTerms(args: CreateTermsArgs): Terms;
+/**
+ * Structurally validates one side's terms.
+ *
+ * Exact transcription of `TermsLib.validateTerms`:
+ *
+ * ```solidity
+ * if (terms.assets.length == 0) revert EmptyAssets();
+ * if (reclaimRecipient == 0 || recipient == 0) revert ZeroAddressRecipient();
+ * if (terms.commitmentDeadline == 0) revert ZeroDeadline();
+ * if (!(commitmentDeadline < claimDeadline && claimDeadline < reclaimRelease))
+ *   revert DisordedDeadlines();
+ * enforceNonZeroChainId(terms); validateAssets(terms);
+ * ```
+ *
+ * Deliberately does NOT check that deadlines are in the future: freshness
+ * is enforced per-action by the half-open windows
+ * (see {@link validateCommitWindow}). The taker legitimately commits AFTER
+ * the proposer's commitment deadline has elapsed — `Omnibus.commit`
+ * validates BOTH sides' terms, so a freshness check here would wrongly
+ * reject the proposer's already-elapsed deadline during the taker's commit.
+ *
+ * @param terms - The terms to validate (e.g. parsed from JSON or an API).
+ * @throws QuipSwapError `EMPTY_ASSETS` | `ZERO_ADDRESS_RECIPIENT` |
+ *   `ZERO_DEADLINE` | `DISORDERED_DEADLINES` | `ZERO_CHAIN_ID`, plus every
+ *   asset-level code from {@link validateAsset}.
+ * @see TermsLib.validateTerms
+ * @example
+ * ```ts
+ * validateTerms(termsFromCounterparty) // throws before any tx is built
+ * ```
+ */
+declare function validateTerms(terms: Terms): void;
+/**
+ * Validates that two sides' lifecycle timestamps strictly interleave.
+ *
+ * Exact transcription of `TermsLib.validateTermPairing`. Exactly one of
+ * the two chains must hold (every comparison strict — equal timestamps
+ * anywhere are rejected):
+ *
+ * ```text
+ * A proposes: A.commitmentDeadline < B.commitmentDeadline < A.claimDeadline
+ *               < B.claimDeadline < A.reclaimRelease < B.reclaimRelease
+ * B proposes: the same chain with A and B swapped
+ * ```
+ *
+ * The proposer is the side with the smaller `commitmentDeadline` and
+ * commits first. The interleaving is what bounds each side's risk — in a
+ * cross-chain swap it guarantees the taker a reaction buffer after the
+ * secret is revealed (see {@link validateCrossChainSchedule}).
+ *
+ * @param a - One side's terms.
+ * @param b - The other side's terms.
+ * @throws QuipSwapError `DISORDERED_DEADLINES` when neither interleaving
+ *   holds (contract: DisordedDeadlines).
+ * @see TermsLib.validateTermPairing
+ * @example
+ * ```ts
+ * validateTermPairing(aliceTerms, bobTerms) // throws if the schedule is invalid
+ * ```
+ */
+declare function validateTermPairing(a: Terms, b: Terms): void;
+/**
+ * Identifies which side of a pairing proposed.
+ *
+ * Transcribes `TermsLib.proposedByParty`: the proposer is the side with
+ * the smaller `commitmentDeadline` (it commits first). Only meaningful
+ * after {@link validateTermPairing} has passed, which guarantees the
+ * commitment deadlines are strictly ordered and never equal.
+ *
+ * @param party - The first side's terms.
+ * @param counterparty - The second side's terms.
+ * @returns `'party'` if `party` proposed, `'counterparty'` otherwise.
+ * @see TermsLib.proposedByParty
+ * @example
+ * ```ts
+ * if (proposedBy(mine, theirs) === 'party') {
+ *   // I commit first, in [0, mine.commitmentDeadline)
+ * }
+ * ```
+ */
+declare function proposedBy(party: Terms, counterparty: Terms): 'party' | 'counterparty';
+
+/** `type(uint256).max` — the open upper bound of the reclaim window. */
+declare const MAX_UINT256: bigint;
+/**
+ * A half-open time window `[lower, upper)` in Unix seconds.
+ */
+interface TimeWindow {
+    /** Inclusive lower bound (Unix seconds). */
+    readonly lower: bigint;
+    /** EXCLUSIVE upper bound (Unix seconds); `MAX_UINT256` means unbounded. */
+    readonly upper: bigint;
+}
+/**
+ * Asserts `timestamp` lies within the half-open window `[lower, upper)`.
+ *
+ * Exact transcription of `TermsLib.enforceWithin`:
+ *
+ * ```solidity
+ * if (lower >= upper) revert InvalidRange();
+ * if (lower > timestamp || upper <= timestamp) revert WindowViolated();
+ * ```
+ *
+ * The upper bound is EXCLUSIVE: `timestamp === upper` is rejected.
+ *
+ * @param lower - Inclusive lower bound (Unix seconds).
+ * @param upper - Exclusive upper bound (Unix seconds).
+ * @param timestamp - The instant to test (pass the chain's `block.timestamp`).
+ * @throws QuipSwapError `INVALID_RANGE` when `lower >= upper` (degenerate
+ *   window — contract: InvalidRange); `WINDOW_VIOLATED` when the timestamp
+ *   is before `lower` or at/after `upper` (contract: WindowViolated).
+ * @see TermsLib.enforceWithin
+ * @example
+ * ```ts
+ * enforceWithin(0n, 1000n, 999n)  // ok
+ * enforceWithin(0n, 1000n, 1000n) // throws WINDOW_VIOLATED (upper exclusive)
+ * ```
+ */
+declare function enforceWithin(lower: bigint, upper: bigint, timestamp: bigint): void;
+/**
+ * Non-throwing variant of {@link enforceWithin}.
+ *
+ * @param window - The half-open window to test.
+ * @param timestamp - The instant to test (Unix seconds).
+ * @returns `true` iff `window.lower <= timestamp < window.upper` and the
+ *   window is non-degenerate.
+ */
+declare function isWithinWindow(window: TimeWindow, timestamp: bigint): boolean;
+/**
+ * The proposer's commit window: `[0, proposer.commitmentDeadline)`.
+ *
+ * Enforced by `Omnibus.commit` via
+ * `enforceWithin(0, party.commitmentDeadline, block.timestamp)` on the
+ * proposer path.
+ *
+ * @param proposer - The proposer's terms (the side with the earlier `commitmentDeadline`).
+ * @returns The half-open commit window for the proposer.
+ * @see Omnibus.commit
+ */
+declare function proposerCommitWindow(proposer: Terms): TimeWindow;
+/**
+ * The taker's commit window:
+ * `[proposer.commitmentDeadline, taker.commitmentDeadline)`.
+ *
+ * The taker can only commit AFTER the proposer's commitment deadline has
+ * elapsed — enforced by `Omnibus.commit` via
+ * `enforceWithin(counterparty.commitmentDeadline, party.commitmentDeadline, block.timestamp)`.
+ * A taker commit attempted while the proposer's window is still open
+ * reverts with `WindowViolated`.
+ *
+ * @param taker - The taker's terms.
+ * @param proposer - The proposer's terms.
+ * @returns The half-open commit window for the taker.
+ * @see Omnibus.commit
+ */
+declare function takerCommitWindow(taker: Terms, proposer: Terms): TimeWindow;
+/**
+ * The proposer's claim window:
+ * `[taker.commitmentDeadline, proposer.claimDeadline)`.
+ *
+ * Enforced by `Omnibus.claim` when the claimant role is the proposer:
+ * `enforceWithin(counterparty.commitmentDeadline, party.claimDeadline, block.timestamp)`.
+ *
+ * @param proposer - The proposer's terms.
+ * @param taker - The taker's terms.
+ * @returns The half-open claim window for the proposer (secret holder).
+ * @see Omnibus.claim
+ */
+declare function proposerClaimWindow(proposer: Terms, taker: Terms): TimeWindow;
+/**
+ * The taker's claim window:
+ * `[proposer.claimDeadline, proposer.reclaimRelease)`.
+ *
+ * Enforced by `Omnibus.claim` when the claimant role is the taker:
+ * `enforceWithin(counterparty.claimDeadline, counterparty.reclaimRelease, block.timestamp)`
+ * (the counterparty is the proposer on this path). The width of this
+ * window, `proposer.reclaimRelease - proposer.claimDeadline`, is the
+ * taker's post-reveal reaction buffer in a cross-chain swap.
+ *
+ * @param proposer - The proposer's terms (the claim is gated on the PROPOSER's schedule).
+ * @returns The half-open claim window for the taker.
+ * @see Omnibus.claim
+ */
+declare function takerClaimWindow(proposer: Terms): TimeWindow;
+/**
+ * The reclaim window for one leg: `[leg.reclaimRelease, +infinity)`.
+ *
+ * Enforced by `Omnibus.reclaim` via
+ * `enforceWithin(party.reclaimRelease, type(uint256).max, block.timestamp)`.
+ * Reclaim never closes once open.
+ *
+ * @param leg - The terms of the leg being reclaimed.
+ * @returns The half-open reclaim window (upper bound `MAX_UINT256`).
+ * @see Omnibus.reclaim
+ */
+declare function reclaimWindow(leg: Terms): TimeWindow;
+/**
+ * Validates that `currentTimestamp` lies inside the commit window for the
+ * role `party` plays in the pairing — exactly the check `Omnibus.commit`
+ * performs:
+ *
+ * - `party` is the proposer: `[0, party.commitmentDeadline)`
+ * - `party` is the taker: `[counterparty.commitmentDeadline, party.commitmentDeadline)`
+ *
+ * @param party - The committing side's terms.
+ * @param counterparty - The other side's terms.
+ * @param currentTimestamp - The chain's current `block.timestamp` (Unix
+ *   seconds) — pass an explicit value; this helper never reads a clock.
+ * @throws QuipSwapError `WINDOW_VIOLATED` | `INVALID_RANGE` as in
+ *   {@link enforceWithin}.
+ * @see Omnibus.commit
+ * @example
+ * ```ts
+ * const block = await publicClient.getBlock()
+ * validateCommitWindow(myTerms, theirTerms, block.timestamp)
+ * ```
+ */
+declare function validateCommitWindow(party: Terms, counterparty: Terms, currentTimestamp: bigint): void;
+/**
+ * Validates that `currentTimestamp` lies inside the claim window for the
+ * role `party` plays — exactly the check `Omnibus.claim` performs:
+ *
+ * - `party` is the proposer: `[counterparty.commitmentDeadline, party.claimDeadline)`
+ * - `party` is the taker: `[counterparty.claimDeadline, counterparty.reclaimRelease)`
+ *
+ * @param party - The claimant role's terms (the side the claimant acts for).
+ * @param counterparty - The other side's terms (the leg being claimed).
+ * @param currentTimestamp - The chain's current `block.timestamp` (Unix seconds).
+ * @throws QuipSwapError `WINDOW_VIOLATED` | `INVALID_RANGE` as in
+ *   {@link enforceWithin}.
+ * @see Omnibus.claim
+ */
+declare function validateClaimWindow(party: Terms, counterparty: Terms, currentTimestamp: bigint): void;
+/**
+ * Validates that `currentTimestamp` has reached the reclaim window of the
+ * leg being reclaimed — exactly the check `Omnibus.reclaim` performs:
+ * `[party.reclaimRelease, type(uint256).max)`.
+ *
+ * @param party - The terms of the leg being reclaimed.
+ * @param currentTimestamp - The chain's current `block.timestamp` (Unix seconds).
+ * @throws QuipSwapError `WINDOW_VIOLATED` when the release has not elapsed.
+ * @see Omnibus.reclaim
+ */
+declare function validateReclaimWindow(party: Terms, currentTimestamp: bigint): void;
+
+/**
+ * The ABI parameter description of the `Asset[]` array — the SINGLE source
+ * of truth for the Asset tuple shape in the SDK. `assetType` is a Solidity
+ * enum, encoded as `uint8` in the ABI.
+ *
+ * @see TermsLib (struct Asset)
+ */
+declare const assetArrayAbiParameter: {
+    readonly name: "assets";
+    readonly type: "tuple[]";
+    readonly components: readonly [{
+        readonly name: "assetType";
+        readonly type: "uint8";
+    }, {
+        readonly name: "target";
+        readonly type: "address";
+    }, {
+        readonly name: "id";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+};
+/**
+ * The ABI parameter description of the full `Terms` tuple — the SINGLE
+ * source of truth for the Terms shape. Used to decode the `Commitment`
+ * event's `party` field back into a typed {@link Terms}.
+ *
+ * Note: {@link digestTerms} does NOT use this tuple — the contract hashes
+ * `abi.encode(field1, ..., field7)` (seven separate top-level values), not
+ * `abi.encode(struct)`; for a single dynamic struct argument those two
+ * encodings differ by a leading offset word.
+ *
+ * @see TermsLib (struct Terms), IOmnibus.Commitment
+ */
+declare const termsAbiParameter: {
+    readonly name: "terms";
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly name: "chainId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "reclaimRecipient";
+        readonly type: "address";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "commitmentDeadline";
+        readonly type: "uint256";
+    }, {
+        readonly name: "claimDeadline";
+        readonly type: "uint256";
+    }, {
+        readonly name: "reclaimRelease";
+        readonly type: "uint256";
+    }, {
+        readonly name: "assets";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "assetType";
+            readonly type: "uint8";
+        }, {
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly name: "id";
+            readonly type: "uint256";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+    }];
+};
+/**
+ * Computes the digest of a single side's terms.
+ *
+ * Exact transcription of `TermsLib.digestTerms`:
+ *
+ * ```solidity
+ * digest = EfficientHashLib.hash(            // keccak256(bytes)
+ *   abi.encode(
+ *     terms.chainId, terms.reclaimRecipient, terms.recipient,
+ *     terms.commitmentDeadline, terms.claimDeadline, terms.reclaimRelease,
+ *     terms.assets
+ *   )
+ * );
+ * ```
+ *
+ * Standard (head/tail) ABI encoding of SEVEN top-level values — not packed
+ * encoding, and not the encoding of a single `Terms` struct. The asset
+ * order matters: reordering assets changes the digest.
+ *
+ * @param terms - The side's terms.
+ * @returns The 32-byte digest used for `posted` tracking and canonical ordering.
+ * @see TermsLib.digestTerms
+ * @example
+ * ```ts
+ * const digest = digestTerms(aliceTerms)
+ * const isPosted = await client.posted(lock, digest)
+ * ```
+ */
+declare function digestTerms(terms: Terms): Hex32;
+/**
+ * Computes the canonical digest of a terms pair, identical regardless of
+ * which side is passed first.
+ *
+ * Exact transcription of `TermsLib.digestTermsCanonically`:
+ * 1. Digest each side independently with {@link digestTerms}.
+ * 2. Compare the two digests as unsigned 256-bit integers — NOT as strings
+ *    (string comparison is locale/casing-sensitive and does not match
+ *    Solidity's `uint256(a) < uint256(b)`).
+ * 3. Concatenate the raw 32-byte values, smaller digest first.
+ * 4. keccak256 the 64-byte concatenation (matching
+ *    `EfficientHashLib.hash(bytes32, bytes32)`).
+ *
+ * This is the value stored in `Omnibus.termsHash[lock]`; both chains of a
+ * cross-chain swap must derive it identically.
+ *
+ * @param party - One side's terms (order does not matter).
+ * @param counterparty - The other side's terms.
+ * @returns The canonical 32-byte digest of the pair.
+ * @see TermsLib.digestTermsCanonically
+ * @example
+ * ```ts
+ * digestTermsCanonically(a, b) === digestTermsCanonically(b, a) // always true
+ * ```
+ */
+declare function digestTermsCanonically(party: Terms, counterparty: Terms): Hex32;
+/**
+ * Derives the hashlock from a secret.
+ *
+ * Exact transcription of `Omnibus._generateLock`: keccak256 over the raw
+ * 32-byte secret (matching `EfficientHashLib.hash(bytes32)` — no length
+ * prefix, no ABI encoding).
+ *
+ * @param secret - A 32-byte hex preimage (`0x` + 64 hex chars). Validated
+ *   before hashing — externally supplied secrets of the wrong length would
+ *   otherwise silently produce a lock that can never be claimed.
+ * @returns The 32-byte lock, `keccak256(secret)`.
+ * @throws QuipSwapError `INVALID_HEX32` if `secret` is not exactly 32 bytes
+ *   of valid hex.
+ * @see Omnibus._generateLock
+ * @example
+ * ```ts
+ * const lock = generateLock('0x' + '11'.repeat(32) as Hex32)
+ * ```
+ */
+declare function generateLock(secret: Hex32): Hex32;
+/**
+ * Asserts a value is exactly 32 bytes of valid hex (`0x` + 64 hex chars).
+ *
+ * @param value - The value to check.
+ * @param label - Name used in the error message (e.g. `"secret"`, `"lock"`).
+ * @throws QuipSwapError `INVALID_HEX32` when malformed or the wrong length.
+ */
+declare function assertHex32(value: string, label: string): asserts value is Hex32;
+
+/**
+ * Generates a fresh 32-byte secret and its lock.
+ *
+ * Uses `crypto.getRandomValues` (the runtime's CSPRNG — available in
+ * browsers, Node.js >= 19, and Bun). Never uses `Math.random()`,
+ * timestamps, counters, or any other predictable source: a guessable
+ * secret lets an attacker claim the counterparty's escrowed assets.
+ *
+ * @returns A {@link SecretLockPair} where `lock === generateLock(secret)`.
+ *   Keep `secret` private until claim; `lock` is safe to share.
+ * @see Omnibus._generateLock
+ * @example
+ * ```ts
+ * const {secret, lock} = generateSecret()
+ * // share `lock` with the counterparty; keep `secret` private
+ * ```
+ */
+declare function generateSecret(): SecretLockPair;
+/**
+ * Validates an externally supplied secret and derives its lock.
+ *
+ * Use this instead of {@link generateLock} when the secret comes from
+ * storage or another process and you want the validated pair back.
+ *
+ * @param secret - A 0x-prefixed 32-byte hex string.
+ * @returns The validated {@link SecretLockPair}.
+ * @throws QuipSwapError `INVALID_HEX32` if the secret is malformed or not
+ *   exactly 32 bytes (the error never echoes the supplied value).
+ * @example
+ * ```ts
+ * const pair = secretToPair(loadSecretFromVault())
+ * ```
+ */
+declare function secretToPair(secret: string): SecretLockPair;
+
+/** A verified Omnibus deployment on one chain. */
+interface OmnibusDeployment {
+    /** The chain id the deployment lives on. */
+    readonly chainId: bigint;
+    /** The Omnibus singleton address on that chain. */
+    readonly omnibusAddress: Address;
+}
+/**
+ * The canonical CREATE3 Omnibus address, sourced from `address.json`.
+ *
+ * CREATE3 (via the canonical Deployer contract) derives the address from
+ * (Deployer contract, salt) — both chain-independent — so a single Omnibus
+ * deployed via `script/DeployOmnibus.s.sol` has the SAME address on every
+ * chain.
+ *
+ * ⚠️ Currently the zero PLACEHOLDER (`address.json`). To activate: set
+ * `omnibusAddress` in `address.json` to the real deployed address, run
+ * `make verify-omnibus` (offline: confirms it matches the predicted
+ * (Deployer, salt) address), confirm on-chain that the correct Omnibus sits
+ * there for each target chain (CREATE3 addresses ignore init code, so
+ * semantic verification is mandatory), and add those chain ids to `chains`.
+ * No code change required.
+ */
+declare const OMNIBUS_CREATE3_ADDRESS: Address;
+/**
+ * Built-in verified deployments, keyed by chain id. Derived from
+ * {@link OMNIBUS_CREATE3_ADDRESS} + {@link VERIFIED_DEPLOYMENT_CHAINS} so
+ * there is a single source of truth. EMPTY until the placeholder address is
+ * replaced and chains are enabled (identical behavior to the prior empty
+ * registry while empty).
+ */
+declare const knownDeployments: ReadonlyMap<bigint, OmnibusDeployment>;
+/**
+ * Resolves the Omnibus address for a chain.
+ *
+ * Resolution order: an explicit `override` wins; otherwise the built-in
+ * {@link knownDeployments} registry is consulted.
+ *
+ * @param chainId - The target chain id.
+ * @param override - Optional application-supplied deployment for this chain.
+ * @returns The resolved deployment.
+ * @throws QuipSwapError `UNKNOWN_DEPLOYMENT` when no verified deployment
+ *   exists and no override was provided, or when the override is malformed
+ *   or names a different chain.
+ * @example
+ * ```ts
+ * const {omnibusAddress} = resolveDeployment(8453n, {
+ *   chainId: 8453n,
+ *   omnibusAddress: '0x...', // your verified deployment
+ * })
+ * ```
+ */
+declare function resolveDeployment(chainId: bigint, override?: OmnibusDeployment): OmnibusDeployment;
+
+/** Default gas-limit safety multiplier: a 20% margin over the node's estimate. */
+declare const DEFAULT_GAS_MULTIPLIER = 1.2;
+/** Multiplier floor; anything below 1.0 risks out-of-gas by construction. */
+declare const MIN_GAS_MULTIPLIER = 1;
+/** Multiplier ceiling; caps the damage of a misconfigured value. */
+declare const MAX_GAS_MULTIPLIER = 2;
+/**
+ * Per-transaction options accepted by every write method (`commit`,
+ * `claim`, `reclaim`, and all `admin.*` writes). All fields optional;
+ * everything unset falls back to viem's automatic behavior.
+ */
+interface TxOptions {
+    /**
+     * Explicit gas limit. When set, THREE things are skipped: (a) gas
+     * estimation, (b) the safety multiplier, and (c) the pre-submission
+     * revert check — because `estimateContractGas` is also what catches a
+     * would-be revert before broadcast, and it does not run. The protocol
+     * preflights still run, but a call that would revert is signed and
+     * broadcast anyway and burns its gas. Use an explicit `gas` only when the
+     * call is known to succeed (e.g. replaying a previously simulated call)
+     * and you accept on-chain revert risk; leave `gas` unset to keep the
+     * revert check, and use {@link TxOptions.gasMultiplier} if you only want
+     * to tune the buffer.
+     */
+    readonly gas?: bigint;
+    /**
+     * Gas-limit safety multiplier: `gas = floor(estimate * multiplier)`,
+     * computed with bigint-safe 3-decimal math (never a bigint×float
+     * multiplication). Defaults to {@link DEFAULT_GAS_MULTIPLIER}; clamped
+     * to [{@link MIN_GAS_MULTIPLIER}, {@link MAX_GAS_MULTIPLIER}];
+     * non-finite values fall back to the MIN (no buffer).
+     */
+    readonly gasMultiplier?: number;
+    /** EIP-1559 total fee ceiling per gas, in wei (exclusive with `gasPrice`). */
+    readonly maxFeePerGas?: bigint;
+    /** EIP-1559 priority tip per gas, in wei (exclusive with `gasPrice`). */
+    readonly maxPriorityFeePerGas?: bigint;
+    /** Legacy gas price, in wei, for non-EIP-1559 chains (exclusive with the two fields above). */
+    readonly gasPrice?: bigint;
+    /** Pin the transaction nonce; by default viem fetches the next nonce. */
+    readonly nonce?: number;
+    /**
+     * Skips the stage-1 BALANCE preflight ONLY (the bare-call-value check
+     * that runs before gas estimation; see {@link preflightBalanceCheck}).
+     * The protocol preflights (windows, pairing, chain id, lock state) ALWAYS
+     * run — they are correctness checks, not robustness checks.
+     */
+    readonly skipPreflightChecks?: boolean;
+}
+/**
+ * Resolves the effective gas multiplier from {@link TxOptions}.
+ *
+ * Rules (deterministic, inspectable by tests and callers):
+ * - unset → {@link DEFAULT_GAS_MULTIPLIER}
+ * - non-finite (`NaN`, `±Infinity`) → {@link MIN_GAS_MULTIPLIER} (no buffer)
+ * - otherwise clamped into [{@link MIN_GAS_MULTIPLIER}, {@link MAX_GAS_MULTIPLIER}]
+ *
+ * @param opts - The caller's transaction options (only `gasMultiplier` is read).
+ * @returns The clamped multiplier that {@link applyGasMultiplier} will use.
+ */
+declare function resolveGasMultiplier(opts?: TxOptions): number;
+/**
+ * Applies the resolved safety multiplier to a gas estimate.
+ *
+ * Bigint-safe and deterministic: the multiplier is rounded to exactly
+ * 3 decimal places by integer scaling — a bigint is never multiplied by a
+ * float, so large estimates cannot pick up float round-trip drift:
+ *
+ * ```ts
+ * const scaled = Math.round(multiplier * 1000)
+ * gas = (estimate * BigInt(scaled)) / 1000n
+ * ```
+ *
+ * @param estimate - The node's gas estimate (from `estimateContractGas`).
+ * @param opts - Transaction options; see {@link resolveGasMultiplier}.
+ * @returns The buffered gas limit, `floor(estimate * multiplier)`.
+ */
+declare function applyGasMultiplier(estimate: bigint, opts?: TxOptions): bigint;
+/**
+ * The fee fields forwarded to `writeContract` — containing ONLY the fields
+ * the caller explicitly set, so viem's automatic fee pricing keeps working
+ * for everything unset. `undefined` fee fields are never passed through.
+ */
+interface FeeOverrides {
+    readonly maxFeePerGas?: bigint;
+    readonly maxPriorityFeePerGas?: bigint;
+    readonly gasPrice?: bigint;
+}
+/**
+ * Builds the {@link FeeOverrides} object from caller options.
+ *
+ * @param opts - Transaction options.
+ * @returns An object with only the explicitly-set fee fields present.
+ */
+declare function buildFeeOverrides(opts?: TxOptions): FeeOverrides;
+/** The contract call being prepared (the exact params `estimateContractGas` receives). */
+interface PrepareTxContractParams {
+    readonly address: Address;
+    readonly abi: Abi;
+    readonly functionName: string;
+    readonly args?: readonly unknown[];
+    /** Native value attached to the call (payable functions only). */
+    readonly value?: bigint;
+    /** The sender address — estimation and the balance preflight both use it. */
+    readonly account: Address;
+}
+/** Arguments for {@link prepareTx}. */
+interface PrepareTxArgs {
+    readonly publicClient: PublicClient;
+    readonly contractParams: PrepareTxContractParams;
+    /**
+     * The total native value the sender must pay for the call itself, in wei
+     * — for commit exactly `totalNative(party) + commitmentFee`; `0n` for
+     * claim/reclaim/admin. The balance preflight checks this bare value only
+     * (gas funding is deliberately not preflighted — see
+     * {@link preflightBalanceCheck}); value-less calls skip the check.
+     */
+    readonly totalValue: bigint;
+    readonly opts?: TxOptions;
+}
+/** The prepared transaction fields, ready to spread into `writeContract`. */
+interface PreparedTx {
+    /** The gas limit to submit with (buffered unless `opts.gas` was set). */
+    readonly gas: bigint;
+    /** Only the caller's explicitly-set fee fields (see {@link FeeOverrides}). */
+    readonly fees: FeeOverrides;
+    /** Present only when the caller pinned a nonce. */
+    readonly nonce?: number;
+}
+/**
+ * Throws `BALANCE_TOO_LOW` if the account's balance is below `required`.
+ *
+ * No-op when `required <= 0n` — value-less calls (claim/reclaim/admin)
+ * have no balance preflight; their send-time funds failures are mapped to
+ * `BALANCE_TOO_LOW` in `submitWrite` (see client.ts). Only the bare call
+ * value is checked: gas funding is deliberately NOT preflighted (it is the
+ * wallet application's concern in the WalletConnect flow).
+ *
+ * @param publicClient - The Viem public client to read the balance through.
+ * @param account - The sender whose balance is checked.
+ * @param required - The native value (wei) the call itself must carry.
+ * @throws QuipSwapError `BALANCE_TOO_LOW` (with `{required, balance}` in
+ *   details) when the balance cannot cover `required`.
+ */
+declare function preflightBalanceCheck(publicClient: PublicClient, account: Address, required: bigint): Promise<void>;
+/**
+ * Prepares a write: balance preflight, then gas estimation (or an explicit
+ * limit) with the safety multiplier.
+ *
+ * Stage order:
+ * 1. **Balance preflight** (unless `opts.skipPreflightChecks`) — BEFORE
+ *    estimation, bare `totalValue` only ({@link preflightBalanceCheck}).
+ *    Running it first fixes a masking bug by construction: any sender
+ *    reaching estimation already covers the value, and viem attaches no
+ *    gas price to `eth_estimateGas`, so the node cannot fail estimation on
+ *    funds — insufficient funds can no longer masquerade as
+ *    `GAS_ESTIMATION_FAILED`.
+ * 2. **Gas** — explicit `opts.gas` is used verbatim (no estimation, no
+ *    multiplier, and therefore NO pre-submission revert check). Otherwise
+ *    `publicClient.estimateContractGas` runs the call node-side, so a
+ *    contract revert surfaces HERE, decoded into a
+ *    `CONTRACT_REVERT` error with `contractErrorName` — this stage is the
+ *    pre-submission revert check that replaced `simulateContract` — and
+ *    the estimate is buffered by {@link applyGasMultiplier}.
+ *
+ * @param args - See {@link PrepareTxArgs}.
+ * @returns The {@link PreparedTx} to spread into `writeContract`.
+ * @throws QuipSwapError `BALANCE_TOO_LOW` (with `{required, balance}` in
+ *   details) when the sender cannot cover the call value;
+ *   `CONTRACT_REVERT` (with `contractErrorName`) when the call would
+ *   revert; `GAS_ESTIMATION_FAILED` when estimation fails for a non-revert
+ *   reason (network error, bad params).
+ * @example
+ * ```ts
+ * const prepared = await prepareTx({publicClient, contractParams, totalValue: 0n, opts})
+ * await walletClient.writeContract({...contractParams, gas: prepared.gas, ...prepared.fees})
+ * ```
+ */
+declare function prepareTx(args: PrepareTxArgs): Promise<PreparedTx>;
+
+/** A decoded `Commitment` event. */
+interface CommitmentEvent {
+    /** The hashlock the commitment is bound to (indexed topic). */
+    readonly lock: Hex32;
+    /** The committing side's FULL terms, recovered from event data. */
+    readonly party: Terms;
+    /** The QuipWallet that committed (indexed topic). */
+    readonly committer: Address;
+    /** Block number the log was found in (`null` for pending logs). */
+    readonly blockNumber: bigint | null;
+    /** Transaction hash the log was found in (`null` for pending logs). */
+    readonly transactionHash: Hex32 | null;
+    /** Log index within the block (`null` for pending logs). */
+    readonly logIndex: number | null;
+}
+/** A decoded `Claim` event. The `secret` field is public once emitted. */
+interface ClaimEvent {
+    /** The address that called `claim` (event data, NOT the asset recipient per se). */
+    readonly recipient: Address;
+    /** The hashlock that was claimed (indexed topic — the only filterable field). */
+    readonly lock: Hex32;
+    /** The revealed 32-byte preimage. Public from this moment on. */
+    readonly secret: Hex32;
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: Hex32 | null;
+    readonly logIndex: number | null;
+}
+/** A decoded `Reclaimed` event. Two may appear in a single transaction. */
+interface ReclaimedEvent {
+    /** The address that called `reclaim` (permissionless — any account). */
+    readonly caller: Address;
+    /** The hashlock that was reclaimed (indexed topic). */
+    readonly lock: Hex32;
+    /** The `reclaimRecipient` that received this leg's assets (indexed topic). */
+    readonly recipient: Address;
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: Hex32 | null;
+    readonly logIndex: number | null;
+}
+/**
+ * Decodes every `Commitment` event in a list of logs (e.g. from a receipt
+ * or `getLogs`), recovering the committing side's full typed {@link Terms}
+ * from event data — this is how a coordinator reconstructs a side's terms
+ * from chain history without an off-chain channel.
+ *
+ * Non-`Commitment` logs are skipped, not errors.
+ *
+ * NOTE: a raw ABI decoder — it does NOT verify `log.address`, so it decodes
+ * any `Commitment`-shaped log in `logs`. Scope `logs` to the known Omnibus
+ * deployment first (prefer `client.waitForReceipt` /
+ * `waitForOmnibusReceipt(..., {address})`, or the address-scoped
+ * {@link getCommitmentEvents}).
+ *
+ * @param logs - Pre-scoped logs (a receipt's `logs` array or a `getLogs` result).
+ * @returns All decoded `Commitment` events, in log order.
+ * @see IOmnibus.Commitment
+ * @example
+ * ```ts
+ * // PREFERRED: client.waitForReceipt scopes decoding to the Omnibus address
+ * const {commitments} = await client.waitForReceipt(hash)
+ * commitments[0]?.party.assets // typed Asset[]
+ *
+ * // low-level: only on logs ALREADY scoped to the Omnibus address
+ * const scoped = receipt.logs.filter(l => l.address.toLowerCase() === omnibus.toLowerCase())
+ * const [commitment] = decodeCommitmentEvents(scoped)
+ * ```
+ */
+declare function decodeCommitmentEvents(logs: readonly Log[]): CommitmentEvent[];
+/**
+ * Decodes every `Claim` event in a list of logs.
+ *
+ * The `secret` field is the revealed preimage: in a cross-chain swap this
+ * is how the taker (or a relayer) learns the secret after the proposer
+ * claims — watch the counterparty chain for `Claim` on the shared lock and
+ * extract `secret`.
+ *
+ * NOTE: This helper does NOT filter by Omnibus contract address — it decodes
+ * any log in `logs` whose shape matches the `Claim` ABI. Callers passing
+ * unscoped logs (e.g. a full receipt or a broad `getLogs` result) may pick up
+ * unrelated contracts. {@link extractRevealedSecret} inherits this behavior
+ * and can then return a spoofed secret if a non-Omnibus log mimics `Claim`.
+ * Prefer {@link getClaimEvents} / {@link watchClaimEvents} (address-scoped)
+ * or pre-filter `logs` to the known Omnibus deployment before decoding.
+ *
+ * @param logs - Raw logs to scan; non-`Claim` logs are skipped.
+ * @returns All decoded `Claim` events, in log order.
+ * @see IOmnibus.Claim
+ * @example
+ * ```ts
+ * // PREFERRED: client.waitForReceipt scopes decoding to the Omnibus address
+ * const {claims} = await client.waitForReceipt(hash)
+ * const secret = extractSecretFromClaims(claims, lock) // verified + scoped
+ *
+ * // low-level: only on logs ALREADY scoped to the Omnibus address
+ * const scoped = receipt.logs.filter(l => l.address.toLowerCase() === omnibus.toLowerCase())
+ * const someClaim = decodeClaimEvents(scoped)[0]?.secret // now public on-chain
+ * ```
+ */
+declare function decodeClaimEvents(logs: readonly Log[]): ClaimEvent[];
+/**
+ * Extracts the revealed secret for a specific lock from a list of logs.
+ *
+ * Verifies the cryptographic relationship before returning: a `Claim` event
+ * is accepted only when both its indexed `lock` equals the requested lock
+ * AND `generateLock(event.secret)` hashes back to that lock. This rejects a
+ * same-shaped fake `Claim(lock, wrongSecret)` whose `secret` does not
+ * actually open the lock.
+ *
+ * Idempotent by construction: duplicate `Claim` logs for the same lock
+ * carry the same secret (the lock is `keccak256(secret)`, so only one
+ * preimage can ever satisfy it), so processing the same event twice
+ * returns the same value.
+ *
+ * SECURITY: this does NOT filter by `log.address` — it inherits the
+ * raw-log/address behavior of the decoders. Scope `logs` to the correct
+ * Omnibus address first (prefer `client.waitForReceipt`,
+ * `waitForOmnibusReceipt(..., {address})`, or the address-scoped
+ * `getClaimEvents`/`watchClaimEvents`), or extract from an already-scoped
+ * decoded {@link ClaimEvent} array via {@link extractSecretFromClaims}.
+ *
+ * @param logs - Raw logs to scan (receipt logs or a `getLogs` result).
+ * @param lock - The lock whose secret to extract.
+ * @returns The 32-byte secret, or `undefined` when no `Claim` for the lock
+ *   carries a secret that hashes to it.
+ * @see IOmnibus.Claim, Omnibus._generateLock
+ * @example
+ * ```ts
+ * // prefer scoped claims; only use raw logs you have already address-scoped
+ * const secret = extractRevealedSecret(scopedChainBLogs, lock)
+ * if (secret) await chainAClient.claim({secret, party: bobTerms, counterparty: aliceTerms})
+ * ```
+ */
+declare function extractRevealedSecret(logs: readonly Log[], lock: Hex32): Hex32 | undefined;
+/**
+ * Extracts the revealed secret for a lock from already-decoded `Claim`
+ * events — the safe, address-scoped path (the events typically come from
+ * {@link OmnibusReceipt.claims}, which `client.waitForReceipt` /
+ * `waitForOmnibusReceipt(..., {address})` already filter by `log.address`).
+ *
+ * Like {@link extractRevealedSecret} it verifies `generateLock(secret)`
+ * hashes back to the requested lock, so a fake `Claim(lock, wrongSecret)`
+ * is ignored.
+ *
+ * @param claims - Decoded `Claim` events (e.g. `receipt.claims`).
+ * @param lock - The lock whose secret to extract.
+ * @returns The 32-byte secret, or `undefined` when none matches.
+ * @see IOmnibus.Claim, Omnibus._generateLock
+ * @example
+ * ```ts
+ * const receipt = await aliceOnB.waitForReceipt(claimHash)
+ * const secret = extractSecretFromClaims(receipt.claims, lock)
+ * ```
+ */
+declare function extractSecretFromClaims(claims: readonly ClaimEvent[], lock: Hex32): Hex32 | undefined;
+/**
+ * Decodes every `Reclaimed` event in a list of logs.
+ *
+ * IMPORTANT: one reclaim transaction can legitimately emit TWO `Reclaimed`
+ * events — when the counterparty leg is local and the lock was `Committed`,
+ * both legs return to their respective `reclaimRecipient` addresses in one
+ * call. Always handle the array, never assume a single event.
+ *
+ * NOTE: a raw ABI decoder — it does NOT verify `log.address`. Scope `logs`
+ * to the known Omnibus deployment first (prefer `client.waitForReceipt` /
+ * `waitForOmnibusReceipt(..., {address})`, or {@link getReclaimedEvents}).
+ *
+ * @param logs - Pre-scoped logs to scan; non-`Reclaimed` logs are skipped.
+ * @returns All decoded `Reclaimed` events, in log order.
+ * @see IOmnibus.Reclaimed, Omnibus.reclaim
+ */
+declare function decodeReclaimedEvents(logs: readonly Log[]): ReclaimedEvent[];
+/** Common arguments for historical event queries. */
+interface EventQueryArgs {
+    /** The Viem public client to query through. */
+    readonly publicClient: PublicClient;
+    /** The Omnibus contract address — always filter by contract address. */
+    readonly address: Address;
+    /** Restrict results to one lock (indexed topic) when provided. */
+    readonly lock?: Hex32;
+    /** Inclusive starting block; supply a deployment block to bound the scan. */
+    readonly fromBlock?: BlockNumber | BlockTag;
+    /** Inclusive ending block. */
+    readonly toBlock?: BlockNumber | BlockTag;
+}
+/**
+ * Queries historical `Commitment` events via `publicClient.getLogs`.
+ *
+ * Reorg caveat: a log returned here reflects the chain at query time only.
+ * Re-query (or compare block hashes) after your confirmation depth before
+ * acting on it.
+ *
+ * @param args - See {@link EventQueryArgs}.
+ * @returns Decoded events in chain order.
+ * @example
+ * ```ts
+ * const history = await getCommitmentEvents({publicClient, address, lock})
+ * ```
+ */
+declare function getCommitmentEvents(args: EventQueryArgs): Promise<CommitmentEvent[]>;
+/**
+ * Queries historical `Claim` events via `publicClient.getLogs`.
+ *
+ * @param args - See {@link EventQueryArgs}.
+ * @returns Decoded events in chain order. Apply your confirmation policy
+ *   before treating a revealed secret's claim as settled.
+ */
+declare function getClaimEvents(args: EventQueryArgs): Promise<ClaimEvent[]>;
+/**
+ * Queries historical `Reclaimed` events via `publicClient.getLogs`.
+ *
+ * @param args - See {@link EventQueryArgs}.
+ * @returns Decoded events in chain order (possibly two per transaction).
+ */
+declare function getReclaimedEvents(args: EventQueryArgs): Promise<ReclaimedEvent[]>;
+/**
+ * Watches for live `Claim` events on a lock — the cross-chain coordinator's
+ * tool for learning the revealed secret promptly.
+ *
+ * This is an OPTIONAL convenience; the SDK never requires a permanently
+ * running watcher. The callback may fire more than once for the same claim
+ * (duplicates, reorg re-emission) — {@link extractRevealedSecret}'s
+ * idempotence makes acting on duplicates safe.
+ *
+ * @param args - Query args plus the callback.
+ * @param args.onClaim - Invoked with each decoded `Claim` event observed.
+ * @returns The unwatch function from Viem; call it to stop watching.
+ * @example
+ * ```ts
+ * const stop = watchClaimEvents({publicClient, address, lock, onClaim: e => use(e.secret)})
+ * ```
+ */
+declare function watchClaimEvents(args: Omit<EventQueryArgs, 'fromBlock' | 'toBlock'> & {
+    readonly onClaim: (event: ClaimEvent) => void;
+}): () => void;
+
+/**
+ * Receipt helpers.
+ *
+ * A returned transaction hash is NOT confirmation: the transaction may
+ * still be pending, may revert, or may be dropped/replaced. These helpers
+ * wait for a receipt, check `status`, and decode the relevant Omnibus
+ * events into typed results.
+ *
+ * Address-scoped decoding: when `options.address` is supplied, only logs
+ * emitted by that address are decoded — preventing another contract in the
+ * same transaction from emitting an Omnibus-shaped `Commitment`/`Claim`/
+ * `Reclaimed` event that the receipt helper would otherwise decode as
+ * genuine. Prefer the client-bound {@link OmnibusClient.waitForReceipt},
+ * which passes the client's Omnibus address automatically. Omitting
+ * `address` keeps the legacy raw behavior (decode every matching log) for
+ * backward compatibility, but is NOT recommended for security-sensitive
+ * flows.
+ *
+ * Submission ({@link OmnibusClient.commit} et al.) and receipt waiting are
+ * deliberately separate so the application chooses its own confirmation
+ * count, timeout, retry, and finality policy per call.
+ */
+
+/** Options forwarded to `publicClient.waitForTransactionReceipt`, plus address scoping. */
+interface WaitOptions {
+    /**
+     * The expected Omnibus contract address. When set, only logs emitted by
+     * this address are decoded into `commitments`/`claims`/`reclaims` — the
+     * defense against same-signature events from other contracts in the same
+     * transaction. Omitting it decodes every matching log (legacy behavior;
+     * not recommended). {@link OmnibusClient.waitForReceipt} fills this in.
+     */
+    readonly address?: Address;
+    /** Number of confirmations to wait for (default: the client's default, 1). */
+    readonly confirmations?: number;
+    /** Milliseconds to wait before giving up. */
+    readonly timeout?: number;
+}
+/** A successful, decoded Omnibus transaction result. */
+interface OmnibusReceipt {
+    /** The transaction hash that was waited on. */
+    readonly transactionHash: Hash;
+    /** The full Viem receipt (status is guaranteed `'success'`). */
+    readonly receipt: TransactionReceipt;
+    /** Decoded `Commitment` events emitted by the transaction (0 or 1). */
+    readonly commitments: readonly CommitmentEvent[];
+    /** Decoded `Claim` events emitted by the transaction (0 or 1). */
+    readonly claims: readonly ClaimEvent[];
+    /** Decoded `Reclaimed` events (0, 1, or 2 — dual-leg reclaims emit two). */
+    readonly reclaims: readonly ReclaimedEvent[];
+}
+/**
+ * Waits for a transaction receipt, verifies it succeeded, and decodes all
+ * Omnibus events it emitted.
+ *
+ * @param publicClient - The Viem public client to poll through.
+ * @param hash - The transaction hash returned by a write method.
+ * @param options - `address` (strongly recommended — scopes decoding to the
+ *   Omnibus deployment; see {@link WaitOptions}), plus confirmation count
+ *   and timeout. Pick confirmations per your finality policy — one
+ *   confirmation on a reorg-prone chain is weak evidence.
+ * @returns The typed {@link OmnibusReceipt}; `commitments`/`claims`/
+ *   `reclaims` contain only events from `options.address` when supplied.
+ * @throws QuipSwapError `TRANSACTION_REVERTED` when the receipt status is
+ *   `'reverted'`; `CONTRACT_REVERT` (with `cause`) when waiting itself
+ *   fails (timeout, replacement, RPC error).
+ * @example
+ * ```ts
+ * // prefer client.waitForReceipt; standalone form must pass the address:
+ * const hash = await client.commit({lock, party, counterparty})
+ * const {commitments} = await waitForOmnibusReceipt(publicClient, hash, {
+ *   address: omnibusAddress,
+ *   confirmations: 3,
+ * })
+ * console.log(commitments[0]?.lock)
+ * ```
+ */
+declare function waitForOmnibusReceipt(publicClient: PublicClient, hash: Hash, options?: WaitOptions): Promise<OmnibusReceipt>;
+
+/**
+ * Minimal `IQuipFactory` surface consumed by the SDK — exactly what the
+ * Omnibus `onlyQuipWallet` modifier reads.
+ *
+ * @see IQuipFactory.vaultIdOf
+ */
+declare const quipFactoryAbi: readonly [{
+    readonly type: "function";
+    readonly name: "vaultIdOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "vaultId";
+        readonly type: "bytes32";
+    }];
+}];
+/** Arguments for {@link createOmnibusClient}. */
+interface CreateOmnibusClientArgs {
+    /** The deployed Omnibus contract address (see {@link resolveDeployment}). */
+    readonly address: Address;
+    /** A Viem public client connected to the chain the contract lives on. */
+    readonly publicClient: PublicClient;
+    /**
+     * A Viem wallet client for writes. Optional: a read-only client works
+     * without one, and writes then fail with `MISSING_WALLET_CLIENT`. In
+     * production the COMMIT sender must be a QuipWallet contract; claim and
+     * reclaim may be sent by any account.
+     */
+    readonly walletClient?: WalletClient;
+}
+/** Arguments for {@link OmnibusClient.commit}. */
+interface CommitArgs {
+    /** The hashlock (`generateLock(secret)`); the proposer generates the secret. */
+    readonly lock: Hex32;
+    /** The committing side's terms — the sender acts for this side. */
+    readonly party: Terms;
+    /** The other side's terms. */
+    readonly counterparty: Terms;
+    /**
+     * When `true` (default), preflight additionally reads the lock's
+     * on-chain state: a `Spent` or `Committed` lock rejects with
+     * `INVALID_LOCK_STATE` (no commit can advance from those states), and a
+     * `Free` lock requires the canonical `termsHash` to match
+     * (`TERMS_NOT_ON_CHAIN` otherwise) and the committing side to not
+     * already be posted (`TERMS_ALREADY_POSTED` otherwise — the second
+     * same-chain commit must post the OTHER side). Costs three extra
+     * parallel reads; with the flag off, gas estimation still catches every
+     * case as a decoded `CONTRACT_REVERT`.
+     */
+    readonly verifyOnChainState?: boolean;
+}
+/** Arguments for {@link OmnibusClient.claim}. */
+interface ClaimArgs {
+    /** The 32-byte preimage of the lock. Sending it on-chain reveals it publicly. */
+    readonly secret: Hex32;
+    /** The claimant role's terms (the side the claimant acts for). */
+    readonly party: Terms;
+    /** The other side's terms — the leg being claimed; must be local. */
+    readonly counterparty: Terms;
+    /**
+     * When `true` (default), preflight additionally verifies on-chain state
+     * in one parallel read batch: `lockState(lock)` must be `Committed`
+     * (`INVALID_LOCK_STATE` otherwise, with the actual state and likely
+     * cause), `termsHash(lock)` must equal the canonical digest, and the
+     * counterparty's side must be `posted` (`TERMS_NOT_ON_CHAIN` otherwise).
+     * Costs three extra parallel reads; disable only if you have just
+     * verified the state yourself — estimation still catches everything.
+     */
+    readonly verifyOnChainState?: boolean;
+}
+/** Arguments for {@link OmnibusClient.reclaim}. */
+interface ReclaimArgs {
+    /** The hashlock identifying the swap. */
+    readonly lock: Hex32;
+    /** The terms of the leg being reclaimed (must be local to this chain). */
+    readonly party: Terms;
+    /** The other side's terms. */
+    readonly counterparty: Terms;
+    /**
+     * When `true` (default), preflight additionally verifies on-chain state
+     * in one parallel read batch: `lockState(lock)` must be `Free` or
+     * `Committed` (`INVALID_LOCK_STATE` otherwise — `Unused` was never
+     * committed, `Spent` was already settled), `termsHash(lock)` must equal
+     * the canonical digest, and the party's side must be `posted`
+     * (`TERMS_NOT_ON_CHAIN` otherwise).
+     */
+    readonly verifyOnChainState?: boolean;
+}
+/** Owner-only administrative operations (Ownable2Step). */
+interface OmnibusAdmin {
+    /**
+     * Sets the commitment fee. Owner only; reverts `FeeExceedsMax` above
+     * `MAX_FEE`, `OwnableUnauthorizedAccount` for non-owners.
+     *
+     * @param newFee - The new fee in wei; must be `<= MAX_FEE`.
+     * @param opts - Optional per-transaction gas/fee/nonce options.
+     * @returns The transaction hash.
+     * @throws QuipSwapError `MISSING_WALLET_CLIENT` | `CONTRACT_REVERT` |
+     *   `GAS_ESTIMATION_FAILED` | `BALANCE_TOO_LOW`.
+     * @see Omnibus.setCommitmentFee
+     */
+    setCommitmentFee(newFee: bigint, opts?: TxOptions): Promise<Hash>;
+    /**
+     * Withdraws all accrued fees to `to`. Owner only. Escrowed swap native is
+     * NOT withdrawable — only accrued fees.
+     *
+     * @param to - The recipient of the accrued fees.
+     * @param opts - Optional per-transaction gas/fee/nonce options.
+     * @returns The transaction hash.
+     * @throws QuipSwapError `MISSING_WALLET_CLIENT` | `CONTRACT_REVERT` |
+     *   `GAS_ESTIMATION_FAILED` | `BALANCE_TOO_LOW`.
+     * @see Omnibus.withdrawFees
+     */
+    withdrawFees(to: Address, opts?: TxOptions): Promise<Hash>;
+    /**
+     * Starts the two-step ownership transfer (Ownable2Step): the new owner
+     * must later call {@link acceptOwnership}.
+     *
+     * @param newOwner - The proposed new owner.
+     * @param opts - Optional per-transaction gas/fee/nonce options.
+     * @returns The transaction hash.
+     * @see Ownable2Step.transferOwnership
+     */
+    transferOwnership(newOwner: Address, opts?: TxOptions): Promise<Hash>;
+    /**
+     * Completes a pending two-step ownership transfer; must be sent by the
+     * pending owner.
+     *
+     * @param opts - Optional per-transaction gas/fee/nonce options.
+     * @returns The transaction hash.
+     * @see Ownable2Step.acceptOwnership
+     */
+    acceptOwnership(opts?: TxOptions): Promise<Hash>;
+}
+/**
+ * A typed client bound to one deployed Omnibus contract.
+ *
+ * Created by {@link createOmnibusClient}. Read methods mirror the
+ * contract's getters one-to-one; write methods preflight, estimate gas
+ * with a safety buffer, and submit. Write methods return the transaction
+ * HASH only — pair them with {@link OmnibusClient.waitForReceipt} to
+ * confirm success and decode events (it scopes decoding to this client's
+ * Omnibus address automatically).
+ */
+interface OmnibusClient {
+    /** The Omnibus contract address this client is bound to. */
+    readonly address: Address;
+    /** The underlying public client (exposed for receipt/event helpers). */
+    readonly publicClient: PublicClient;
+    /** Reads the contract version. @see Omnibus.VERSION */
+    getVersion(): Promise<bigint>;
+    /** Reads the maximum settable commitment fee in wei. @see Omnibus.MAX_FEE */
+    getMaxFee(): Promise<bigint>;
+    /** Reads the QuipFactory address whose registry gates commit. @see Omnibus.QUIP_FACTORY */
+    getQuipFactory(): Promise<Address>;
+    /** Reads the current commitment fee in wei. @see Omnibus.commitmentFee */
+    getCommitmentFee(): Promise<bigint>;
+    /** Reads the withdrawable accrued fees in wei. @see Omnibus.accruedFees */
+    getAccruedFees(): Promise<bigint>;
+    /** Reads a lock's lifecycle state. @see Omnibus.lockState */
+    getLockState(lock: Hex32): Promise<LockState>;
+    /** Reads the canonical terms digest bound to a lock (zero if none). @see Omnibus.termsHash */
+    getTermsHash(lock: Hex32): Promise<Hex32>;
+    /** Reads whether a side's terms digest was posted for a lock. @see Omnibus.posted */
+    getPosted(lock: Hex32, termsDigest: Hex32): Promise<boolean>;
+    /** Reads the current owner. @see Ownable.owner */
+    getOwner(): Promise<Address>;
+    /** Reads the pending owner of an in-flight two-step transfer. @see Ownable2Step.pendingOwner */
+    getPendingOwner(): Promise<Address>;
+    /**
+     * Checks whether `account` passes the `onlyQuipWallet` gate: reads
+     * `vaultIdOf(account)` on the contract's `QUIP_FACTORY` and reports
+     * whether it is non-zero. Only factory-deployed QuipWallets can commit;
+     * `commit` runs this as a preflight and rejects with `NOT_QUIP_WALLET`.
+     *
+     * @param account - The would-be commit sender (the QuipWallet contract
+     *   address, NOT its owner's EOA).
+     * @returns `true` iff `vaultIdOf(account)` is non-zero (the account can commit).
+     * @see Omnibus.commit (onlyQuipWallet), IQuipFactory.vaultIdOf
+     */
+    isQuipWallet(account: Address): Promise<boolean>;
+    /**
+     * Commits the sender's side of a swap. QuipWallet-gated and payable.
+     *
+     * The contract gates commit with `onlyQuipWallet`
+     * (`QUIP_FACTORY.vaultIdOf(msg.sender) != 0`), so the SDK preflights the
+     * gate via {@link OmnibusClient.isQuipWallet} and rejects a non-wallet
+     * sender with `NOT_QUIP_WALLET` BEFORE any estimation round-trip — this is
+     * the most likely integration failure. The committer must be the QuipWallet
+     * CONTRACT address, never its owner's EOA.
+     *
+     * Preflight (in order, all before any transaction exists):
+     * 1. Both terms structurally valid; 2. pairing strictly interleaves;
+     * 3. `party.chainId` matches the connected chain (`counterparty.chainId`
+     *    may differ — cross-chain); 4. the sender passes the QuipWallet gate
+     *    (`vaultIdOf != 0`); 5. the chain's current timestamp is inside the
+     *    sender's commit window — proposer `[0, party.commitmentDeadline)`,
+     *    taker `[counterparty.commitmentDeadline, party.commitmentDeadline)`
+     *    (the taker's window OPENS only when the proposer's deadline
+     *    elapses); 6. unless `verifyOnChainState` is disabled, the lock's
+     *    on-chain state permits this commit (see
+     *    {@link CommitArgs.verifyOnChainState}); 7. the fee is re-read;
+     *    8. `msg.value` is computed as exactly
+     *    `totalNative(party) + commitmentFee` — the contract checks strict
+     *    equality (`IncorrectNativeAmountReceived`), so over- and
+     *    underpayment both revert; 9. the balance preflight runs (bare
+     *    `msg.value` only — gas funding is not preflighted); 10. gas is
+     *    estimated node-side (a would-be revert surfaces here, decoded) and
+     *    buffered by the safety multiplier; 11. submit.
+     *
+     * Unused gas is refunded, so the default 1.2x buffer costs nothing at
+     * execution; it exists to prevent out-of-gas failures from state drift
+     * between estimation and inclusion — which matters here because writes
+     * happen inside closing time windows.
+     *
+     * @remarks
+     * ⚠️ ASSET-LOSS RISK (cross-chain takers). If you are the TAKER in a
+     * cross-chain swap and you commit before the PROPOSER has actually
+     * committed on their chain, the proposer — who holds the secret — can
+     * claim your escrowed leg while never funding their own, and your assets
+     * are gone. The contract enforces the same-chain *window* ordering (the
+     * taker cannot commit until the proposer's commitment deadline has passed)
+     * and the same-chain lock-state guards prevent a taker-first commit from
+     * ever draining the taker — but it CANNOT protect you cross-chain (your
+     * chain cannot read the proposer's chain), where a taker-first commit
+     * against an uncommitted proposer loses your funds. Before a cross-chain
+     * taker commit, verify the
+     * proposer's commitment yourself with
+     * {@link verifyRemoteCommitment} against the proposer's chain and apply
+     * your own confirmation depth; only then call `commit`. See the
+     * "Security & risks" section of USAGE.md.
+     *
+     * @param args - See {@link CommitArgs}.
+     * @param opts - Optional per-transaction gas/fee/nonce options
+     *   ({@link TxOptions}); `skipPreflightChecks` skips ONLY the balance
+     *   check, never the protocol preflights.
+     * @returns The transaction hash (not finality — wait for the receipt).
+     * @throws QuipSwapError `MISSING_WALLET_CLIENT` | `MISSING_ACCOUNT` |
+     *   structural codes from {@link validateTerms} | `DISORDERED_DEADLINES`
+     *   | `CHAIN_ID_MISMATCH` | `NOT_QUIP_WALLET` | `WINDOW_VIOLATED` |
+     *   `INVALID_LOCK_STATE` | `TERMS_ALREADY_POSTED` | `TERMS_NOT_ON_CHAIN` |
+     *   `GAS_ESTIMATION_FAILED` | `BALANCE_TOO_LOW` | `CONTRACT_REVERT`.
+     * @see Omnibus.commit (onlyQuipWallet)
+     * @example
+     * ```ts
+     * const hash = await client.commit({lock, party: myTerms, counterparty: theirTerms})
+     * const result = await client.waitForReceipt(hash) // address-scoped decoding
+     * ```
+     */
+    commit(args: CommitArgs, opts?: TxOptions): Promise<Hash>;
+    /**
+     * Claims a swap by revealing the secret. PERMISSIONLESS — the contract
+     * allows anyone holding the secret to claim; the SDK adds no caller
+     * restriction. The transaction makes the secret PUBLIC.
+     *
+     * Same-chain note: when `party.chainId == counterparty.chainId`, one
+     * claim settles BOTH legs (counterparty's assets to `party.recipient`,
+     * party's assets to `counterparty.recipient`).
+     *
+     * Preflight: secret is valid 32-byte hex; both terms valid and paired;
+     * `counterparty.chainId` matches the connected chain (the CLAIMED leg is
+     * local; `party.chainId` may be remote in a cross-chain claim); the
+     * timestamp is inside the claimant role's window; unless disabled, the
+     * lock is `Committed` and its `termsHash`/`posted` state matches (see
+     * {@link ClaimArgs.verifyOnChainState}); then balance preflight,
+     * estimate+buffer gas (the pre-submission revert check), submit.
+     *
+     * @param args - See {@link ClaimArgs}.
+     * @param opts - Optional per-transaction gas/fee/nonce options.
+     * @returns The transaction hash (not finality).
+     * @throws QuipSwapError `INVALID_HEX32` | structural/pairing codes |
+     *   `CHAIN_ID_MISMATCH` | `WINDOW_VIOLATED` | `INVALID_LOCK_STATE` |
+     *   `TERMS_NOT_ON_CHAIN` | `MISSING_WALLET_CLIENT` |
+     *   `GAS_ESTIMATION_FAILED` | `BALANCE_TOO_LOW` | `CONTRACT_REVERT`.
+     * @see Omnibus.claim
+     */
+    claim(args: ClaimArgs, opts?: TxOptions): Promise<Hash>;
+    /**
+     * Reclaims escrowed assets after the local leg's `reclaimRelease`.
+     * PERMISSIONLESS — assets always go to the terms' `reclaimRecipient`
+     * regardless of caller, so the SDK adds no caller restriction.
+     *
+     * Dual-leg note: when the counterparty leg is also local and the lock is
+     * `Committed`, one reclaim returns BOTH legs to their respective
+     * `reclaimRecipient` addresses and emits two `Reclaimed` events. Reclaim
+     * is also valid from `Free` (a half-committed same-chain swap).
+     *
+     * Preflight: terms valid and paired; `party.chainId` matches the
+     * connected chain; current timestamp `>= party.reclaimRelease`; unless
+     * disabled, the lock is `Free` or `Committed` and its
+     * `termsHash`/`posted` state matches (see
+     * {@link ReclaimArgs.verifyOnChainState}); then balance preflight,
+     * estimate+buffer gas (the pre-submission revert check), submit.
+     *
+     * @param args - See {@link ReclaimArgs}.
+     * @param opts - Optional per-transaction gas/fee/nonce options.
+     * @returns The transaction hash (not finality).
+     * @throws QuipSwapError structural/pairing codes | `CHAIN_ID_MISMATCH` |
+     *   `WINDOW_VIOLATED` | `INVALID_LOCK_STATE` | `TERMS_NOT_ON_CHAIN` |
+     *   `MISSING_WALLET_CLIENT` | `GAS_ESTIMATION_FAILED` |
+     *   `BALANCE_TOO_LOW` | `CONTRACT_REVERT`.
+     * @see Omnibus.reclaim
+     */
+    reclaim(args: ReclaimArgs, opts?: TxOptions): Promise<Hash>;
+    /**
+     * Waits for a write's receipt, verifies success, and decodes the Omnibus
+     * events — scoped to THIS client's Omnibus address, so a same-signature
+     * event from another contract in the same transaction is never decoded as
+     * genuine. This is the preferred way to confirm a `commit`/`claim`/
+     * `reclaim`; you do not pass the address again.
+     *
+     * @param hash - The transaction hash returned by a write method.
+     * @param options - Confirmation count and timeout ({@link WaitOptions});
+     *   `address` is always set to this client's Omnibus address, so you do
+     *   not pass it.
+     * @returns The typed {@link OmnibusReceipt} with address-scoped events.
+     * @throws QuipSwapError `TRANSACTION_REVERTED` | `CONTRACT_REVERT`.
+     * @see waitForOmnibusReceipt
+     * @example
+     * ```ts
+     * const hash = await client.commit({lock, party, counterparty})
+     * const {commitments} = await client.waitForReceipt(hash, {confirmations: 3})
+     * ```
+     */
+    waitForReceipt(hash: Hash, options?: WaitOptions): Promise<OmnibusReceipt>;
+    /** Owner-only operations, namespaced to avoid mixing with user flows. */
+    readonly admin: OmnibusAdmin;
+}
+/**
+ * Creates a typed {@link OmnibusClient} bound to one deployed Omnibus.
+ *
+ * @param args - The contract address plus existing Viem clients; see
+ *   {@link CreateOmnibusClientArgs}. No private keys, RPC URLs, or
+ *   provider-specific objects are accepted — bring your own Viem clients.
+ * @returns The client; see {@link OmnibusClient} for every method.
+ * @example
+ * ```ts
+ * import {createPublicClient, createWalletClient, custom, http} from 'viem'
+ *
+ * const publicClient = createPublicClient({transport: http(rpcUrl)})
+ * const walletClient = createWalletClient({transport: custom(window.ethereum)})
+ * const client = createOmnibusClient({address: omnibusAddress, publicClient, walletClient})
+ * const fee = await client.getCommitmentFee()
+ * ```
+ */
+declare function createOmnibusClient(args: CreateOmnibusClientArgs): OmnibusClient;
+
+/**
+ * Approval inspection and planning for non-native assets.
+ *
+ * The committer is `msg.sender` of the commit transaction — in production a
+ * QuipWallet CONTRACT (never its owner's EOA; see the QuipWallet gate on
+ * `Omnibus.commit`). Assets must belong to that wallet and approvals must
+ * be issued BY that wallet, so every check here asks: "can the Omnibus
+ * contract pull this asset from the committing wallet?"
+ *
+ * Fee-on-transfer caveat: `Omnibus.commit` reconciles received balances
+ * (`TermsLib.transferAssetsNoNative`). If an ERC-20/ERC-1155 delivers less
+ * than the declared amount (fee-on-transfer, deflationary), commit reverts
+ * with `UnexpectedAmountReceived` EVEN IF the approval plan is fully
+ * satisfied. A satisfied plan is necessary, not sufficient.
+ */
+
+/** ERC-20 approval status for one token (amounts aggregated across asset entries). */
+interface Erc20ApprovalItem {
+    readonly kind: 'erc20';
+    /** The token contract. */
+    readonly token: Address;
+    /** Sum of every asset entry for this token in the terms. */
+    readonly requiredAllowance: bigint;
+    /** `allowance(committer, omnibus)` at plan time. */
+    readonly currentAllowance: bigint;
+    /** `currentAllowance >= requiredAllowance`. */
+    readonly satisfied: boolean;
+}
+/** ERC-721 approval status for one specific token id. */
+interface Erc721ApprovalItem {
+    readonly kind: 'erc721';
+    readonly token: Address;
+    readonly tokenId: bigint;
+    /** `getApproved(tokenId) == omnibus`. */
+    readonly tokenApproved: boolean;
+    /** `isApprovedForAll(committer, omnibus)`. */
+    readonly operatorApproved: boolean;
+    /** Either single-token or operator approval suffices. */
+    readonly satisfied: boolean;
+}
+/** ERC-1155 approval status for one token contract (operator approval covers all ids). */
+interface Erc1155ApprovalItem {
+    readonly kind: 'erc1155';
+    readonly token: Address;
+    /** `isApprovedForAll(committer, omnibus)`. */
+    readonly operatorApproved: boolean;
+    readonly satisfied: boolean;
+}
+/** One entry of an {@link ApprovalPlan}. */
+type ApprovalItem = Erc20ApprovalItem | Erc721ApprovalItem | Erc1155ApprovalItem;
+/** The result of {@link planApprovals}. */
+interface ApprovalPlan {
+    /** The wallet whose assets will be pulled (the commit sender). */
+    readonly committer: Address;
+    /** The Omnibus contract that must be able to pull them. */
+    readonly omnibusAddress: Address;
+    /** One item per (token / token+id) requiring approval; empty if all-native. */
+    readonly items: readonly ApprovalItem[];
+    /** True iff every item is satisfied. */
+    readonly satisfied: boolean;
+}
+/** Arguments for {@link planApprovals}. */
+interface PlanApprovalsArgs {
+    /** Public client on the chain where `terms.chainId` points. */
+    readonly publicClient: PublicClient;
+    /** The deployed Omnibus address (the spender/operator to check for). */
+    readonly omnibusAddress: Address;
+    /**
+     * The committing wallet — the QuipWallet CONTRACT address that will send
+     * the commit transaction, NOT its owner's EOA.
+     */
+    readonly committer: Address;
+    /** The side's terms whose assets will be escrowed. */
+    readonly terms: Terms;
+}
+/**
+ * Inspects on-chain approvals for every non-native asset in a side's terms
+ * and returns a typed plan describing what is missing.
+ *
+ * Checks performed (mirroring what `TermsLib.transferAssetsNoNative` will
+ * need at commit time):
+ * - ERC-20: `allowance(committer, omnibus) >= sum(required amounts)` —
+ *   multiple entries of the same token are AGGREGATED.
+ * - ERC-721: `getApproved(tokenId) == omnibus` OR
+ *   `isApprovedForAll(committer, omnibus)`.
+ * - ERC-1155: `isApprovedForAll(committer, omnibus)`.
+ *
+ * Native assets need no approval (they ride along as `msg.value`).
+ *
+ * Note: nonstandard ERC-20s exist (missing return values, fee-on-transfer).
+ * A satisfied plan does not guarantee commit success for fee-on-transfer
+ * tokens — the contract reverts with `UnexpectedAmountReceived` when less
+ * than the declared amount arrives.
+ *
+ * @param args - See {@link PlanApprovalsArgs}.
+ * @returns The typed {@link ApprovalPlan}.
+ * @throws QuipSwapError `CONTRACT_REVERT` when an allowance/approval read
+ *   itself reverts (e.g. a non-token target address).
+ * @see TermsLib.transferAssetsNoNative
+ * @example
+ * ```ts
+ * const plan = await planApprovals({publicClient, omnibusAddress, committer: quipWallet, terms})
+ * for (const item of plan.items.filter(i => !i.satisfied)) {
+ *   const hash = await submitApproval({publicClient, walletClient, omnibusAddress, item, erc20Mode: 'exact'})
+ * }
+ * ```
+ */
+declare function planApprovals(args: PlanApprovalsArgs): Promise<ApprovalPlan>;
+/**
+ * ERC-20 approval sizing. The choice is explicit because it is a real
+ * trade-off the application must own:
+ * - `'exact'` approves only the required amount (safer: a compromised or
+ *   buggy spender can take at most the swap amount; costs one approval per
+ *   swap).
+ * - `'unlimited'` approves `type(uint256).max` (convenient: one approval
+ *   forever; risk: the spender can pull ANY future balance).
+ *
+ * The SDK never defaults to unlimited.
+ */
+type Erc20ApprovalMode = 'exact' | 'unlimited';
+/** Arguments for {@link submitApproval}. */
+interface SubmitApprovalArgs {
+    /** Public client used for simulation. */
+    readonly publicClient: PublicClient;
+    /** Wallet client of the COMMITTER (the wallet that owns the assets). */
+    readonly walletClient: WalletClient;
+    /** The Omnibus address to approve as spender/operator. */
+    readonly omnibusAddress: Address;
+    /** The unsatisfied plan item to fix. */
+    readonly item: ApprovalItem;
+    /** REQUIRED for ERC-20 items: exact or unlimited (see {@link Erc20ApprovalMode}). */
+    readonly erc20Mode?: Erc20ApprovalMode;
+    /**
+     * For ERC-721 items: `'token'` approves only the specific token id
+     * (default — least privilege); `'operator'` grants `setApprovalForAll`.
+     */
+    readonly erc721Mode?: 'token' | 'operator';
+}
+/**
+ * Simulates and submits the approval transaction that satisfies one
+ * unsatisfied {@link ApprovalItem}.
+ *
+ * Always simulates before writing (`simulateContract` → `writeContract`)
+ * so approval failures surface as decoded errors, not burned gas. Nothing
+ * is auto-approved: the application explicitly invokes this per item.
+ *
+ * @param args - See {@link SubmitApprovalArgs}.
+ * @returns The transaction hash. Wait for its receipt before re-planning —
+ *   a hash alone does not mean the approval landed.
+ * @throws QuipSwapError `MISSING_ACCOUNT` when the wallet client has no
+ *   account; `INVALID_RANGE` (mode missing for ERC-20); `CONTRACT_REVERT`
+ *   when simulation/submission fails.
+ * @example
+ * ```ts
+ * const hash = await submitApproval({
+ *   publicClient, walletClient, omnibusAddress,
+ *   item: unsatisfiedItem, erc20Mode: 'exact',
+ * })
+ * await publicClient.waitForTransactionReceipt({hash})
+ * ```
+ */
+declare function submitApproval(args: SubmitApprovalArgs): Promise<`0x${string}`>;
+
+/**
+ * Suggested minimum-buffer presets (seconds) by chain-finality profile.
+ * Starting points to tune to your chains, NOT authoritative values.
+ *
+ * - `fastL2` (~5 min): fast-finality L2s with low reorg risk.
+ * - `standard` (~30 min): general-purpose default.
+ * - `conservativeL1` (~1 hr): congested or deep-reorg-risk L1s.
+ */
+declare const DEFAULT_BUFFERS: {
+    /** ~5 min — fast-finality L2s. */
+    readonly fastL2: 300n;
+    /** ~30 min — general default. */
+    readonly standard: 1800n;
+    /** ~1 hr — congested / deep-reorg-risk L1s. */
+    readonly conservativeL1: 3600n;
+};
+/**
+ * Default minimum buffer applied to CROSS-CHAIN schedules when the caller
+ * supplies none. A conservative starting point ({@link DEFAULT_BUFFERS}.standard,
+ * ~30 min) — tune to your chains; overriding BELOW it can expose users to
+ * missed windows and lost funds under congestion/reorgs.
+ */
+declare const DEFAULT_CROSS_CHAIN_BUFFER_SECONDS: 1800n;
+/**
+ * Default minimum buffer applied to SAME-CHAIN schedules when the caller
+ * supplies none. Same conservative starting point as the cross-chain default
+ * ({@link DEFAULT_BUFFERS}.standard, ~30 min) but a SEPARATE constant so the
+ * two modes can be tuned independently later without touching call sites.
+ */
+declare const DEFAULT_SAME_CHAIN_BUFFER_SECONDS: 1800n;
+/**
+ * Validates that every adjacent gap in a pairing's interleaved six-timestamp
+ * schedule is at least `minimumBufferSeconds`. This is the gap-SIZE check
+ * (distinct from interleaving ORDER, validated by `validateTermPairing`);
+ * the contract never checks size, so this is the only enforcement point.
+ *
+ * The schedule order checked is: `proposer.commitmentDeadline`,
+ * `taker.commitmentDeadline`, `proposer.claimDeadline`, `taker.claimDeadline`,
+ * `proposer.reclaimRelease`, `taker.reclaimRelease`. Callers must pass terms
+ * whose roles are already normalized (proposer = smaller `commitmentDeadline`).
+ *
+ * @param proposerTerms - The proposer's leg (smaller `commitmentDeadline`).
+ * @param takerTerms - The taker's leg.
+ * @param minimumBufferSeconds - The minimum acceptable gap (seconds) between
+ *   every adjacent pair of schedule timestamps.
+ * @returns `{minimumGapSeconds}` — the smallest adjacent gap in the schedule.
+ * @throws QuipSwapError `INSUFFICIENT_BUFFER` when any adjacent gap is below
+ *   `minimumBufferSeconds` (details carry the offending pair and the gap).
+ * @see TermsLib.validateTermPairing (the ORDER check this complements)
+ * @example
+ * ```ts
+ * const {minimumGapSeconds} = checkScheduleBuffers(proposer, taker, 1800n)
+ * ```
+ */
+declare function checkScheduleBuffers(proposerTerms: Terms, takerTerms: Terms, minimumBufferSeconds: bigint): {
+    minimumGapSeconds: bigint;
+};
+
+/**
+ * A validated same-chain swap plan with both sides normalized into
+ * proposer/taker roles and all five action windows precomputed.
+ */
+interface SameChainSwapPlan {
+    /** The proposer's terms (earlier schedule; commits first; holds the secret). */
+    readonly proposerTerms: Terms;
+    /** The taker's terms (later schedule; commits second). */
+    readonly takerTerms: Terms;
+    /** The canonical trade digest stored in `termsHash[lock]` on commit. */
+    readonly canonicalDigest: Hex32;
+    /** The proposer side's single-terms digest (its `posted` key). */
+    readonly proposerDigest: Hex32;
+    /** The taker side's single-terms digest (its `posted` key). */
+    readonly takerDigest: Hex32;
+    /** `[0, proposer.commitmentDeadline)`. */
+    readonly proposerCommitWindow: TimeWindow;
+    /** `[proposer.commitmentDeadline, taker.commitmentDeadline)`. */
+    readonly takerCommitWindow: TimeWindow;
+    /** `[taker.commitmentDeadline, proposer.claimDeadline)` — one claim settles both legs. */
+    readonly claimWindow: TimeWindow;
+    /** `[proposer.reclaimRelease, +inf)` for the proposer's leg. */
+    readonly proposerReclaimWindow: TimeWindow;
+    /** `[taker.reclaimRelease, +inf)` for the taker's leg. */
+    readonly takerReclaimWindow: TimeWindow;
+}
+/**
+ * Validates a same-chain pairing and assembles a {@link SameChainSwapPlan}.
+ *
+ * Validates structure, interleaving (ORDER), that both sides name the SAME
+ * chain, AND the gap-SIZE buffers between adjacent schedule timestamps.
+ * Accepts the two sides in either order; roles are derived from the
+ * schedule (`proposedBy`). Use {@link validateCrossChainSchedule} for
+ * cross-chain swaps.
+ *
+ * The CONTRACT does not check buffer sizes — it only enforces interleaving
+ * order — so this is the ONLY place a dangerously tight same-chain window is
+ * caught. And nothing forces it (unlike the cross-chain reaction handoff):
+ * BOTH parties should call `planSameChainSwap` on their own terms before
+ * acting. It is per-party self-protection, not a shared gate.
+ *
+ * @param a - One side's terms.
+ * @param b - The other side's terms.
+ * @param opts - Optional. `minimumBufferSeconds` sets the minimum acceptable
+ *   gap (seconds) between every adjacent pair of schedule timestamps;
+ *   defaults to {@link DEFAULT_SAME_CHAIN_BUFFER_SECONDS} when omitted.
+ *   Overriding BELOW the default may let dangerously tight windows through —
+ *   only do so if you understand your chain's finality.
+ * @returns The normalized plan with windows and digests precomputed.
+ * @throws QuipSwapError - structural codes from {@link validateTerms};
+ *   `DISORDERED_DEADLINES` for a non-interleaved schedule;
+ *   `CHAIN_ID_MISMATCH` when the sides name different chains;
+ *   `INSUFFICIENT_BUFFER` when any adjacent gap is below the minimum.
+ * @see TermsLib.validateTermPairing, checkScheduleBuffers
+ * @example
+ * ```ts
+ * const plan = planSameChainSwap(aliceTerms, bobTerms) // default buffer
+ * // proposer commits first:
+ * await client.commit({lock, party: plan.proposerTerms, counterparty: plan.takerTerms})
+ * ```
+ */
+declare function planSameChainSwap(a: Terms, b: Terms, opts?: {
+    readonly minimumBufferSeconds?: bigint;
+}): SameChainSwapPlan;
+/**
+ * Application-level swap status — deliberately SEPARATE from the Solidity
+ * {@link LockState}: the chain knows four states, but an application also
+ * needs to know which window is open and which side has posted.
+ */
+type SameChainSwapStatus = 
+/** Nothing committed; the proposer's commit window is open. */
+'awaiting-proposer-commit'
+/**
+ * Nothing committed and the proposer's window has closed. The swap can
+ * no longer COMPLETE (the proposer can never commit, so the lock can
+ * never reach Committed) — but the contract will still accept a
+ * taker-first commit in `[proposer.commitmentDeadline,
+ * taker.commitmentDeadline)`: `Omnibus.commit` checks only the window,
+ * not that the proposer actually committed (verifying the counterparty's
+ * commitment is the committer's duty, per the contract comments). Such a
+ * commit is pointless and self-harming — it moves the lock Unused→Free
+ * and strands the taker's assets until `taker.reclaimRelease` (reclaim
+ * from Free). Treat this status as terminal and do NOT commit into it.
+ */
+ | 'proposer-commit-expired'
+/** Proposer committed (lock Free); the taker's window has not opened yet. */
+ | 'awaiting-taker-window'
+/** Proposer committed (lock Free); the taker's window is open. */
+ | 'awaiting-taker-commit'
+/** Only the proposer committed and the taker's window closed; awaiting the proposer's reclaimRelease. */
+ | 'half-committed-expired'
+/** Both committed before the taker's commitment deadline; the proposer-claim window has not opened yet. */
+ | 'awaiting-claim-window'
+/** Both committed; the claim window is open — the secret holder should claim. */
+ | 'claimable'
+/** Both committed; the proposer-claim window closed (taker-claim window may run until proposer.reclaimRelease). */
+ | 'late-claimable'
+/** Both committed; no claim landed and a leg's reclaim window is open. */
+ | 'reclaimable'
+/** Lock Free and the proposer's reclaim window is open (reclaim-from-Free). */
+ | 'reclaimable-from-free'
+/** Terminal: the lock is Spent (claimed or reclaimed). */
+ | 'settled';
+/** The full status report returned by {@link getSameChainSwapStatus}. */
+interface SameChainSwapStatusReport {
+    /** The application-level status (see {@link SameChainSwapStatus}). */
+    readonly status: SameChainSwapStatus;
+    /** The raw on-chain {@link LockState} the status was derived from. */
+    readonly lockState: LockState;
+    /** Whether the proposer's side is posted on-chain. */
+    readonly proposerPosted: boolean;
+    /** Whether the taker's side is posted on-chain. */
+    readonly takerPosted: boolean;
+    /** The chain timestamp the report was computed at. */
+    readonly timestamp: bigint;
+}
+/**
+ * Inspects a same-chain swap's status from ACTUAL on-chain state
+ * (`lockState`, `posted`) combined with the current block timestamp.
+ *
+ * @param client - An {@link OmnibusClient} on the swap's chain.
+ * @param lock - The swap's hashlock.
+ * @param plan - The plan from {@link planSameChainSwap}.
+ * @returns A {@link SameChainSwapStatusReport}; never throws on unexpected
+ *   state combinations — the raw fields are included so the application can
+ *   inspect them.
+ * @example
+ * ```ts
+ * const {status} = await getSameChainSwapStatus(client, lock, plan)
+ * if (status === 'claimable') await client.claim({secret, party: plan.proposerTerms, counterparty: plan.takerTerms})
+ * ```
+ */
+declare function getSameChainSwapStatus(client: OmnibusClient, lock: Hex32, plan: SameChainSwapPlan): Promise<SameChainSwapStatusReport>;
+
+/** Arguments for {@link validateCrossChainSchedule}. */
+interface ValidateCrossChainScheduleArgs {
+    /**
+     * The SECRET HOLDER's leg. The secret holder must be the proposer (the
+     * side with the smaller `commitmentDeadline`); anything else is the
+     * free-option misconfiguration and is rejected.
+     */
+    readonly proposerTerms: Terms;
+    /** The counterparty's (taker's) leg, on the other chain. */
+    readonly takerTerms: Terms;
+    /**
+     * Minimum acceptable gap, in SECONDS, between EVERY pair of adjacent
+     * timestamps in the interleaved schedule — including the taker's
+     * post-reveal reaction buffer
+     * (`proposer.reclaimRelease - proposer.claimDeadline`).
+     *
+     * Optional: defaults to {@link DEFAULT_CROSS_CHAIN_BUFFER_SECONDS} when
+     * omitted. Choose it from chain finality, reorg risk, RPC reliability,
+     * network congestion, relayer responsiveness, and your operational safety
+     * margin (the {@link DEFAULT_BUFFERS} presets are starting points). A
+     * value comfortable on a fast-finality L2 may be recklessly small on a
+     * congested L1. Overriding BELOW the default can expose users to missed
+     * windows and lost funds under congestion/reorgs — only do so if you
+     * understand your chains' finality.
+     */
+    readonly minimumBufferSeconds?: bigint;
+}
+/** The validated cross-chain schedule summary. */
+interface CrossChainSchedule {
+    /** The proposer's (secret holder's) leg. */
+    readonly proposerTerms: Terms;
+    /** The taker's leg. */
+    readonly takerTerms: Terms;
+    /**
+     * The taker's post-reveal reaction buffer in seconds:
+     * `proposer.reclaimRelease - proposer.claimDeadline` — the gap between
+     * the latest possible secret reveal (the proposer-claim window closes at
+     * `proposer.claimDeadline`) and the close of the taker's claim window
+     * (`proposer.reclaimRelease`). This is the taker's time to observe the
+     * revealed secret and land their own claim.
+     */
+    readonly reactionBufferSeconds: bigint;
+    /** The smallest gap between any two adjacent schedule timestamps, in seconds. */
+    readonly minimumGapSeconds: bigint;
+}
+/**
+ * Validates a cross-chain swap schedule before any transaction is sent.
+ *
+ * Checks, in order:
+ * 1. Both terms are structurally valid and the pairing strictly
+ *    interleaves (the contract enforces this on BOTH chains; the SDK
+ *    rejects bad pairings before any gas is spent).
+ * 2. The secret holder's leg (`proposerTerms`) actually IS the proposer —
+ *    rejecting the free-option role mis-assignment.
+ * 3. The two legs are on DIFFERENT chains (use {@link planSameChainSwap}
+ *    otherwise).
+ * 4. Every gap between adjacent timestamps in the interleaved schedule —
+ *    including the reaction buffer — is at least `minimumBufferSeconds`
+ *    (defaults to {@link DEFAULT_CROSS_CHAIN_BUFFER_SECONDS} when omitted).
+ *
+ * This validates the SCHEDULE only (interleaving, roles, buffers) and reads
+ * no chain — it is NOT proof that any party has committed. A taker must
+ * still run {@link verifyRemoteCommitment} against the proposer's chain
+ * before committing; a valid schedule alone does not make a commit safe.
+ *
+ * @param args - See {@link ValidateCrossChainScheduleArgs}; parameter names
+ *   are protocol roles (`proposerTerms`/`takerTerms`), not call-site roles.
+ * @returns The {@link CrossChainSchedule} summary (buffers included).
+ * @throws QuipSwapError - structural codes; `DISORDERED_DEADLINES`;
+ *   `SECRET_HOLDER_NOT_PROPOSER` when the roles are inverted;
+ *   `CHAIN_ID_MISMATCH` when both legs share a chain;
+ *   `INSUFFICIENT_BUFFER` when any adjacent gap is below the minimum.
+ * @see TermsLib.validateTermPairing, test/attack/CrossChainFreeOption.t.sol
+ * @example
+ * ```ts
+ * const schedule = validateCrossChainSchedule({
+ *   proposerTerms: aliceTermsOnChainA, // Alice holds the secret
+ *   takerTerms: bobTermsOnChainB,
+ *   // minimumBufferSeconds omitted → DEFAULT_CROSS_CHAIN_BUFFER_SECONDS;
+ *   // or pass an explicit margin, e.g. DEFAULT_BUFFERS.conservativeL1
+ * })
+ * ```
+ */
+declare function validateCrossChainSchedule(args: ValidateCrossChainScheduleArgs): CrossChainSchedule;
+/** The result of {@link verifyRemoteCommitment}. */
+interface RemoteCommitmentStatus {
+    /** True iff the remote lock is `Committed` AND the remote side's terms are posted. */
+    readonly committed: boolean;
+    /** The remote lock's state. */
+    readonly lockState: LockState;
+    /** Whether the remote (proposer) side's terms digest is posted for the lock. */
+    readonly proposerPosted: boolean;
+    /** Whether the on-chain canonical termsHash matches the supplied pairing. */
+    readonly termsHashMatches: boolean;
+}
+/**
+ * The taker's MANDATORY pre-commit check: verifies on the PROPOSER's chain
+ * that the proposer's commitment has actually taken effect.
+ *
+ * ⚠️ Skipping this before a cross-chain TAKER commit is the single most
+ * dangerous mistake you can make with this SDK. If the taker commits and
+ * the proposer never committed, the proposer (who holds the secret) can
+ * claim the taker's escrowed leg while risking nothing — the taker loses
+ * its funds. The contract states the obligation explicitly (`Omnibus.commit`:
+ * "the party MUST ensure the commitment from the counterparty has taken
+ * effect especially if the swap is cross-chain") but CANNOT enforce it
+ * cross-chain, because the taker's chain cannot read the proposer's chain.
+ *
+ * Not spoofable: this reads on-chain STORAGE (`lockState` / `posted` /
+ * `termsHash`), not events, so a forged log cannot fake a commitment. But
+ * the result is POINT-IN-TIME — a reorg can undo a young commit — so apply
+ * your own confirmation depth (re-check after N blocks) before relying on a
+ * `true` result.
+ *
+ * Chain-agnostic: pass a client bound to the PROPOSER's chain for a
+ * cross-chain swap (the case that matters); passing the local client for a
+ * same-chain swap merely duplicates a guard the contract already enforces.
+ *
+ * @param remoteClient - An {@link OmnibusClient} bound to the PROPOSER's chain.
+ * @param lock - The shared hashlock.
+ * @param proposerTerms - The proposer's (remote) leg.
+ * @param takerTerms - The taker's (local) leg.
+ * @returns A {@link RemoteCommitmentStatus}; commit only when `committed`
+ *   is true and your confirmation policy is satisfied.
+ * @see Omnibus.commit
+ * @example
+ * ```ts
+ * const status = await verifyRemoteCommitment(chainAClient, lock, aliceTerms, bobTerms)
+ * if (status.committed) await chainBClient.commit({lock, party: bobTerms, counterparty: aliceTerms})
+ * ```
+ */
+declare function verifyRemoteCommitment(remoteClient: OmnibusClient, lock: Hex32, proposerTerms: Terms, takerTerms: Terms): Promise<RemoteCommitmentStatus>;
+/**
+ * Derives the lock from a secret for cross-chain coordination — re-export
+ * of {@link generateLock} under a workflow-centric name so coordinators
+ * depend only on this module.
+ *
+ * @param secret - The proposer's 32-byte secret.
+ * @returns The shared lock used on BOTH chains.
+ * @throws QuipSwapError `INVALID_HEX32` for malformed secrets.
+ * @see Omnibus._generateLock
+ */
+declare function deriveSharedLock(secret: Hex32): Hex32;
+
+/**
+ * Omnibus contract ABI.
+ *
+ * AUTO-GENERATED by scripts/generate-abi.ts from out/Omnibus.sol/Omnibus.json.
+ * Do not edit by hand — run `forge build && bun run generate:abi` instead.
+ *
+ * Exported `as const` so Viem can infer typed function arguments, return
+ * values, event shapes, and custom error names directly from this object.
+ */
+declare const omnibusAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "initialOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "quipFactory";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "receive";
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_FEE";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "QUIP_FACTORY";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract IQuipFactory";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "acceptOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "accruedFees";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "claim";
+    readonly inputs: readonly [{
+        readonly name: "secret";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "party";
+        readonly type: "tuple";
+        readonly internalType: "struct Terms";
+        readonly components: readonly [{
+            readonly name: "chainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRecipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "commitmentDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRelease";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assets";
+            readonly type: "tuple[]";
+            readonly internalType: "struct Asset[]";
+            readonly components: readonly [{
+                readonly name: "assetType";
+                readonly type: "uint8";
+                readonly internalType: "enum AssetType";
+            }, {
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "id";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }, {
+        readonly name: "counterparty";
+        readonly type: "tuple";
+        readonly internalType: "struct Terms";
+        readonly components: readonly [{
+            readonly name: "chainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRecipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "commitmentDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRelease";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assets";
+            readonly type: "tuple[]";
+            readonly internalType: "struct Asset[]";
+            readonly components: readonly [{
+                readonly name: "assetType";
+                readonly type: "uint8";
+                readonly internalType: "enum AssetType";
+            }, {
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "id";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "commit";
+    readonly inputs: readonly [{
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "party";
+        readonly type: "tuple";
+        readonly internalType: "struct Terms";
+        readonly components: readonly [{
+            readonly name: "chainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRecipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "commitmentDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRelease";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assets";
+            readonly type: "tuple[]";
+            readonly internalType: "struct Asset[]";
+            readonly components: readonly [{
+                readonly name: "assetType";
+                readonly type: "uint8";
+                readonly internalType: "enum AssetType";
+            }, {
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "id";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }, {
+        readonly name: "counterparty";
+        readonly type: "tuple";
+        readonly internalType: "struct Terms";
+        readonly components: readonly [{
+            readonly name: "chainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRecipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "commitmentDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRelease";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assets";
+            readonly type: "tuple[]";
+            readonly internalType: "struct Asset[]";
+            readonly components: readonly [{
+                readonly name: "assetType";
+                readonly type: "uint8";
+                readonly internalType: "enum AssetType";
+            }, {
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "id";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "commitmentFee";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "lockState";
+    readonly inputs: readonly [{
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "state";
+        readonly type: "uint8";
+        readonly internalType: "enum LockState";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "onERC1155BatchReceived";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256[]";
+        readonly internalType: "uint256[]";
+    }, {
+        readonly name: "";
+        readonly type: "uint256[]";
+        readonly internalType: "uint256[]";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "onERC1155Received";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "onERC721Received";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "owner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pendingOwner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "posted";
+    readonly inputs: readonly [{
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "termsDigest";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "isPosted";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "reclaim";
+    readonly inputs: readonly [{
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "party";
+        readonly type: "tuple";
+        readonly internalType: "struct Terms";
+        readonly components: readonly [{
+            readonly name: "chainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRecipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "commitmentDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRelease";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assets";
+            readonly type: "tuple[]";
+            readonly internalType: "struct Asset[]";
+            readonly components: readonly [{
+                readonly name: "assetType";
+                readonly type: "uint8";
+                readonly internalType: "enum AssetType";
+            }, {
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "id";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }, {
+        readonly name: "counterparty";
+        readonly type: "tuple";
+        readonly internalType: "struct Terms";
+        readonly components: readonly [{
+            readonly name: "chainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRecipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "commitmentDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRelease";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assets";
+            readonly type: "tuple[]";
+            readonly internalType: "struct Asset[]";
+            readonly components: readonly [{
+                readonly name: "assetType";
+                readonly type: "uint8";
+                readonly internalType: "enum AssetType";
+            }, {
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "id";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "renounceOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setCommitmentFee";
+    readonly inputs: readonly [{
+        readonly name: "newFee";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "supportsInterface";
+    readonly inputs: readonly [{
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+        readonly internalType: "bytes4";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "termsHash";
+    readonly inputs: readonly [{
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "canonicalDigest";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "transferOwnership";
+    readonly inputs: readonly [{
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "withdrawFees";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "event";
+    readonly name: "Claim";
+    readonly inputs: readonly [{
+        readonly name: "recipient";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "secret";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Commitment";
+    readonly inputs: readonly [{
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "party";
+        readonly type: "tuple";
+        readonly indexed: false;
+        readonly internalType: "struct Terms";
+        readonly components: readonly [{
+            readonly name: "chainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRecipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "commitmentDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimDeadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "reclaimRelease";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "assets";
+            readonly type: "tuple[]";
+            readonly internalType: "struct Asset[]";
+            readonly components: readonly [{
+                readonly name: "assetType";
+                readonly type: "uint8";
+                readonly internalType: "enum AssetType";
+            }, {
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "id";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }, {
+        readonly name: "committer";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "FeeUpdated";
+    readonly inputs: readonly [{
+        readonly name: "oldFee";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "newFee";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "FeesWithdrawn";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferStarted";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferred";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Reclaimed";
+    readonly inputs: readonly [{
+        readonly name: "caller";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "lock";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "CallerNotQuipWallet";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ChainIdMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DisordedDeadlines";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "EmptyAssets";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "FeeExceedsMax";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IncorrectNativeAmountReceived";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidERC1155Asset";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidERC20Asset";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidERC721Asset";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidLockAdvancement";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidLockState";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidNativeAsset";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidRange";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableInvalidOwner";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableUnauthorizedAccount";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "TermsAlreadyPosted";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "TermsMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "TermsNotPosted";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "UnexpectedAmountReceived";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "WindowViolated";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAddressRecipient";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAmount";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroChainId";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroDeadline";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroQuipFactory";
+    readonly inputs: readonly [];
+}];
+
+export { type ApprovalItem, type ApprovalPlan, type Asset, AssetType, type ClaimArgs, type ClaimEvent, type CommitArgs, type CommitmentEvent, type CreateOmnibusClientArgs, type CreateTermsArgs, type CrossChainSchedule, DEFAULT_BUFFERS, DEFAULT_CROSS_CHAIN_BUFFER_SECONDS, DEFAULT_GAS_MULTIPLIER, DEFAULT_SAME_CHAIN_BUFFER_SECONDS, type Erc1155ApprovalItem, type Erc20ApprovalItem, type Erc20ApprovalMode, type Erc721ApprovalItem, type EventQueryArgs, type FeeOverrides, type Hex32, LockState, MAX_GAS_MULTIPLIER, MAX_UINT256, MIN_GAS_MULTIPLIER, OMNIBUS_CREATE3_ADDRESS, type OmnibusAdmin, type OmnibusClient, type OmnibusDeployment, type OmnibusReceipt, type PlanApprovalsArgs, type PrepareTxArgs, type PrepareTxContractParams, type PreparedTx, QuipSwapError, type QuipSwapErrorCode, type QuipSwapErrorDetails, type ReclaimArgs, type ReclaimedEvent, type RemoteCommitmentStatus, type SameChainSwapPlan, type SameChainSwapStatus, type SameChainSwapStatusReport, type SecretLockPair, type SubmitApprovalArgs, type Terms, type TimeWindow, type TxOptions, type ValidateCrossChainScheduleArgs, type WaitOptions, applyGasMultiplier, assertHex32, assetArrayAbiParameter, buildFeeOverrides, checkScheduleBuffers, createOmnibusClient, createTerms, decodeClaimEvents, decodeCommitmentEvents, decodeReclaimedEvents, deriveSharedLock, digestTerms, digestTermsCanonically, enforceWithin, erc1155Asset, erc20Asset, erc721Asset, extractContractErrorName, extractRevealedSecret, extractSecretFromClaims, generateLock, generateSecret, getClaimEvents, getCommitmentEvents, getReclaimedEvents, getSameChainSwapStatus, isWithinWindow, knownDeployments, nativeAsset, omnibusAbi, planApprovals, planSameChainSwap, preflightBalanceCheck, prepareTx, proposedBy, proposerClaimWindow, proposerCommitWindow, quipFactoryAbi, reclaimWindow, resolveDeployment, resolveGasMultiplier, secretToPair, submitApproval, takerClaimWindow, takerCommitWindow, termsAbiParameter, totalNative, validateAsset, validateClaimWindow, validateCommitWindow, validateCrossChainSchedule, validateReclaimWindow, validateTermPairing, validateTerms, verifyRemoteCommitment, waitForOmnibusReceipt, watchClaimEvents, wrapContractError };