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

package/dist/index.js

@@ -0,0 +1,2596 @@
+// src/types.ts
+var AssetType = /* @__PURE__ */ ((AssetType2) => {
+  AssetType2[AssetType2["Native"] = 0] = "Native";
+  AssetType2[AssetType2["ERC20"] = 1] = "ERC20";
+  AssetType2[AssetType2["ERC721"] = 2] = "ERC721";
+  AssetType2[AssetType2["ERC1155"] = 3] = "ERC1155";
+  return AssetType2;
+})(AssetType || {});
+var LockState = /* @__PURE__ */ ((LockState2) => {
+  LockState2[LockState2["Unused"] = 0] = "Unused";
+  LockState2[LockState2["Free"] = 1] = "Free";
+  LockState2[LockState2["Committed"] = 2] = "Committed";
+  LockState2[LockState2["Spent"] = 3] = "Spent";
+  return LockState2;
+})(LockState || {});
+
+// src/errors.ts
+import { BaseError, ContractFunctionRevertedError } from "viem";
+var QuipSwapError = class extends Error {
+  name = "QuipSwapError";
+  code;
+  contractErrorName;
+  cause;
+  details;
+  constructor(args) {
+    super(args.message);
+    this.code = args.code;
+    if (args.contractErrorName !== void 0) this.contractErrorName = args.contractErrorName;
+    if (args.cause !== void 0) this.cause = args.cause;
+    if (args.details !== void 0) this.details = args.details;
+  }
+};
+function extractContractErrorName(error) {
+  if (error instanceof BaseError) {
+    const revert = error.walk((e) => e instanceof ContractFunctionRevertedError);
+    if (revert instanceof ContractFunctionRevertedError) {
+      return revert.data?.errorName ?? revert.signature;
+    }
+  }
+  return void 0;
+}
+function wrapContractError(error, context) {
+  const contractErrorName = extractContractErrorName(error);
+  const suffix = contractErrorName !== void 0 ? ` (contract error: ${contractErrorName})` : "";
+  return new QuipSwapError({
+    code: "CONTRACT_REVERT",
+    message: `${context} reverted${suffix}`,
+    ...contractErrorName !== void 0 ? { contractErrorName } : {},
+    cause: error
+  });
+}
+
+// src/assets.ts
+import { isAddress, zeroAddress } from "viem";
+function nativeAsset(amount) {
+  if (amount <= 0n) {
+    throw new QuipSwapError({
+      code: "ZERO_AMOUNT",
+      message: "Native asset amount must be greater than zero (contract: ZeroAmount)",
+      details: { amount }
+    });
+  }
+  return Object.freeze({ assetType: 0 /* Native */, target: zeroAddress, id: 0n, amount });
+}
+function erc20Asset(target, amount) {
+  assertTokenTarget(target, "INVALID_ERC20_ASSET", "ERC-20");
+  if (amount <= 0n) {
+    throw new QuipSwapError({
+      code: "ZERO_AMOUNT",
+      message: "ERC-20 asset amount must be greater than zero (contract: ZeroAmount)",
+      details: { target, amount }
+    });
+  }
+  return Object.freeze({ assetType: 1 /* ERC20 */, target, id: 0n, amount });
+}
+function erc721Asset(target, tokenId) {
+  assertTokenTarget(target, "INVALID_ERC721_ASSET", "ERC-721");
+  if (tokenId < 0n) {
+    throw new QuipSwapError({
+      code: "INVALID_ERC721_ASSET",
+      message: "ERC-721 token id must be non-negative",
+      details: { target, tokenId }
+    });
+  }
+  return Object.freeze({ assetType: 2 /* ERC721 */, target, id: tokenId, amount: 1n });
+}
+function erc1155Asset(target, tokenId, amount) {
+  assertTokenTarget(target, "INVALID_ERC1155_ASSET", "ERC-1155");
+  if (tokenId < 0n) {
+    throw new QuipSwapError({
+      code: "INVALID_ERC1155_ASSET",
+      message: "ERC-1155 token id must be non-negative",
+      details: { target, tokenId }
+    });
+  }
+  if (amount <= 0n) {
+    throw new QuipSwapError({
+      code: "ZERO_AMOUNT",
+      message: "ERC-1155 asset amount must be greater than zero (contract: ZeroAmount)",
+      details: { target, tokenId, amount }
+    });
+  }
+  return Object.freeze({ assetType: 3 /* ERC1155 */, target, id: tokenId, amount });
+}
+function validateAsset(asset) {
+  if (asset.assetType !== 0 /* Native */ && asset.assetType !== 1 /* ERC20 */ && asset.assetType !== 2 /* ERC721 */ && asset.assetType !== 3 /* ERC1155 */) {
+    throw new QuipSwapError({
+      code: "INVALID_ASSET_TYPE",
+      message: `Unknown asset type ${String(asset.assetType)}; expected 0 (Native), 1 (ERC20), 2 (ERC721), or 3 (ERC1155)`,
+      details: { asset }
+    });
+  }
+  if (asset.amount <= 0n) {
+    throw new QuipSwapError({
+      code: "ZERO_AMOUNT",
+      message: "Asset amount must be greater than zero for every asset type (contract: ZeroAmount)",
+      details: { asset }
+    });
+  }
+  if (!isAddress(asset.target, { strict: false })) {
+    throw new QuipSwapError({
+      code: assetTypeErrorCode(asset.assetType),
+      message: `Asset target ${String(asset.target)} is not a valid address`,
+      details: { asset }
+    });
+  }
+  const isZeroTarget = asset.target.toLowerCase() === zeroAddress;
+  const isZeroId = asset.id === 0n;
+  if (asset.assetType === 0 /* Native */ && (!isZeroTarget || !isZeroId)) {
+    throw new QuipSwapError({
+      code: "INVALID_NATIVE_ASSET",
+      message: "Native asset must have zero target and zero id (contract: InvalidNativeAsset)",
+      details: { asset }
+    });
+  }
+  if (asset.assetType === 1 /* ERC20 */ && (isZeroTarget || !isZeroId)) {
+    throw new QuipSwapError({
+      code: "INVALID_ERC20_ASSET",
+      message: "ERC-20 asset must have a non-zero target and id 0 (contract: InvalidERC20Asset)",
+      details: { asset }
+    });
+  }
+  if (asset.assetType === 2 /* ERC721 */ && isZeroTarget) {
+    throw new QuipSwapError({
+      code: "INVALID_ERC721_ASSET",
+      message: "ERC-721 asset must have a non-zero target (contract: InvalidERC721Asset)",
+      details: { asset }
+    });
+  }
+  if (asset.assetType === 3 /* ERC1155 */ && isZeroTarget) {
+    throw new QuipSwapError({
+      code: "INVALID_ERC1155_ASSET",
+      message: "ERC-1155 asset must have a non-zero target (contract: InvalidERC1155Asset)",
+      details: { asset }
+    });
+  }
+}
+function assetTypeErrorCode(assetType) {
+  switch (assetType) {
+    case 0 /* Native */:
+      return "INVALID_NATIVE_ASSET";
+    case 1 /* ERC20 */:
+      return "INVALID_ERC20_ASSET";
+    case 2 /* ERC721 */:
+      return "INVALID_ERC721_ASSET";
+    case 3 /* ERC1155 */:
+      return "INVALID_ERC1155_ASSET";
+  }
+}
+function assertTokenTarget(target, code, label) {
+  if (!isAddress(target, { strict: false }) || target.toLowerCase() === zeroAddress) {
+    throw new QuipSwapError({
+      code,
+      message: `${label} asset target must be a non-zero contract address`,
+      details: { target }
+    });
+  }
+}
+function totalNative(terms) {
+  let total = 0n;
+  for (const asset of terms.assets) {
+    if (asset.assetType === 0 /* Native */) total += asset.amount;
+  }
+  return total;
+}
+
+// src/terms.ts
+import { isAddress as isAddress2, zeroAddress as zeroAddress2 } from "viem";
+function createTerms(args) {
+  const terms = Object.freeze({
+    chainId: args.chainId,
+    reclaimRecipient: args.reclaimRecipient,
+    recipient: args.recipient,
+    commitmentDeadline: args.commitmentDeadline,
+    claimDeadline: args.claimDeadline,
+    reclaimRelease: args.reclaimRelease,
+    assets: Object.freeze([...args.assets])
+  });
+  validateTerms(terms);
+  return terms;
+}
+function validateTerms(terms) {
+  if (terms.assets.length === 0) {
+    throw new QuipSwapError({
+      code: "EMPTY_ASSETS",
+      message: "Terms must contain at least one asset (contract: EmptyAssets)"
+    });
+  }
+  if (!isRecipientAddress(terms.reclaimRecipient) || !isRecipientAddress(terms.recipient)) {
+    throw new QuipSwapError({
+      code: "ZERO_ADDRESS_RECIPIENT",
+      message: "Both recipient and reclaimRecipient must be valid non-zero addresses (contract: ZeroAddressRecipient)",
+      details: { recipient: terms.recipient, reclaimRecipient: terms.reclaimRecipient }
+    });
+  }
+  if (terms.commitmentDeadline === 0n) {
+    throw new QuipSwapError({
+      code: "ZERO_DEADLINE",
+      message: "commitmentDeadline must be non-zero (contract: ZeroDeadline)"
+    });
+  }
+  if (!(terms.commitmentDeadline < terms.claimDeadline && terms.claimDeadline < terms.reclaimRelease)) {
+    throw new QuipSwapError({
+      code: "DISORDERED_DEADLINES",
+      message: "Lifecycle timestamps must satisfy commitmentDeadline < claimDeadline < reclaimRelease, strictly (contract: DisordedDeadlines)",
+      details: {
+        commitmentDeadline: terms.commitmentDeadline,
+        claimDeadline: terms.claimDeadline,
+        reclaimRelease: terms.reclaimRelease
+      }
+    });
+  }
+  if (terms.chainId <= 0n) {
+    throw new QuipSwapError({
+      code: "ZERO_CHAIN_ID",
+      message: "chainId must be greater than zero (contract: ZeroChainId)",
+      details: { chainId: terms.chainId }
+    });
+  }
+  for (const asset of terms.assets) validateAsset(asset);
+}
+function isRecipientAddress(value) {
+  return isAddress2(value, { strict: false }) && value.toLowerCase() !== zeroAddress2;
+}
+function validateTermPairing(a, b) {
+  const aProposes = a.commitmentDeadline < b.commitmentDeadline && b.commitmentDeadline < a.claimDeadline && a.claimDeadline < b.claimDeadline && b.claimDeadline < a.reclaimRelease && a.reclaimRelease < b.reclaimRelease;
+  const bProposes = b.commitmentDeadline < a.commitmentDeadline && a.commitmentDeadline < b.claimDeadline && b.claimDeadline < a.claimDeadline && a.claimDeadline < b.reclaimRelease && b.reclaimRelease < a.reclaimRelease;
+  if (!(aProposes || bProposes)) {
+    throw new QuipSwapError({
+      code: "DISORDERED_DEADLINES",
+      message: "The two sides' lifecycle timestamps must strictly interleave (proposer.commit < taker.commit < proposer.claim < taker.claim < proposer.reclaim < taker.reclaim; contract: DisordedDeadlines)",
+      details: { a: lifecycleOf(a), b: lifecycleOf(b) }
+    });
+  }
+}
+function lifecycleOf(terms) {
+  return {
+    commitmentDeadline: terms.commitmentDeadline,
+    claimDeadline: terms.claimDeadline,
+    reclaimRelease: terms.reclaimRelease
+  };
+}
+function proposedBy(party, counterparty) {
+  return party.commitmentDeadline < counterparty.commitmentDeadline ? "party" : "counterparty";
+}
+
+// src/windows.ts
+var MAX_UINT256 = (1n << 256n) - 1n;
+function enforceWithin(lower, upper, timestamp) {
+  if (lower >= upper) {
+    throw new QuipSwapError({
+      code: "INVALID_RANGE",
+      message: `Degenerate window: lower (${lower}) must be strictly less than upper (${upper}) (contract: InvalidRange)`,
+      details: { lower, upper, timestamp }
+    });
+  }
+  if (lower > timestamp || upper <= timestamp) {
+    throw new QuipSwapError({
+      code: "WINDOW_VIOLATED",
+      message: `Timestamp ${timestamp} is outside the half-open window [${lower}, ${upper}) (contract: WindowViolated; the upper bound is exclusive)`,
+      details: { lower, upper, timestamp }
+    });
+  }
+}
+function isWithinWindow(window, timestamp) {
+  return window.lower < window.upper && window.lower <= timestamp && timestamp < window.upper;
+}
+function proposerCommitWindow(proposer) {
+  return { lower: 0n, upper: proposer.commitmentDeadline };
+}
+function takerCommitWindow(taker, proposer) {
+  return { lower: proposer.commitmentDeadline, upper: taker.commitmentDeadline };
+}
+function proposerClaimWindow(proposer, taker) {
+  return { lower: taker.commitmentDeadline, upper: proposer.claimDeadline };
+}
+function takerClaimWindow(proposer) {
+  return { lower: proposer.claimDeadline, upper: proposer.reclaimRelease };
+}
+function reclaimWindow(leg) {
+  return { lower: leg.reclaimRelease, upper: MAX_UINT256 };
+}
+function validateCommitWindow(party, counterparty, currentTimestamp) {
+  if (proposedBy(party, counterparty) === "party") {
+    enforceWithin(0n, party.commitmentDeadline, currentTimestamp);
+  } else {
+    enforceWithin(counterparty.commitmentDeadline, party.commitmentDeadline, currentTimestamp);
+  }
+}
+function validateClaimWindow(party, counterparty, currentTimestamp) {
+  if (proposedBy(party, counterparty) === "party") {
+    enforceWithin(counterparty.commitmentDeadline, party.claimDeadline, currentTimestamp);
+  } else {
+    enforceWithin(counterparty.claimDeadline, counterparty.reclaimRelease, currentTimestamp);
+  }
+}
+function validateReclaimWindow(party, currentTimestamp) {
+  enforceWithin(party.reclaimRelease, MAX_UINT256, currentTimestamp);
+}
+
+// src/hashing.ts
+import { concat, encodeAbiParameters, isHex, keccak256 } from "viem";
+var assetArrayAbiParameter = {
+  name: "assets",
+  type: "tuple[]",
+  components: [
+    { name: "assetType", type: "uint8" },
+    { name: "target", type: "address" },
+    { name: "id", type: "uint256" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+var termsAbiParameter = {
+  name: "terms",
+  type: "tuple",
+  components: [
+    { name: "chainId", type: "uint256" },
+    { name: "reclaimRecipient", type: "address" },
+    { name: "recipient", type: "address" },
+    { name: "commitmentDeadline", type: "uint256" },
+    { name: "claimDeadline", type: "uint256" },
+    { name: "reclaimRelease", type: "uint256" },
+    assetArrayAbiParameter
+  ]
+};
+var termsDigestAbiParameters = [
+  { name: "chainId", type: "uint256" },
+  { name: "reclaimRecipient", type: "address" },
+  { name: "recipient", type: "address" },
+  { name: "commitmentDeadline", type: "uint256" },
+  { name: "claimDeadline", type: "uint256" },
+  { name: "reclaimRelease", type: "uint256" },
+  assetArrayAbiParameter
+];
+function digestTerms(terms) {
+  return keccak256(
+    encodeAbiParameters(termsDigestAbiParameters, [
+      terms.chainId,
+      terms.reclaimRecipient,
+      terms.recipient,
+      terms.commitmentDeadline,
+      terms.claimDeadline,
+      terms.reclaimRelease,
+      // readonly Asset[] is structurally compatible with the tuple components
+      terms.assets.map((a) => ({ assetType: a.assetType, target: a.target, id: a.id, amount: a.amount }))
+    ])
+  );
+}
+function digestTermsCanonically(party, counterparty) {
+  const partyDigest = digestTerms(party);
+  const counterpartyDigest = digestTerms(counterparty);
+  return BigInt(partyDigest) < BigInt(counterpartyDigest) ? keccak256(concat([partyDigest, counterpartyDigest])) : keccak256(concat([counterpartyDigest, partyDigest]));
+}
+function generateLock(secret) {
+  assertHex32(secret, "secret");
+  return keccak256(secret);
+}
+function assertHex32(value, label) {
+  if (!isHex(value, { strict: true }) || value.length !== 66) {
+    throw new QuipSwapError({
+      code: "INVALID_HEX32",
+      message: `${label} must be a 0x-prefixed 32-byte hex string (66 chars total); received ${typeof value === "string" ? `${value.length} chars` : typeof value}`
+    });
+  }
+}
+
+// src/secrets.ts
+import { bytesToHex } from "viem";
+function generateSecret() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  const secret = bytesToHex(bytes);
+  return Object.freeze({ secret, lock: generateLock(secret) });
+}
+function secretToPair(secret) {
+  assertHex32(secret, "secret");
+  return Object.freeze({ secret, lock: generateLock(secret) });
+}
+
+// src/deployments.ts
+import { isAddress as isAddress3, zeroAddress as zeroAddress3 } from "viem";
+
+// src/address.json
+var address_default = {
+  _comment: "Verified Omnibus deployments. 'omnibusAddress' is the canonical CREATE3 address derived from (Deployer contract, salt); 'chains' lists chain ids where it is VERIFIED-deployed (verify with `make verify-omnibus`). Empty/placeholder until a real deployment is confirmed; while empty, the SDK resolves no built-in address and requires an override.",
+  omnibusAddress: "0x07b74fb3805f75E669488F64E9a27E74E08fC9e0",
+  chains: [84532]
+};
+
+// src/deployments.ts
+var OMNIBUS_CREATE3_ADDRESS = address_default.omnibusAddress;
+var VERIFIED_DEPLOYMENT_CHAINS = new Set(
+  address_default.chains.map((chainId) => BigInt(chainId))
+);
+var knownDeployments = new Map(
+  [...VERIFIED_DEPLOYMENT_CHAINS].map((chainId) => [chainId, { chainId, omnibusAddress: OMNIBUS_CREATE3_ADDRESS }])
+);
+function resolveDeployment(chainId, override) {
+  if (override !== void 0) {
+    if (!isAddress3(override.omnibusAddress, { strict: false }) || override.omnibusAddress.toLowerCase() === zeroAddress3) {
+      throw new QuipSwapError({
+        code: "UNKNOWN_DEPLOYMENT",
+        message: `Deployment override for chain ${chainId} has an invalid omnibusAddress`,
+        details: { override }
+      });
+    }
+    if (override.chainId !== chainId) {
+      throw new QuipSwapError({
+        code: "UNKNOWN_DEPLOYMENT",
+        message: `Deployment override names chain ${override.chainId} but chain ${chainId} was requested`,
+        details: { override, chainId }
+      });
+    }
+    return override;
+  }
+  const known = knownDeployments.get(chainId);
+  if (known === void 0) {
+    throw new QuipSwapError({
+      code: "UNKNOWN_DEPLOYMENT",
+      message: `No verified Omnibus deployment is known for chain ${chainId} and no override was provided. Supply {chainId, omnibusAddress} explicitly. Addresses are never guessed: a CREATE3 address ignores init code, so a deployment must be verified on-chain before it is trusted (run \`make verify-omnibus\`).`,
+      details: { chainId }
+    });
+  }
+  return known;
+}
+
+// src/gas.ts
+import { BaseError as BaseError2, ContractFunctionRevertedError as ContractFunctionRevertedError2 } from "viem";
+var DEFAULT_GAS_MULTIPLIER = 1.2;
+var MIN_GAS_MULTIPLIER = 1;
+var MAX_GAS_MULTIPLIER = 2;
+function resolveGasMultiplier(opts = {}) {
+  const requested = opts.gasMultiplier ?? DEFAULT_GAS_MULTIPLIER;
+  if (!Number.isFinite(requested)) return MIN_GAS_MULTIPLIER;
+  return Math.min(MAX_GAS_MULTIPLIER, Math.max(MIN_GAS_MULTIPLIER, requested));
+}
+function applyGasMultiplier(estimate, opts = {}) {
+  const scaled = Math.round(resolveGasMultiplier(opts) * 1e3);
+  return estimate * BigInt(scaled) / 1000n;
+}
+function buildFeeOverrides(opts = {}) {
+  return {
+    ...opts.maxFeePerGas !== void 0 ? { maxFeePerGas: opts.maxFeePerGas } : {},
+    ...opts.maxPriorityFeePerGas !== void 0 ? { maxPriorityFeePerGas: opts.maxPriorityFeePerGas } : {},
+    ...opts.gasPrice !== void 0 ? { gasPrice: opts.gasPrice } : {}
+  };
+}
+function isContractRevert(error) {
+  return error instanceof BaseError2 && error.walk((e) => e instanceof ContractFunctionRevertedError2) !== null;
+}
+async function preflightBalanceCheck(publicClient, account, required) {
+  if (required <= 0n) return;
+  const balance = await publicClient.getBalance({ address: account });
+  if (balance < required) {
+    throw new QuipSwapError({
+      code: "BALANCE_TOO_LOW",
+      message: `Sender ${account} holds ${balance} wei but the call requires ${required} wei of value`,
+      details: { required, balance }
+    });
+  }
+}
+async function prepareTx(args) {
+  const { publicClient, contractParams, totalValue, opts = {} } = args;
+  if (opts.skipPreflightChecks !== true) {
+    await preflightBalanceCheck(publicClient, contractParams.account, totalValue);
+  }
+  let gas;
+  if (opts.gas !== void 0) {
+    gas = opts.gas;
+  } else {
+    let estimate;
+    try {
+      estimate = await publicClient.estimateContractGas({
+        address: contractParams.address,
+        abi: contractParams.abi,
+        functionName: contractParams.functionName,
+        args: contractParams.args ?? [],
+        account: contractParams.account,
+        ...contractParams.value !== void 0 ? { value: contractParams.value } : {}
+        // dynamic functionName + optional payable value cannot satisfy viem's
+        // conditional parameter types statically; the runtime shape is
+        // exercised by the mocked-client and Anvil integration suites
+      });
+    } catch (error) {
+      if (isContractRevert(error)) {
+        throw wrapContractError(error, `Estimating gas for ${contractParams.functionName}`);
+      }
+      throw new QuipSwapError({
+        code: "GAS_ESTIMATION_FAILED",
+        message: `Gas estimation for ${contractParams.functionName} failed for a non-revert reason (network error or invalid request); see cause`,
+        cause: error
+      });
+    }
+    gas = applyGasMultiplier(estimate, opts);
+  }
+  return { gas, fees: buildFeeOverrides(opts), ...opts.nonce !== void 0 ? { nonce: opts.nonce } : {} };
+}
+
+// src/client.ts
+import { BaseError as BaseError3, InsufficientFundsError } from "viem";
+
+// src/generated/omnibusAbi.ts
+var omnibusAbi = [
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "initialOwner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "quipFactory",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "MAX_FEE",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "QUIP_FACTORY",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IQuipFactory"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "acceptOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "accruedFees",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "claim",
+    "inputs": [
+      {
+        "name": "secret",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "party",
+        "type": "tuple",
+        "internalType": "struct Terms",
+        "components": [
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "commitmentDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "claimDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRelease",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assets",
+            "type": "tuple[]",
+            "internalType": "struct Asset[]",
+            "components": [
+              {
+                "name": "assetType",
+                "type": "uint8",
+                "internalType": "enum AssetType"
+              },
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "counterparty",
+        "type": "tuple",
+        "internalType": "struct Terms",
+        "components": [
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "commitmentDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "claimDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRelease",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assets",
+            "type": "tuple[]",
+            "internalType": "struct Asset[]",
+            "components": [
+              {
+                "name": "assetType",
+                "type": "uint8",
+                "internalType": "enum AssetType"
+              },
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "commit",
+    "inputs": [
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "party",
+        "type": "tuple",
+        "internalType": "struct Terms",
+        "components": [
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "commitmentDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "claimDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRelease",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assets",
+            "type": "tuple[]",
+            "internalType": "struct Asset[]",
+            "components": [
+              {
+                "name": "assetType",
+                "type": "uint8",
+                "internalType": "enum AssetType"
+              },
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "counterparty",
+        "type": "tuple",
+        "internalType": "struct Terms",
+        "components": [
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "commitmentDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "claimDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRelease",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assets",
+            "type": "tuple[]",
+            "internalType": "struct Asset[]",
+            "components": [
+              {
+                "name": "assetType",
+                "type": "uint8",
+                "internalType": "enum AssetType"
+              },
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "commitmentFee",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "lockState",
+    "inputs": [
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "state",
+        "type": "uint8",
+        "internalType": "enum LockState"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onERC1155BatchReceived",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "onERC1155Received",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "onERC721Received",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "pendingOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "posted",
+    "inputs": [
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "termsDigest",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "isPosted",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "reclaim",
+    "inputs": [
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "party",
+        "type": "tuple",
+        "internalType": "struct Terms",
+        "components": [
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "commitmentDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "claimDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRelease",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assets",
+            "type": "tuple[]",
+            "internalType": "struct Asset[]",
+            "components": [
+              {
+                "name": "assetType",
+                "type": "uint8",
+                "internalType": "enum AssetType"
+              },
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "counterparty",
+        "type": "tuple",
+        "internalType": "struct Terms",
+        "components": [
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "commitmentDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "claimDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRelease",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assets",
+            "type": "tuple[]",
+            "internalType": "struct Asset[]",
+            "components": [
+              {
+                "name": "assetType",
+                "type": "uint8",
+                "internalType": "enum AssetType"
+              },
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "renounceOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setCommitmentFee",
+    "inputs": [
+      {
+        "name": "newFee",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "supportsInterface",
+    "inputs": [
+      {
+        "name": "interfaceId",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "termsHash",
+    "inputs": [
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "canonicalDigest",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transferOwnership",
+    "inputs": [
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "withdrawFees",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Claim",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "secret",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Commitment",
+    "inputs": [
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "party",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct Terms",
+        "components": [
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "commitmentDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "claimDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "reclaimRelease",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assets",
+            "type": "tuple[]",
+            "internalType": "struct Asset[]",
+            "components": [
+              {
+                "name": "assetType",
+                "type": "uint8",
+                "internalType": "enum AssetType"
+              },
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "committer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "FeeUpdated",
+    "inputs": [
+      {
+        "name": "oldFee",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "newFee",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "FeesWithdrawn",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferStarted",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Reclaimed",
+    "inputs": [
+      {
+        "name": "caller",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "lock",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "CallerNotQuipWallet",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ChainIdMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "DisordedDeadlines",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "EmptyAssets",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "FeeExceedsMax",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "IncorrectNativeAmountReceived",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidERC1155Asset",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidERC20Asset",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidERC721Asset",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidLockAdvancement",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidLockState",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidNativeAsset",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidRange",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OwnableInvalidOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OwnableUnauthorizedAccount",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "TermsAlreadyPosted",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "TermsMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "TermsNotPosted",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "UnexpectedAmountReceived",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "WindowViolated",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroAddressRecipient",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroAmount",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroChainId",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroDeadline",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroQuipFactory",
+    "inputs": []
+  }
+];
+
+// src/events.ts
+import { parseEventLogs } from "viem";
+function toAssetType(value) {
+  if (value === 0 || value === 1 || value === 2 || value === 3) return value;
+  throw new QuipSwapError({
+    code: "INVALID_ASSET_TYPE",
+    message: `Decoded asset type ${value} is out of range`
+  });
+}
+function toTerms(decoded) {
+  return Object.freeze({
+    chainId: decoded.chainId,
+    reclaimRecipient: decoded.reclaimRecipient,
+    recipient: decoded.recipient,
+    commitmentDeadline: decoded.commitmentDeadline,
+    claimDeadline: decoded.claimDeadline,
+    reclaimRelease: decoded.reclaimRelease,
+    assets: Object.freeze(
+      decoded.assets.map(
+        (a) => Object.freeze({ assetType: toAssetType(a.assetType), target: a.target, id: a.id, amount: a.amount })
+      )
+    )
+  });
+}
+function decodeCommitmentEvents(logs) {
+  const parsed = parseEventLogs({ abi: omnibusAbi, eventName: "Commitment", logs, strict: true });
+  return parsed.map((log) => ({
+    lock: log.args.lock,
+    party: toTerms(log.args.party),
+    committer: log.args.committer,
+    blockNumber: log.blockNumber,
+    transactionHash: log.transactionHash,
+    logIndex: log.logIndex
+  }));
+}
+function decodeClaimEvents(logs) {
+  const parsed = parseEventLogs({ abi: omnibusAbi, eventName: "Claim", logs, strict: true });
+  return parsed.map((log) => ({
+    recipient: log.args.recipient,
+    lock: log.args.lock,
+    secret: log.args.secret,
+    blockNumber: log.blockNumber,
+    transactionHash: log.transactionHash,
+    logIndex: log.logIndex
+  }));
+}
+function extractRevealedSecret(logs, lock) {
+  return extractSecretFromClaims(decodeClaimEvents(logs), lock);
+}
+function extractSecretFromClaims(claims, lock) {
+  const lockLower = lock.toLowerCase();
+  for (const event of claims) {
+    if (event.lock.toLowerCase() !== lockLower) continue;
+    if (generateLock(event.secret).toLowerCase() !== lockLower) continue;
+    return event.secret;
+  }
+  return void 0;
+}
+function decodeReclaimedEvents(logs) {
+  const parsed = parseEventLogs({ abi: omnibusAbi, eventName: "Reclaimed", logs, strict: true });
+  return parsed.map((log) => ({
+    caller: log.args.caller,
+    lock: log.args.lock,
+    recipient: log.args.recipient,
+    blockNumber: log.blockNumber,
+    transactionHash: log.transactionHash,
+    logIndex: log.logIndex
+  }));
+}
+async function getCommitmentEvents(args) {
+  const logs = await getOmnibusLogs(args, "Commitment");
+  return decodeCommitmentEvents(logs);
+}
+async function getClaimEvents(args) {
+  const logs = await getOmnibusLogs(args, "Claim");
+  return decodeClaimEvents(logs);
+}
+async function getReclaimedEvents(args) {
+  const logs = await getOmnibusLogs(args, "Reclaimed");
+  return decodeReclaimedEvents(logs);
+}
+async function getOmnibusLogs(args, eventName) {
+  const event = omnibusAbi.find(
+    (entry) => entry.type === "event" && entry.name === eventName
+  );
+  if (event === void 0) {
+    throw new QuipSwapError({ code: "EVENT_NOT_FOUND", message: `Event ${eventName} missing from generated ABI` });
+  }
+  return await args.publicClient.getLogs({
+    address: args.address,
+    event,
+    ...args.lock !== void 0 ? { args: { lock: args.lock } } : {},
+    ...args.fromBlock !== void 0 ? { fromBlock: args.fromBlock } : {},
+    ...args.toBlock !== void 0 ? { toBlock: args.toBlock } : {}
+  });
+}
+function watchClaimEvents(args) {
+  return args.publicClient.watchContractEvent({
+    address: args.address,
+    abi: omnibusAbi,
+    eventName: "Claim",
+    ...args.lock !== void 0 ? { args: { lock: args.lock } } : {},
+    onLogs: (logs) => {
+      for (const event of decodeClaimEvents(logs)) args.onClaim(event);
+    }
+  });
+}
+
+// src/receipts.ts
+function filterLogsByAddress(logs, address) {
+  if (address === void 0) return logs;
+  const expected = address.toLowerCase();
+  return logs.filter((log) => log.address.toLowerCase() === expected);
+}
+async function waitForOmnibusReceipt(publicClient, hash, options = {}) {
+  let receipt;
+  try {
+    receipt = await publicClient.waitForTransactionReceipt({
+      hash,
+      ...options.confirmations !== void 0 ? { confirmations: options.confirmations } : {},
+      ...options.timeout !== void 0 ? { timeout: options.timeout } : {}
+    });
+  } catch (error) {
+    throw wrapContractError(error, `Waiting for receipt of ${hash}`);
+  }
+  if (receipt.status !== "success") {
+    throw new QuipSwapError({
+      code: "TRANSACTION_REVERTED",
+      message: `Transaction ${hash} was mined but reverted`,
+      details: { receipt }
+    });
+  }
+  const logs = filterLogsByAddress(receipt.logs, options.address);
+  return {
+    transactionHash: hash,
+    receipt,
+    commitments: decodeCommitmentEvents(logs),
+    claims: decodeClaimEvents(logs),
+    reclaims: decodeReclaimedEvents(logs)
+  };
+}
+
+// src/client.ts
+var quipFactoryAbi = [
+  {
+    type: "function",
+    name: "vaultIdOf",
+    stateMutability: "view",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [{ name: "vaultId", type: "bytes32" }]
+  }
+];
+function toAbiTerms(terms) {
+  return {
+    chainId: terms.chainId,
+    reclaimRecipient: terms.reclaimRecipient,
+    recipient: terms.recipient,
+    commitmentDeadline: terms.commitmentDeadline,
+    claimDeadline: terms.claimDeadline,
+    reclaimRelease: terms.reclaimRelease,
+    assets: terms.assets.map((a) => ({ assetType: a.assetType, target: a.target, id: a.id, amount: a.amount }))
+  };
+}
+function lockStateName(state) {
+  return LockState[state] ?? `unknown(${state})`;
+}
+function createOmnibusClient(args) {
+  const { address, publicClient, walletClient } = args;
+  const contract = { address, abi: omnibusAbi };
+  let quipFactoryAddress;
+  async function getQuipFactory() {
+    if (quipFactoryAddress === void 0) {
+      const factory = await read("QUIP_FACTORY");
+      quipFactoryAddress = factory;
+      return factory;
+    }
+    return quipFactoryAddress;
+  }
+  async function read(functionName, fnArgs = []) {
+    try {
+      return await publicClient.readContract({
+        ...contract,
+        functionName,
+        args: fnArgs
+      });
+    } catch (error) {
+      throw wrapContractError(error, `Reading ${functionName}`);
+    }
+  }
+  function requireWallet() {
+    if (walletClient === void 0) {
+      throw new QuipSwapError({
+        code: "MISSING_WALLET_CLIENT",
+        message: "This operation submits a transaction; create the client with a walletClient to use it"
+      });
+    }
+    const account = walletClient.account;
+    if (account === void 0) {
+      throw new QuipSwapError({
+        code: "MISSING_ACCOUNT",
+        message: "The wallet client has no account; hoist an account onto the wallet client"
+      });
+    }
+    return { wallet: walletClient, sender: account.address };
+  }
+  async function chainTimestamp() {
+    const block = await publicClient.getBlock();
+    return block.timestamp;
+  }
+  async function isQuipWallet(account) {
+    const factory = await getQuipFactory();
+    try {
+      const vaultId = await publicClient.readContract({
+        address: factory,
+        abi: quipFactoryAbi,
+        functionName: "vaultIdOf",
+        args: [account]
+      });
+      return BigInt(vaultId) !== 0n;
+    } catch (error) {
+      throw wrapContractError(error, "Reading vaultIdOf from QUIP_FACTORY");
+    }
+  }
+  async function readLockBatch(lock, postedDigest) {
+    const [state, onChainTermsHash, isPosted] = await Promise.all([
+      read("lockState", [lock]),
+      read("termsHash", [lock]),
+      read("posted", [lock, postedDigest])
+    ]);
+    return { state, onChainTermsHash, isPosted };
+  }
+  function checkTermsHash(lock, onChainTermsHash, party, counterparty) {
+    const expected = digestTermsCanonically(party, counterparty);
+    if (onChainTermsHash.toLowerCase() !== expected.toLowerCase()) {
+      throw new QuipSwapError({
+        code: "TERMS_NOT_ON_CHAIN",
+        message: "The on-chain termsHash for this lock does not match the canonical digest of the supplied terms (contract would revert TermsMismatch)",
+        details: { lock, onChainTermsHash, expected }
+      });
+    }
+  }
+  function checkPosted(lock, isPosted) {
+    if (!isPosted) {
+      throw new QuipSwapError({
+        code: "TERMS_NOT_ON_CHAIN",
+        message: "The required side's terms have not been posted for this lock (contract would revert TermsNotPosted)",
+        details: { lock }
+      });
+    }
+  }
+  async function verifyClaimState(lock, party, counterparty) {
+    const { state, onChainTermsHash, isPosted } = await readLockBatch(lock, digestTerms(counterparty));
+    if (state !== 2 /* Committed */) {
+      const cause = state === 0 /* Unused */ ? "nothing has been committed under this lock on this chain \u2014 either the swap was never committed here, or the supplied secret is not the preimage for this swap (a wrong secret derives a different lock)" : state === 1 /* Free */ ? "the counterparty has not committed yet (same-chain swap is half-committed)" : "the lock was already claimed or reclaimed";
+      throw new QuipSwapError({
+        code: "INVALID_LOCK_STATE",
+        message: `Cannot claim: lock state is ${lockStateName(state)} but claim requires Committed \u2014 ${cause} (contract would revert InvalidLockState)`,
+        details: { lock, lockState: state, required: "Committed" }
+      });
+    }
+    checkTermsHash(lock, onChainTermsHash, party, counterparty);
+    checkPosted(lock, isPosted);
+  }
+  async function verifyReclaimState(lock, party, counterparty) {
+    const { state, onChainTermsHash, isPosted } = await readLockBatch(lock, digestTerms(party));
+    if (state !== 1 /* Free */ && state !== 2 /* Committed */) {
+      const cause = state === 0 /* Unused */ ? "nothing has been committed under this lock on this chain" : "the lock was already claimed or reclaimed";
+      throw new QuipSwapError({
+        code: "INVALID_LOCK_STATE",
+        message: `Cannot reclaim: lock state is ${lockStateName(state)} but reclaim requires Free or Committed \u2014 ${cause} (contract would revert InvalidLockAdvancement)`,
+        details: { lock, lockState: state, required: "Free or Committed" }
+      });
+    }
+    checkTermsHash(lock, onChainTermsHash, party, counterparty);
+    checkPosted(lock, isPosted);
+  }
+  async function verifyCommitState(lock, party, counterparty) {
+    const { state, onChainTermsHash, isPosted } = await readLockBatch(lock, digestTerms(party));
+    if (state === 3 /* Spent */ || state === 2 /* Committed */) {
+      throw new QuipSwapError({
+        code: "INVALID_LOCK_STATE",
+        message: `Cannot commit: lock state is ${lockStateName(state)} and no commit can advance from it (contract would revert InvalidLockAdvancement)`,
+        details: { lock, lockState: state, required: "Unused or Free" }
+      });
+    }
+    if (state === 1 /* Free */) {
+      checkTermsHash(lock, onChainTermsHash, party, counterparty);
+      if (isPosted) {
+        throw new QuipSwapError({
+          code: "TERMS_ALREADY_POSTED",
+          message: "This side's terms are already posted for the lock; the second same-chain commit must post the OTHER side (contract would revert TermsAlreadyPosted)",
+          details: { lock, partyDigest: digestTerms(party) }
+        });
+      }
+    }
+  }
+  async function submitWrite(params) {
+    const prepared = await prepareTx({
+      publicClient,
+      contractParams: {
+        address,
+        abi: omnibusAbi,
+        functionName: params.functionName,
+        args: params.args,
+        ...params.value !== void 0 ? { value: params.value } : {},
+        account: params.sender
+      },
+      totalValue: params.value ?? 0n,
+      ...params.opts !== void 0 ? { opts: params.opts } : {}
+    });
+    try {
+      return await params.wallet.writeContract({
+        ...contract,
+        functionName: params.functionName,
+        args: params.args,
+        account: params.wallet.account ?? params.sender,
+        chain: params.wallet.chain ?? publicClient.chain ?? null,
+        ...params.value !== void 0 ? { value: params.value } : {},
+        gas: prepared.gas,
+        ...prepared.fees,
+        ...prepared.nonce !== void 0 ? { nonce: prepared.nonce } : {}
+        // dynamic functionName + optional payable value cannot satisfy viem's
+        // conditional parameter types statically; the runtime shape is
+        // exercised by the mocked-client and Anvil integration suites
+      });
+    } catch (error) {
+      if (error instanceof BaseError3 && error.walk((e) => e instanceof InsufficientFundsError) !== null) {
+        throw new QuipSwapError({
+          code: "BALANCE_TOO_LOW",
+          message: `Sender cannot cover gas for ${params.functionName}; fund the account and retry`,
+          cause: error
+        });
+      }
+      throw wrapContractError(error, params.context);
+    }
+  }
+  const admin = {
+    async setCommitmentFee(newFee, opts) {
+      const { wallet, sender } = requireWallet();
+      return submitWrite({ wallet, sender, functionName: "setCommitmentFee", args: [newFee], opts, context: "setCommitmentFee" });
+    },
+    async withdrawFees(to, opts) {
+      const { wallet, sender } = requireWallet();
+      return submitWrite({ wallet, sender, functionName: "withdrawFees", args: [to], opts, context: "withdrawFees" });
+    },
+    async transferOwnership(newOwner, opts) {
+      const { wallet, sender } = requireWallet();
+      return submitWrite({
+        wallet,
+        sender,
+        functionName: "transferOwnership",
+        args: [newOwner],
+        opts,
+        context: "transferOwnership"
+      });
+    },
+    async acceptOwnership(opts) {
+      const { wallet, sender } = requireWallet();
+      return submitWrite({ wallet, sender, functionName: "acceptOwnership", args: [], opts, context: "acceptOwnership" });
+    }
+  };
+  return {
+    address,
+    publicClient,
+    getVersion: () => read("VERSION"),
+    getMaxFee: () => read("MAX_FEE"),
+    getQuipFactory,
+    getCommitmentFee: () => read("commitmentFee"),
+    getAccruedFees: () => read("accruedFees"),
+    getLockState: async (lock) => {
+      assertHex32(lock, "lock");
+      const state = await read("lockState", [lock]);
+      return state;
+    },
+    getTermsHash: (lock) => {
+      assertHex32(lock, "lock");
+      return read("termsHash", [lock]);
+    },
+    getPosted: (lock, termsDigest) => {
+      assertHex32(lock, "lock");
+      assertHex32(termsDigest, "termsDigest");
+      return read("posted", [lock, termsDigest]);
+    },
+    getOwner: () => read("owner"),
+    getPendingOwner: () => read("pendingOwner"),
+    isQuipWallet,
+    // confirm a write and decode events, always scoped to this client's
+    // Omnibus address (the client knows the right address for its chain)
+    waitForReceipt: (hash, options = {}) => waitForOmnibusReceipt(publicClient, hash, { ...options, address }),
+    // @audit-ok
+    async commit({ lock, party, counterparty, verifyOnChainState = true }, opts) {
+      assertHex32(lock, "lock");
+      const { wallet, sender } = requireWallet();
+      validateTerms(party);
+      validateTerms(counterparty);
+      validateTermPairing(party, counterparty);
+      const connectedChainId = BigInt(await publicClient.getChainId());
+      if (party.chainId !== connectedChainId) {
+        throw new QuipSwapError({
+          code: "CHAIN_ID_MISMATCH",
+          message: `party.chainId (${party.chainId}) does not match the connected chain (${connectedChainId}); commit must be sent on the chain holding the party's assets (contract: ChainIdMismatch)`,
+          details: { partyChainId: party.chainId, connectedChainId }
+        });
+      }
+      if (!await isQuipWallet(sender)) {
+        throw new QuipSwapError({
+          code: "NOT_QUIP_WALLET",
+          message: `Sender ${sender} is not a factory-deployed QuipWallet (QUIP_FACTORY.vaultIdOf is zero); only QuipWallet contracts can commit (contract: CallerNotQuipWallet). The committer must be the QuipWallet CONTRACT address \u2014 never substitute the wallet owner's EOA`,
+          details: { sender }
+        });
+      }
+      const timestamp = await chainTimestamp();
+      try {
+        validateCommitWindow(party, counterparty, timestamp);
+      } catch (error) {
+        if (error instanceof QuipSwapError && error.code === "WINDOW_VIOLATED" && proposedBy(party, counterparty) === "counterparty" && timestamp < counterparty.commitmentDeadline) {
+          throw new QuipSwapError({
+            code: "WINDOW_VIOLATED",
+            message: `Taker commit window has not opened yet: it opens at the proposer's commitmentDeadline (${counterparty.commitmentDeadline}) and the chain time is ${timestamp}. Wait for the proposer's deadline to elapse before committing`,
+            details: { opensAt: counterparty.commitmentDeadline, timestamp },
+            cause: error
+          });
+        }
+        throw error;
+      }
+      if (verifyOnChainState) {
+        await verifyCommitState(lock, party, counterparty);
+      }
+      const fee = await read("commitmentFee");
+      const value = totalNative(party) + fee;
+      return submitWrite({
+        wallet,
+        sender,
+        functionName: "commit",
+        args: [lock, toAbiTerms(party), toAbiTerms(counterparty)],
+        value,
+        opts,
+        context: "commit"
+      });
+    },
+    async claim({ secret, party, counterparty, verifyOnChainState = true }, opts) {
+      assertHex32(secret, "secret");
+      const lock = generateLock(secret);
+      const { wallet, sender } = requireWallet();
+      validateTerms(party);
+      validateTerms(counterparty);
+      validateTermPairing(party, counterparty);
+      const connectedChainId = BigInt(await publicClient.getChainId());
+      if (counterparty.chainId !== connectedChainId) {
+        throw new QuipSwapError({
+          code: "CHAIN_ID_MISMATCH",
+          message: `counterparty.chainId (${counterparty.chainId}) does not match the connected chain (${connectedChainId}); claim must be sent on the chain holding the counterparty's assets (contract: ChainIdMismatch)`,
+          details: { counterpartyChainId: counterparty.chainId, connectedChainId }
+        });
+      }
+      const timestamp = await chainTimestamp();
+      validateClaimWindow(party, counterparty, timestamp);
+      if (verifyOnChainState) {
+        await verifyClaimState(lock, party, counterparty);
+      }
+      return submitWrite({
+        wallet,
+        sender,
+        functionName: "claim",
+        args: [secret, toAbiTerms(party), toAbiTerms(counterparty)],
+        opts,
+        context: "claim"
+      });
+    },
+    async reclaim({ lock, party, counterparty, verifyOnChainState = true }, opts) {
+      assertHex32(lock, "lock");
+      const { wallet, sender } = requireWallet();
+      validateTerms(party);
+      validateTerms(counterparty);
+      validateTermPairing(party, counterparty);
+      const connectedChainId = BigInt(await publicClient.getChainId());
+      if (party.chainId !== connectedChainId) {
+        throw new QuipSwapError({
+          code: "CHAIN_ID_MISMATCH",
+          message: `party.chainId (${party.chainId}) does not match the connected chain (${connectedChainId}); reclaim must be sent on the chain holding the party's assets (contract: ChainIdMismatch)`,
+          details: { partyChainId: party.chainId, connectedChainId }
+        });
+      }
+      const timestamp = await chainTimestamp();
+      validateReclaimWindow(party, timestamp);
+      if (verifyOnChainState) {
+        await verifyReclaimState(lock, party, counterparty);
+      }
+      return submitWrite({
+        wallet,
+        sender,
+        functionName: "reclaim",
+        args: [lock, toAbiTerms(party), toAbiTerms(counterparty)],
+        opts,
+        context: "reclaim"
+      });
+    },
+    admin
+  };
+}
+
+// src/approvals.ts
+var erc20Abi = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var erc721Abi = [
+  {
+    type: "function",
+    name: "getApproved",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "isApprovedForAll",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "setApprovalForAll",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    outputs: []
+  }
+];
+var erc1155Abi = [
+  {
+    type: "function",
+    name: "isApprovedForAll",
+    stateMutability: "view",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "setApprovalForAll",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    outputs: []
+  }
+];
+async function planApprovals(args) {
+  const { publicClient, omnibusAddress, committer, terms } = args;
+  const erc20Required = /* @__PURE__ */ new Map();
+  const erc721Items = [];
+  const erc1155Tokens = /* @__PURE__ */ new Map();
+  for (const asset of terms.assets) {
+    if (asset.assetType === 0 /* Native */) continue;
+    if (asset.assetType === 1 /* ERC20 */) {
+      const key = asset.target.toLowerCase();
+      const existing = erc20Required.get(key);
+      erc20Required.set(key, { token: asset.target, amount: (existing?.amount ?? 0n) + asset.amount });
+    } else if (asset.assetType === 2 /* ERC721 */) {
+      erc721Items.push({ token: asset.target, tokenId: asset.id });
+    } else {
+      erc1155Tokens.set(asset.target.toLowerCase(), asset.target);
+    }
+  }
+  const items = [];
+  try {
+    for (const { token, amount } of erc20Required.values()) {
+      const currentAllowance = await publicClient.readContract({
+        address: token,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [committer, omnibusAddress]
+      });
+      items.push({
+        kind: "erc20",
+        token,
+        requiredAllowance: amount,
+        currentAllowance,
+        satisfied: currentAllowance >= amount
+      });
+    }
+    for (const { token, tokenId } of erc721Items) {
+      const [approvedAddress, operatorApproved] = await Promise.all([
+        publicClient.readContract({ address: token, abi: erc721Abi, functionName: "getApproved", args: [tokenId] }),
+        publicClient.readContract({
+          address: token,
+          abi: erc721Abi,
+          functionName: "isApprovedForAll",
+          args: [committer, omnibusAddress]
+        })
+      ]);
+      const tokenApproved = approvedAddress.toLowerCase() === omnibusAddress.toLowerCase();
+      items.push({
+        kind: "erc721",
+        token,
+        tokenId,
+        tokenApproved,
+        operatorApproved,
+        satisfied: tokenApproved || operatorApproved
+      });
+    }
+    for (const token of erc1155Tokens.values()) {
+      const operatorApproved = await publicClient.readContract({
+        address: token,
+        abi: erc1155Abi,
+        functionName: "isApprovedForAll",
+        args: [committer, omnibusAddress]
+      });
+      items.push({ kind: "erc1155", token, operatorApproved, satisfied: operatorApproved });
+    }
+  } catch (error) {
+    throw wrapContractError(error, "Reading token approvals");
+  }
+  return { committer, omnibusAddress, items, satisfied: items.every((item) => item.satisfied) };
+}
+var MAX_UINT2562 = (1n << 256n) - 1n;
+async function submitApproval(args) {
+  const { publicClient, walletClient, omnibusAddress, item } = args;
+  const account = walletClient.account;
+  if (account === void 0) {
+    throw new QuipSwapError({
+      code: "MISSING_ACCOUNT",
+      message: "The wallet client must have an account to submit an approval"
+    });
+  }
+  try {
+    if (item.kind === "erc20") {
+      if (args.erc20Mode === void 0) {
+        throw new QuipSwapError({
+          code: "INVALID_RANGE",
+          message: "ERC-20 approvals require an explicit erc20Mode ('exact' or 'unlimited'); the SDK never defaults to unlimited"
+        });
+      }
+      const amount = args.erc20Mode === "exact" ? item.requiredAllowance : MAX_UINT2562;
+      const { request: request2 } = await publicClient.simulateContract({
+        address: item.token,
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [omnibusAddress, amount],
+        account
+      });
+      return await walletClient.writeContract(request2);
+    }
+    if (item.kind === "erc721") {
+      if ((args.erc721Mode ?? "token") === "token") {
+        const { request: request3 } = await publicClient.simulateContract({
+          address: item.token,
+          abi: erc721Abi,
+          functionName: "approve",
+          args: [omnibusAddress, item.tokenId],
+          account
+        });
+        return await walletClient.writeContract(request3);
+      }
+      const { request: request2 } = await publicClient.simulateContract({
+        address: item.token,
+        abi: erc721Abi,
+        functionName: "setApprovalForAll",
+        args: [omnibusAddress, true],
+        account
+      });
+      return await walletClient.writeContract(request2);
+    }
+    const { request } = await publicClient.simulateContract({
+      address: item.token,
+      abi: erc1155Abi,
+      functionName: "setApprovalForAll",
+      args: [omnibusAddress, true],
+      account
+    });
+    return await walletClient.writeContract(request);
+  } catch (error) {
+    if (error instanceof QuipSwapError) throw error;
+    throw wrapContractError(error, `Approving ${item.kind} ${item.token}`);
+  }
+}
+
+// src/buffers.ts
+var DEFAULT_BUFFERS = {
+  /** ~5 min — fast-finality L2s. */
+  fastL2: 300n,
+  /** ~30 min — general default. */
+  standard: 1800n,
+  /** ~1 hr — congested / deep-reorg-risk L1s. */
+  conservativeL1: 3600n
+};
+var DEFAULT_CROSS_CHAIN_BUFFER_SECONDS = DEFAULT_BUFFERS.standard;
+var DEFAULT_SAME_CHAIN_BUFFER_SECONDS = DEFAULT_BUFFERS.standard;
+function checkScheduleBuffers(proposerTerms, takerTerms, minimumBufferSeconds) {
+  const sequence = [
+    ["proposer.commitmentDeadline", proposerTerms.commitmentDeadline],
+    ["taker.commitmentDeadline", takerTerms.commitmentDeadline],
+    ["proposer.claimDeadline", proposerTerms.claimDeadline],
+    ["taker.claimDeadline", takerTerms.claimDeadline],
+    ["proposer.reclaimRelease", proposerTerms.reclaimRelease],
+    ["taker.reclaimRelease", takerTerms.reclaimRelease]
+  ];
+  let minimumGapSeconds;
+  for (let i = 1; i < sequence.length; i++) {
+    const [prevName, prev] = sequence[i - 1];
+    const [nextName, next] = sequence[i];
+    const gap = next - prev;
+    if (gap < minimumBufferSeconds) {
+      throw new QuipSwapError({
+        code: "INSUFFICIENT_BUFFER",
+        message: `Gap between ${prevName} (${prev}) and ${nextName} (${next}) is ${gap}s, below the required minimum of ${minimumBufferSeconds}s. Every adjacent gap \u2014 especially the taker's post-reveal reaction buffer (proposer.reclaimRelease - proposer.claimDeadline) \u2014 must cover finality, reorg risk, RPC outages, congestion, and relayer latency`,
+        details: { prevName, prev, nextName, next, gap, minimumBufferSeconds }
+      });
+    }
+    if (minimumGapSeconds === void 0 || gap < minimumGapSeconds) minimumGapSeconds = gap;
+  }
+  return { minimumGapSeconds: minimumGapSeconds ?? 0n };
+}
+
+// src/workflows/sameChain.ts
+function planSameChainSwap(a, b, opts) {
+  validateTerms(a);
+  validateTerms(b);
+  validateTermPairing(a, b);
+  if (a.chainId !== b.chainId) {
+    throw new QuipSwapError({
+      code: "CHAIN_ID_MISMATCH",
+      message: `Same-chain plan requires both sides on one chain; got ${a.chainId} and ${b.chainId}`,
+      details: { aChainId: a.chainId, bChainId: b.chainId }
+    });
+  }
+  const [proposerTerms, takerTerms] = proposedBy(a, b) === "party" ? [a, b] : [b, a];
+  checkScheduleBuffers(proposerTerms, takerTerms, opts?.minimumBufferSeconds ?? DEFAULT_SAME_CHAIN_BUFFER_SECONDS);
+  return {
+    proposerTerms,
+    takerTerms,
+    canonicalDigest: digestTermsCanonically(proposerTerms, takerTerms),
+    proposerDigest: digestTerms(proposerTerms),
+    takerDigest: digestTerms(takerTerms),
+    proposerCommitWindow: proposerCommitWindow(proposerTerms),
+    takerCommitWindow: takerCommitWindow(takerTerms, proposerTerms),
+    claimWindow: proposerClaimWindow(proposerTerms, takerTerms),
+    proposerReclaimWindow: reclaimWindow(proposerTerms),
+    takerReclaimWindow: reclaimWindow(takerTerms)
+  };
+}
+async function getSameChainSwapStatus(client, lock, plan) {
+  const [state, proposerPosted, takerPosted, block] = await Promise.all([
+    client.getLockState(lock),
+    client.getPosted(lock, plan.proposerDigest),
+    client.getPosted(lock, plan.takerDigest),
+    client.publicClient.getBlock()
+  ]);
+  const timestamp = block.timestamp;
+  let status;
+  switch (state) {
+    case 0 /* Unused */:
+      status = isWithinWindow(plan.proposerCommitWindow, timestamp) ? "awaiting-proposer-commit" : "proposer-commit-expired";
+      break;
+    case 1 /* Free */:
+      if (isWithinWindow(plan.proposerReclaimWindow, timestamp)) {
+        status = "reclaimable-from-free";
+      } else if (timestamp < plan.takerCommitWindow.lower) {
+        status = "awaiting-taker-window";
+      } else if (isWithinWindow(plan.takerCommitWindow, timestamp)) {
+        status = "awaiting-taker-commit";
+      } else {
+        status = "half-committed-expired";
+      }
+      break;
+    case 2 /* Committed */:
+      if (isWithinWindow(plan.claimWindow, timestamp)) {
+        status = "claimable";
+      } else if (isWithinWindow(plan.proposerReclaimWindow, timestamp)) {
+        status = "reclaimable";
+      } else if (timestamp >= plan.proposerTerms.claimDeadline) {
+        status = "late-claimable";
+      } else {
+        status = "awaiting-claim-window";
+      }
+      break;
+    case 3 /* Spent */:
+      status = "settled";
+      break;
+  }
+  return { status, lockState: state, proposerPosted, takerPosted, timestamp };
+}
+
+// src/workflows/crossChain.ts
+function validateCrossChainSchedule(args) {
+  const { proposerTerms, takerTerms } = args;
+  const minimumBufferSeconds = args.minimumBufferSeconds ?? DEFAULT_CROSS_CHAIN_BUFFER_SECONDS;
+  validateTerms(proposerTerms);
+  validateTerms(takerTerms);
+  validateTermPairing(proposerTerms, takerTerms);
+  if (proposedBy(proposerTerms, takerTerms) !== "party") {
+    throw new QuipSwapError({
+      code: "SECRET_HOLDER_NOT_PROPOSER",
+      message: "The secret holder's leg must be the proposer (smaller commitmentDeadline). A secret-holding taker could claim the counterparty leg while letting its own leg expire \u2014 the cross-chain free option. Swap the role assignment or rebuild the schedule",
+      details: {
+        proposerCommitmentDeadline: proposerTerms.commitmentDeadline,
+        takerCommitmentDeadline: takerTerms.commitmentDeadline
+      }
+    });
+  }
+  if (proposerTerms.chainId === takerTerms.chainId) {
+    throw new QuipSwapError({
+      code: "CHAIN_ID_MISMATCH",
+      message: `Cross-chain schedule requires the two legs on different chains; both are on ${proposerTerms.chainId}`,
+      details: { chainId: proposerTerms.chainId }
+    });
+  }
+  const { minimumGapSeconds } = checkScheduleBuffers(proposerTerms, takerTerms, minimumBufferSeconds);
+  return {
+    proposerTerms,
+    takerTerms,
+    // reactionBuffer = proposer.reclaimRelease - proposer.claimDeadline
+    reactionBufferSeconds: proposerTerms.reclaimRelease - proposerTerms.claimDeadline,
+    minimumGapSeconds
+  };
+}
+async function verifyRemoteCommitment(remoteClient, lock, proposerTerms, takerTerms) {
+  const [state, proposerPosted, onChainTermsHash] = await Promise.all([
+    remoteClient.getLockState(lock),
+    remoteClient.getPosted(lock, digestTerms(proposerTerms)),
+    remoteClient.getTermsHash(lock)
+  ]);
+  const termsHashMatches = onChainTermsHash.toLowerCase() === digestTermsCanonically(proposerTerms, takerTerms).toLowerCase();
+  return {
+    // cross-chain local commits move Unused -> Committed directly
+    committed: state === 2 /* Committed */ && proposerPosted && termsHashMatches,
+    lockState: state,
+    proposerPosted,
+    termsHashMatches
+  };
+}
+function deriveSharedLock(secret) {
+  return generateLock(secret);
+}
+export {
+  AssetType,
+  DEFAULT_BUFFERS,
+  DEFAULT_CROSS_CHAIN_BUFFER_SECONDS,
+  DEFAULT_GAS_MULTIPLIER,
+  DEFAULT_SAME_CHAIN_BUFFER_SECONDS,
+  LockState,
+  MAX_GAS_MULTIPLIER,
+  MAX_UINT256,
+  MIN_GAS_MULTIPLIER,
+  OMNIBUS_CREATE3_ADDRESS,
+  QuipSwapError,
+  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
+};
+//# sourceMappingURL=index.js.map