@masterpeach/market-sdk 0.2.0-beta.20260930.1

package/dist/index.js

@@ -0,0 +1,2705 @@
+import {
+  createPreparedTransactionStore,
+  immutableClone,
+  resolveLiveWalletAccount,
+  transactionResultFromReceipt
+} from "./chunk-TMU4HSZR.js";
+import {
+  marketAccessManagerAbi,
+  marketClaimFeePolicyAbi,
+  marketExtsloadAbi,
+  marketMarketCalendarAbi,
+  marketPoolRegistryAbi,
+  marketRampAbi,
+  marketRampReaderAbi,
+  marketRwaRampAbi,
+  marketStateViewAbi
+} from "./chunk-TTVBOGKZ.js";
+
+// src/actions/authorizations.ts
+import { getAddress as getAddress3 } from "viem";
+
+// src/errors.ts
+var InvalidMarketConfigError = class extends Error {
+  constructor(field, message) {
+    super(message);
+    this.field = field;
+    this.name = "InvalidMarketConfigError";
+  }
+  field;
+};
+var MarketDeploymentVerificationError = class extends Error {
+  constructor(field, expected, actual) {
+    super(`Market deployment mismatch: ${field}.`);
+    this.field = field;
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "MarketDeploymentVerificationError";
+  }
+  field;
+  expected;
+  actual;
+};
+var MarketReadError = class extends Error {
+  constructor(cause) {
+    super("Market RPC read failed. Inspect cause for transport or contract revert details.", {
+      cause
+    });
+    this.name = "MarketReadError";
+  }
+};
+var MarketFeatureUnavailableError = class extends Error {
+  constructor(feature) {
+    super(`Market feature is unavailable for this configuration: ${feature}.`);
+    this.feature = feature;
+    this.name = "MarketFeatureUnavailableError";
+  }
+  feature;
+};
+var MarketSettlingError = class extends Error {
+  constructor(hook2) {
+    super("The Market ledger is settling; a consistent position snapshot is unavailable.");
+    this.hook = hook2;
+    this.name = "MarketSettlingError";
+  }
+  hook;
+};
+var MarketTransactionError = class extends Error {
+  constructor(stage, cause) {
+    super(
+      `Market transaction ${stage} failed. Inspect cause for RPC, signature or contract details.`,
+      { cause }
+    );
+    this.stage = stage;
+    this.name = "MarketTransactionError";
+  }
+  stage;
+};
+var MarketTransactionReplacedError = class extends Error {
+  constructor(originalHash, replacementHash, reason) {
+    super(`Market transaction was ${reason}; inspect the replacement before continuing.`);
+    this.originalHash = originalHash;
+    this.replacementHash = replacementHash;
+    this.reason = reason;
+    this.name = "MarketTransactionReplacedError";
+  }
+  originalHash;
+  replacementHash;
+  reason;
+};
+
+// src/math/identifiers.ts
+import {
+  encodeAbiParameters,
+  getAddress,
+  isAddress,
+  isAddressEqual,
+  keccak256,
+  zeroAddress
+} from "viem";
+function assertMarketUint(value, field, bits = 256) {
+  if (typeof value !== "bigint" || value < 0n || value >= 1n << BigInt(bits)) {
+    throw new InvalidMarketConfigError(field, `Expected a uint${bits} bigint.`);
+  }
+}
+function assertMarketPoolId(value) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {
+    throw new InvalidMarketConfigError("poolId", "Expected a 32-byte pool ID.");
+  }
+}
+function assertMarketAddress(address, field, allowNative = false) {
+  if (!isAddress(address) || !allowNative && isAddressEqual(address, zeroAddress)) {
+    throw new InvalidMarketConfigError(field, "Expected a valid non-zero address.");
+  }
+}
+function defineMarketPoolKey(key) {
+  assertMarketAddress(key.currency0, "currency0", true);
+  assertMarketAddress(key.currency1, "currency1");
+  assertMarketAddress(key.hooks, "hooks");
+  if (BigInt(key.currency0) >= BigInt(key.currency1)) {
+    throw new InvalidMarketConfigError(
+      "currencies",
+      "Currencies must be distinct and sorted by address."
+    );
+  }
+  if (key.fee !== 8388608) {
+    throw new InvalidMarketConfigError(
+      "fee",
+      "Peach Market pools require the v4 dynamic fee flag."
+    );
+  }
+  if (!Number.isInteger(key.tickSpacing) || key.tickSpacing < 1 || key.tickSpacing > 32767) {
+    throw new InvalidMarketConfigError("tickSpacing", "Expected v4 tick spacing in [1, 32767].");
+  }
+  return Object.freeze({
+    currency0: getAddress(key.currency0),
+    currency1: getAddress(key.currency1),
+    fee: key.fee,
+    tickSpacing: key.tickSpacing,
+    hooks: getAddress(key.hooks)
+  });
+}
+function getMarketPoolId(input) {
+  const key = defineMarketPoolKey(input);
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { type: "address" },
+        { type: "address" },
+        { type: "uint24" },
+        { type: "int24" },
+        { type: "address" }
+      ],
+      [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]
+    )
+  );
+}
+function getMarketRangeId(poolId, tickLower, tickUpper, tickSpacing = 1) {
+  assertMarketPoolId(poolId);
+  if (!Number.isInteger(tickSpacing) || tickSpacing < 1 || tickSpacing > 32767) {
+    throw new InvalidMarketConfigError("tickSpacing", "Expected v4 tick spacing in [1, 32767].");
+  }
+  if (!Number.isInteger(tickLower) || !Number.isInteger(tickUpper) || tickLower < -887272 || tickUpper > 887272 || tickLower >= tickUpper || tickLower % tickSpacing !== 0 || tickUpper % tickSpacing !== 0) {
+    throw new InvalidMarketConfigError(
+      "ticks",
+      "Expected ordered, aligned ticks in the v4 tick range."
+    );
+  }
+  return BigInt(
+    keccak256(
+      encodeAbiParameters(
+        [{ type: "bytes32" }, { type: "int24" }, { type: "int24" }],
+        [poolId, tickLower, tickUpper]
+      )
+    )
+  );
+}
+function getMarketSwapDirection(key, base, quote, side) {
+  const normalized = defineMarketPoolKey(key);
+  assertMarketAddress(base, "base", true);
+  assertMarketAddress(quote, "quote", true);
+  const baseIs0 = isAddressEqual(base, normalized.currency0) && isAddressEqual(quote, normalized.currency1);
+  const baseIs1 = isAddressEqual(base, normalized.currency1) && isAddressEqual(quote, normalized.currency0);
+  if (!baseIs0 && !baseIs1 || side !== "buy" && side !== "sell") {
+    throw new InvalidMarketConfigError(
+      "direction",
+      "Base/quote must match both pool currencies and side must be buy/sell."
+    );
+  }
+  return side === "sell" ? baseIs0 : baseIs1;
+}
+
+// src/actions/snapshot.ts
+import { isAddressEqual as isAddressEqual2, keccak256 as keccak2562 } from "viem";
+
+// src/deployment.ts
+import { getAddress as getAddress2, isAddress as isAddress2, zeroAddress as zeroAddress2 } from "viem";
+function invalid(field, message) {
+  throw new InvalidMarketConfigError(field, message);
+}
+function contract(input, field) {
+  if (!isAddress2(input.address) || input.address.toLowerCase() === zeroAddress2) {
+    invalid(`${field}.address`, "Expected a non-zero EVM address.");
+  }
+  if (!/^0x[0-9a-fA-F]{64}$/.test(input.runtimeCodeHash) || /^0x0+$/.test(input.runtimeCodeHash)) {
+    invalid(`${field}.runtimeCodeHash`, "Expected a non-zero 32-byte runtime code hash.");
+  }
+  return Object.freeze({
+    address: getAddress2(input.address),
+    runtimeCodeHash: input.runtimeCodeHash
+  });
+}
+var capabilityKeys = ["liquidity", "nativeLiquidity", "claimOperator", "management"];
+function hook(input, index) {
+  const field = `hooks.${index}`;
+  if (!["ramp", "ramp-eth", "rwa-ramp"].includes(input.kind)) {
+    invalid(`${field}.kind`, "Unsupported Market Hook kind.");
+  }
+  if (input.implementation !== "ramp-v1") {
+    invalid(`${field}.implementation`, "Unsupported Market implementation.");
+  }
+  if (input.kind === "rwa-ramp" !== (input.calendar !== void 0)) {
+    invalid(`${field}.calendar`, "Only RWA Hooks must include a calendar.");
+  }
+  for (const key of capabilityKeys) {
+    if (!["disabled", "unverified", "verified"].includes(input.capabilities[key])) {
+      invalid(`${field}.capabilities.${key}`, "Explicit capability acceptance status is required.");
+    }
+  }
+  if (input.kind !== "ramp-eth" && input.capabilities.nativeLiquidity !== "disabled") {
+    invalid(`${field}.capabilities.nativeLiquidity`, "Native liquidity requires RampETH.");
+  }
+  const capabilities = Object.freeze({
+    liquidity: input.capabilities.liquidity,
+    nativeLiquidity: input.capabilities.nativeLiquidity,
+    claimOperator: input.capabilities.claimOperator,
+    management: input.capabilities.management
+  });
+  return Object.freeze({
+    ...contract(input, field),
+    kind: input.kind,
+    implementation: input.implementation,
+    claimFeePolicy: contract(input.claimFeePolicy, `${field}.claimFeePolicy`),
+    ...input.calendar ? { calendar: contract(input.calendar, `${field}.calendar`) } : {},
+    capabilities
+  });
+}
+function defineMarketDeployment(input) {
+  if (!Number.isSafeInteger(input.chainId) || input.chainId <= 0) {
+    invalid("chainId", "Expected a positive safe integer.");
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(input.deploymentId)) {
+    invalid("deploymentId", "Expected a non-empty lowercase deployment identifier.");
+  }
+  if (input.hooks.length === 0) invalid("hooks", "At least one supported Hook is required.");
+  const hooks = input.hooks.map(hook);
+  if (new Set(hooks.map((entry) => entry.address)).size !== hooks.length) {
+    invalid("hooks", "Duplicate Hook addresses are not allowed.");
+  }
+  let poolStateReader;
+  if (input.poolStateReader?.kind === "state-view") {
+    poolStateReader = Object.freeze({
+      kind: "state-view",
+      contract: contract(input.poolStateReader.contract, "poolStateReader.contract")
+    });
+  } else if (input.poolStateReader?.kind === "extsload") {
+    if (input.poolStateReader.layout !== "uniswap-v4-v1") {
+      invalid("poolStateReader.layout", "Unsupported PoolManager storage layout.");
+    }
+    poolStateReader = Object.freeze({ kind: "extsload", layout: "uniswap-v4-v1" });
+  } else if (input.poolStateReader !== void 0) {
+    invalid("poolStateReader.kind", "Unsupported pool state reader.");
+  }
+  return Object.freeze({
+    chainId: input.chainId,
+    deploymentId: input.deploymentId,
+    poolManager: contract(input.poolManager, "poolManager"),
+    registry: contract(input.registry, "registry"),
+    authority: contract(input.authority, "authority"),
+    ...input.reader ? { reader: contract(input.reader, "reader") } : {},
+    ...poolStateReader ? { poolStateReader } : {},
+    hooks: Object.freeze(hooks)
+  });
+}
+
+// src/actions/snapshot.ts
+async function readMarketSnapshot(context, options, read) {
+  const deployment = defineMarketDeployment(context.deployment);
+  const publicClient = context.publicClient;
+  const { blockNumber, blockHash } = options;
+  if (blockNumber !== void 0) assertMarketUint(blockNumber, "blockNumber");
+  if (blockHash !== void 0 && (blockNumber === void 0 || !/^0x[0-9a-fA-F]{64}$/.test(blockHash))) {
+    throw new InvalidMarketConfigError(
+      "blockHash",
+      "A block hash requires a valid explicit block number."
+    );
+  }
+  try {
+    const chainId = await publicClient.getChainId();
+    if (chainId !== deployment.chainId)
+      throw new MarketDeploymentVerificationError("chainId", deployment.chainId, chainId);
+    const block = await publicClient.getBlock(
+      blockNumber === void 0 ? { blockTag: "latest" } : { blockNumber }
+    );
+    if (block.number === null || block.hash === null)
+      throw new MarketDeploymentVerificationError("block", "mined block", block);
+    if (blockNumber !== void 0 && block.number !== blockNumber)
+      throw new MarketDeploymentVerificationError("blockNumber", blockNumber, block.number);
+    if (blockHash !== void 0 && block.hash.toLowerCase() !== blockHash.toLowerCase())
+      throw new MarketDeploymentVerificationError("blockHash", blockHash, block.hash);
+    const snapshot = Object.freeze({
+      chainId,
+      deploymentId: deployment.deploymentId,
+      blockNumber: block.number,
+      blockHash: block.hash,
+      timestamp: block.timestamp
+    });
+    const data = await read({ publicClient, deployment, block: snapshot });
+    const finalBlock = await publicClient.getBlock({ blockNumber: block.number });
+    if (finalBlock.hash !== block.hash)
+      throw new MarketDeploymentVerificationError("blockHash", block.hash, finalBlock.hash);
+    return Object.freeze({ block: snapshot, data });
+  } catch (error) {
+    if (error instanceof InvalidMarketConfigError || error instanceof MarketDeploymentVerificationError || error instanceof MarketFeatureUnavailableError || error instanceof MarketSettlingError || error instanceof MarketReadError || error instanceof MarketTransactionError)
+      throw error;
+    throw new MarketReadError(error);
+  }
+}
+function requireMarketHook(scope, address) {
+  assertMarketAddress(address, "hook");
+  const hook2 = scope.deployment.hooks.find((entry) => isAddressEqual2(entry.address, address));
+  if (!hook2) throw new MarketFeatureUnavailableError(`unsupported Hook ${address}`);
+  return hook2;
+}
+async function assertMarketCode(scope, contract2) {
+  const code = await scope.publicClient.getCode({
+    address: contract2.address,
+    blockNumber: scope.block.blockNumber
+  });
+  const actual = code && code !== "0x" ? keccak2562(code) : null;
+  if (actual !== contract2.runtimeCodeHash.toLowerCase())
+    throw new MarketDeploymentVerificationError(contract2.address, contract2.runtimeCodeHash, actual);
+}
+
+// src/actions/authorizations.ts
+function getMarketShareAuthorization(context, params) {
+  assertMarketAddress(params.owner, "owner");
+  assertMarketAddress(params.operator, "operator");
+  assertMarketUint(params.rangeId, "rangeId");
+  const owner = getAddress3(params.owner);
+  const operator = getAddress3(params.operator);
+  const rangeId = params.rangeId;
+  const hook2 = requireMarketHook(context, params.hook).address;
+  return readMarketSnapshot(context, params, async (scope) => {
+    const target = {
+      address: hook2,
+      abi: marketRampAbi,
+      blockNumber: scope.block.blockNumber
+    };
+    if (await scope.publicClient.readContract({ ...target, functionName: "isSettling" }))
+      throw new MarketSettlingError(hook2);
+    const [shares, allowance, isShareOperator, isClaimOperator] = await Promise.all([
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "balanceOf",
+        args: [owner, rangeId]
+      }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "allowance",
+        args: [owner, operator, rangeId]
+      }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "isOperator",
+        args: [owner, operator]
+      }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "isClaimOperator",
+        args: [owner, rangeId, operator]
+      })
+    ]);
+    return { hook: hook2, rangeId, owner, operator, shares, allowance, isShareOperator, isClaimOperator };
+  });
+}
+function getMarketClaimOperator(context, params) {
+  const { owner, operator, rangeId } = params;
+  assertMarketAddress(owner, "owner");
+  assertMarketAddress(operator, "operator");
+  assertMarketUint(rangeId, "rangeId");
+  const hook2 = requireMarketHook(context, params.hook).address;
+  return readMarketSnapshot(context, params, async (scope) => ({
+    hook: hook2,
+    owner,
+    operator,
+    rangeId,
+    approved: await scope.publicClient.readContract({
+      address: hook2,
+      abi: marketRampAbi,
+      functionName: "isClaimOperator",
+      args: [owner, rangeId, operator],
+      blockNumber: scope.block.blockNumber
+    })
+  }));
+}
+
+// src/actions/earnings.ts
+import { encodeAbiParameters as encodeAbiParameters3, encodePacked, isAddressEqual as isAddressEqual4, keccak256 as keccak2564, toHex as toHex2 } from "viem";
+
+// src/math/earnings.ts
+var Q128 = 1n << 128n;
+function calculateMarketClaimableFees(ledger) {
+  const { position } = ledger;
+  const { state, effectiveClaimFeeBps } = position.range;
+  assertMarketUint(state.totalShares, "totalShares", 128);
+  assertMarketUint(position.shares, "shares", 128);
+  assertMarketUint(ledger.managerLiquidity, "managerLiquidity", 128);
+  if (position.shares > state.totalShares || state.totalShares !== ledger.managerLiquidity)
+    throw new InvalidMarketConfigError(
+      "liquidity",
+      "Hook shares and manager liquidity are inconsistent."
+    );
+  if (!Number.isInteger(effectiveClaimFeeBps) || effectiveClaimFeeBps < 0 || effectiveClaimFeeBps > 2e3)
+    throw new InvalidMarketConfigError("effectiveClaimFeeBps", "Invalid effective fee rate.");
+  function token(owed, acc, checkpoint, remainder, live, last) {
+    for (const [name, value] of [
+      ["acc", acc],
+      ["checkpoint", checkpoint],
+      ["live", live],
+      ["last", last]
+    ])
+      assertMarketUint(value, name);
+    assertMarketUint(owed, "owed", 128);
+    assertMarketUint(remainder, "remainder", 128);
+    if (checkpoint > acc)
+      throw new InvalidMarketConfigError(
+        "checkpoint",
+        "Net checkpoint exceeds the checked Hook accumulator."
+      );
+    const gross = state.totalShares === 0n ? 0n : BigInt.asUintN(256, live - last) * state.totalShares / Q128;
+    assertMarketUint(gross, "pendingRangeGross", 127);
+    const cut = gross * BigInt(effectiveClaimFeeBps) / 10000n;
+    const nextAcc = acc + (state.totalShares === 0n ? 0n : (gross - cut) * Q128 / state.totalShares);
+    assertMarketUint(nextAcc, "nextAccumulator");
+    const syncedNumerator = position.shares * (acc - checkpoint) + remainder;
+    const numerator = position.shares * (nextAcc - checkpoint) + remainder;
+    const synchronized = syncedNumerator / Q128;
+    const earned = numerator / Q128;
+    assertMarketUint(earned, "earned", 128);
+    assertMarketUint(owed + earned, "claimable", 128);
+    return {
+      settled: owed,
+      synchronized,
+      pending: earned - synchronized,
+      claimable: owed + earned,
+      remainderX128: numerator % Q128,
+      pendingRangeGross: gross,
+      pendingRangeProtocolFee: cut
+    };
+  }
+  const token0 = token(
+    position.settledOwed0,
+    state.accFee0X128,
+    position.checkpoint0X128,
+    position.remainder0X128,
+    ledger.growth0X128,
+    ledger.lastGrowth0X128
+  );
+  const token1 = token(
+    position.settledOwed1,
+    state.accFee1X128,
+    position.checkpoint1X128,
+    position.remainder1X128,
+    ledger.growth1X128,
+    ledger.lastGrowth1X128
+  );
+  return {
+    ledger,
+    token0,
+    token1,
+    paused: position.range.globalPaused || position.range.poolPaused,
+    hasClaimableAmount: token0.claimable > 0n || token1.claimable > 0n
+  };
+}
+
+// src/math/pool-state.ts
+import { encodeAbiParameters as encodeAbiParameters2, keccak256 as keccak2563, toHex } from "viem";
+function marketPoolStorageSlots(poolId) {
+  assertMarketPoolId(poolId);
+  const slot = keccak2563(
+    encodeAbiParameters2([{ type: "bytes32" }, { type: "uint256" }], [poolId, 6n])
+  );
+  return [slot, toHex((BigInt(slot) + 3n) % (1n << 256n), { size: 32 })];
+}
+function decodeMarketPoolStateWords(words) {
+  const [slot0, liquidity] = words;
+  if (words.length !== 2 || slot0 === void 0 || liquidity === void 0 || !/^0x[0-9a-fA-F]{64}$/.test(slot0) || !/^0x[0-9a-fA-F]{64}$/.test(liquidity)) {
+    throw new InvalidMarketConfigError("extsload", "Expected exactly two 32-byte storage words.");
+  }
+  const raw = BigInt(slot0);
+  return {
+    sqrtPriceX96: raw & (1n << 160n) - 1n,
+    tick: Number(BigInt.asIntN(24, raw >> 160n)),
+    protocolFeePacked: Number(raw >> 184n & 0xffffffn),
+    storedLpFeePips: Number(raw >> 208n & 0xffffffn),
+    activeLiquidity: BigInt(liquidity) & (1n << 128n) - 1n
+  };
+}
+
+// src/actions/positions.ts
+import { getAddress as getAddress4, isAddressEqual as isAddressEqual3 } from "viem";
+async function readRange(scope, params) {
+  const hook2 = requireMarketHook(scope, params.hook);
+  const target = {
+    address: hook2.address,
+    abi: marketRampAbi,
+    blockNumber: scope.block.blockNumber
+  };
+  if (await scope.publicClient.readContract({ ...target, functionName: "isSettling" }))
+    throw new MarketSettlingError(hook2.address);
+  const [rawKey, tickLower, tickUpper, set] = await scope.publicClient.readContract({
+    ...target,
+    functionName: "rangeKey",
+    args: [params.rangeId]
+  });
+  if (!set) return { status: "unset", hook: hook2.address, rangeId: params.rangeId };
+  const key = defineMarketPoolKey(rawKey);
+  if (!isAddressEqual3(key.hooks, hook2.address))
+    throw new MarketDeploymentVerificationError("rangeKey.hooks", hook2.address, key.hooks);
+  const poolId = getMarketPoolId(key);
+  const expectedId = getMarketRangeId(poolId, tickLower, tickUpper, key.tickSpacing);
+  if (expectedId !== params.rangeId)
+    throw new MarketDeploymentVerificationError("rangeId", params.rangeId, expectedId);
+  const [state, globalPaused, poolPaused, effectiveClaimFeeBps] = await Promise.all([
+    scope.publicClient.readContract({
+      ...target,
+      functionName: "rangeState",
+      args: [params.rangeId]
+    }),
+    scope.publicClient.readContract({ ...target, functionName: "paused" }),
+    scope.publicClient.readContract({ ...target, functionName: "pausedFor", args: [poolId] }),
+    scope.publicClient.readContract({
+      ...target,
+      functionName: "effectiveClaimFee",
+      args: [params.rangeId]
+    })
+  ]);
+  return {
+    status: "set",
+    hook: hook2.address,
+    rangeId: params.rangeId,
+    key,
+    poolId,
+    tickLower,
+    tickUpper,
+    state,
+    globalPaused,
+    poolPaused,
+    effectiveClaimFeeBps
+  };
+}
+function getMarketRange(context, params) {
+  const { hook: hook2, rangeId } = params;
+  assertMarketAddress(hook2, "hook");
+  assertMarketUint(rangeId, "rangeId");
+  return readMarketSnapshot(context, params, (scope) => readRange(scope, { hook: hook2, rangeId }));
+}
+function getMarketPosition(context, params) {
+  const { hook: hook2, rangeId } = params;
+  assertMarketAddress(hook2, "hook");
+  assertMarketUint(rangeId, "rangeId");
+  assertMarketAddress(params.owner, "owner");
+  const owner = getAddress4(params.owner);
+  return readMarketSnapshot(context, params, async (scope) => {
+    const range = await readRange(scope, { hook: hook2, rangeId });
+    const target = {
+      address: range.hook,
+      abi: marketRampAbi,
+      blockNumber: scope.block.blockNumber
+    };
+    const [shares, position, remainder] = await Promise.all([
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "balanceOf",
+        args: [owner, rangeId]
+      }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "userPosition",
+        args: [rangeId, owner]
+      }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "userFeeRemainder",
+        args: [rangeId, owner]
+      })
+    ]);
+    return {
+      range,
+      owner,
+      shares,
+      settledOwed0: position.owed0,
+      settledOwed1: position.owed1,
+      checkpoint0X128: position.checkpoint0X128,
+      checkpoint1X128: position.checkpoint1X128,
+      remainder0X128: remainder[0],
+      remainder1X128: remainder[1]
+    };
+  });
+}
+
+// src/actions/earnings.ts
+function getMarketFeeSnapshot(context, input) {
+  const params = immutableClone(input);
+  return readMarketSnapshot(context, params, async (scope) => {
+    const position = (await getMarketPosition(context, { ...params, ...scope.block })).data;
+    const range = position.range;
+    if (range.status !== "set")
+      throw new MarketFeatureUnavailableError("earnings for an unset range");
+    const hook2 = requireMarketHook(scope, range.hook);
+    const reader = scope.deployment.poolStateReader;
+    if (!reader)
+      throw new MarketFeatureUnavailableError("poolStateReader for gross position baseline");
+    for (const contract2 of [hook2, hook2.claimFeePolicy, scope.deployment.poolManager])
+      await assertMarketCode(scope, contract2);
+    const target = {
+      address: hook2.address,
+      abi: marketRampAbi,
+      blockNumber: scope.block.blockNumber
+    };
+    const policy = {
+      address: hook2.claimFeePolicy.address,
+      abi: marketClaimFeePolicyAbi,
+      blockNumber: scope.block.blockNumber
+    };
+    const [
+      manager,
+      policyAddress,
+      ledgerAddress,
+      growth,
+      claimFeeSyncIndex,
+      policyHistoryLength,
+      currentClaimFeeBps,
+      allTimeMinClaimFeeBps
+    ] = await Promise.all([
+      scope.publicClient.readContract({ ...target, functionName: "poolManager" }),
+      scope.publicClient.readContract({ ...target, functionName: "claimFeePolicy" }),
+      scope.publicClient.readContract({ ...policy, functionName: "ledger" }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "rangeGrowth",
+        args: [range.rangeId]
+      }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "claimFeeSyncIndex",
+        args: [range.rangeId]
+      }),
+      scope.publicClient.readContract({ ...policy, functionName: "length", args: [range.poolId] }),
+      scope.publicClient.readContract({ ...policy, functionName: "current", args: [range.poolId] }),
+      scope.publicClient.readContract({ ...policy, functionName: "minimum", args: [range.poolId] })
+    ]);
+    for (const [name, expected, actual] of [
+      ["manager", scope.deployment.poolManager.address, manager],
+      ["policy", hook2.claimFeePolicy.address, policyAddress],
+      ["ledger", hook2.address, ledgerAddress]
+    ]) {
+      if (!isAddressEqual4(expected, actual))
+        throw new MarketDeploymentVerificationError(name, expected, actual);
+    }
+    const positionId = keccak2564(
+      encodePacked(
+        ["address", "int24", "int24", "bytes32"],
+        [hook2.address, range.tickLower, range.tickUpper, toHex2(range.rangeId, { size: 32 })]
+      )
+    );
+    let managerState;
+    if (reader.kind === "state-view") {
+      await assertMarketCode(scope, reader.contract);
+      const view = {
+        address: reader.contract.address,
+        abi: marketStateViewAbi,
+        blockNumber: scope.block.blockNumber
+      };
+      const bound = await scope.publicClient.readContract({ ...view, functionName: "poolManager" });
+      if (!isAddressEqual4(bound, manager))
+        throw new MarketDeploymentVerificationError("stateView.poolManager", manager, bound);
+      managerState = await scope.publicClient.readContract({
+        ...view,
+        functionName: "getPositionInfo",
+        args: [range.poolId, positionId]
+      });
+    } else {
+      const poolSlot = marketPoolStorageSlots(range.poolId)[0];
+      const base = BigInt(
+        keccak2564(
+          encodeAbiParameters3(
+            [{ type: "bytes32" }, { type: "uint256" }],
+            [positionId, BigInt.asUintN(256, BigInt(poolSlot) + 6n)]
+          )
+        )
+      );
+      const slots = [0n, 1n, 2n].map(
+        (offset) => toHex2(BigInt.asUintN(256, base + offset), { size: 32 })
+      );
+      const words = await scope.publicClient.readContract({
+        address: manager,
+        abi: marketExtsloadAbi,
+        functionName: "extsload",
+        args: [slots],
+        blockNumber: scope.block.blockNumber
+      });
+      const [liquidity, last0, last1] = words;
+      if (words.length !== 3 || !liquidity || !last0 || !last1 || words.some((word) => !/^0x[0-9a-fA-F]{64}$/.test(word)))
+        throw new MarketDeploymentVerificationError(
+          "position storage",
+          "three 32-byte words",
+          words
+        );
+      managerState = [BigInt(liquidity), BigInt(last0), BigInt(last1)];
+    }
+    if (managerState[0] !== range.state.totalShares)
+      throw new MarketDeploymentVerificationError(
+        "managerLiquidity",
+        range.state.totalShares,
+        managerState[0]
+      );
+    return immutableClone({
+      position: { ...position, range },
+      managerLiquidity: managerState[0],
+      lastGrowth0X128: managerState[1],
+      lastGrowth1X128: managerState[2],
+      growth0X128: growth[0],
+      growth1X128: growth[1],
+      claimFeeSyncIndex,
+      policyHistoryLength,
+      currentClaimFeeBps,
+      allTimeMinClaimFeeBps
+    });
+  });
+}
+async function estimateMarketClaimableFees(context, params) {
+  const snapshot = await getMarketFeeSnapshot(context, params);
+  return immutableClone({
+    block: snapshot.block,
+    data: calculateMarketClaimableFees(snapshot.data)
+  });
+}
+
+// src/actions/pools.ts
+import { isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress3 } from "viem";
+function normalizePool(scope, raw) {
+  const key = defineMarketPoolKey(raw.key);
+  const expected = getMarketPoolId(key);
+  if (expected.toLowerCase() !== raw.id.toLowerCase())
+    throw new MarketDeploymentVerificationError("poolId", expected, raw.id);
+  const hookKind = scope.deployment.hooks.find((entry) => isAddressEqual5(entry.address, key.hooks))?.kind ?? null;
+  return { key, poolId: raw.id, active: raw.active, hookKind };
+}
+async function readMarketPoolAt(scope, poolId) {
+  const raw = await scope.publicClient.readContract({
+    address: scope.deployment.registry.address,
+    abi: marketPoolRegistryAbi,
+    functionName: "poolById",
+    args: [poolId],
+    blockNumber: scope.block.blockNumber
+  });
+  const pool = normalizePool(scope, raw);
+  if (pool.poolId.toLowerCase() !== poolId.toLowerCase())
+    throw new MarketDeploymentVerificationError("registry.poolId", poolId, pool.poolId);
+  return pool;
+}
+function requireMarketPoolHook(scope, pool) {
+  const hook2 = requireMarketHook(scope, pool.key.hooks);
+  if (isAddressEqual5(pool.key.currency0, zeroAddress3) && hook2.kind !== "ramp-eth") {
+    throw new InvalidMarketConfigError("currency0", "Native currency requires RampETH.");
+  }
+  return hook2;
+}
+function getMarketPool(context, poolId, options = {}) {
+  assertMarketPoolId(poolId);
+  return readMarketSnapshot(context, options, (scope) => readMarketPoolAt(scope, poolId));
+}
+function listMarketPools(context, params = {}) {
+  const { offset = 0n, limit = 20, activeOnly = false } = params;
+  assertMarketUint(offset, "offset");
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+    throw new InvalidMarketConfigError("limit", "Page size must be in [1, 100].");
+  return readMarketSnapshot(context, params, async (scope) => {
+    const target = {
+      address: scope.deployment.registry.address,
+      abi: marketPoolRegistryAbi,
+      blockNumber: scope.block.blockNumber
+    };
+    const totalCount = await scope.publicClient.readContract({
+      ...target,
+      functionName: "poolCount"
+    });
+    const end = offset + BigInt(limit) < totalCount ? offset + BigInt(limit) : totalCount;
+    const pools = [];
+    for (let start = offset; start < end; start += 8n) {
+      const count = Number(end - start < 8n ? end - start : 8n);
+      const batch = await Promise.all(
+        Array.from(
+          { length: count },
+          (_, index) => scope.publicClient.readContract({
+            ...target,
+            functionName: "poolAt",
+            args: [start + BigInt(index)]
+          })
+        )
+      );
+      for (const entry of batch) {
+        const pool = normalizePool(scope, entry);
+        if (!activeOnly || pool.active) pools.push(pool);
+      }
+    }
+    return { pools, totalCount, nextOffset: end < totalCount ? end : null };
+  });
+}
+
+// src/actions/fees.ts
+function sessionName(value) {
+  if (value === 0) return "open";
+  if (value === 1) return "overnight";
+  if (value === 2) return "closed";
+  throw new MarketDeploymentVerificationError("session", "0, 1 or 2", value);
+}
+function getMarketCurrentFees(context, poolId, options = {}) {
+  assertMarketPoolId(poolId);
+  return readMarketSnapshot(context, options, async (scope) => {
+    const pool = await readMarketPoolAt(scope, poolId);
+    const hook2 = requireMarketPoolHook(scope, pool);
+    const target = {
+      address: hook2.address,
+      abi: marketRampAbi,
+      blockNumber: scope.block.blockNumber
+    };
+    const [fee0For1Pips, fee1For0Pips, globalPaused, poolPaused] = await Promise.all([
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "currentFee",
+        args: [poolId, true]
+      }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "currentFee",
+        args: [poolId, false]
+      }),
+      scope.publicClient.readContract({ ...target, functionName: "paused" }),
+      scope.publicClient.readContract({ ...target, functionName: "pausedFor", args: [poolId] })
+    ]);
+    return { pool, fee0For1Pips, fee1For0Pips, globalPaused, poolPaused };
+  });
+}
+async function readFeeBreakdown(scope, poolId, zeroForOne, timestamp, mode) {
+  const reader = scope.deployment.reader;
+  if (!reader) throw new MarketFeatureUnavailableError("feeBreakdown requires a Reader");
+  const pool = await readMarketPoolAt(scope, poolId);
+  const hook2 = requireMarketPoolHook(scope, pool);
+  const result = await scope.publicClient.readContract({
+    address: reader.address,
+    abi: marketRampReaderAbi,
+    functionName: "feeBreakdown",
+    args: [poolId, zeroForOne, timestamp],
+    blockNumber: scope.block.blockNumber
+  });
+  if (result.hasSession !== (hook2.kind === "rwa-ramp"))
+    throw new MarketDeploymentVerificationError(
+      "reader.hasSession",
+      hook2.kind === "rwa-ramp",
+      result.hasSession
+    );
+  return {
+    pool,
+    zeroForOne,
+    timestamp,
+    mode,
+    session: result.hasSession ? sessionName(result.session) : null,
+    baseFeePips: result.baseFee,
+    directionalPremiumPips: result.directionalPremium,
+    cappedAutonomousFeePips: result.cappedAutonomousFee,
+    overrideActive: result.overrideActive,
+    overrideFeePips: result.overrideFee,
+    overrideExpiry: BigInt(result.overrideExpiry),
+    overrideMinFeePips: result.overrideMinFee,
+    maxFeePips: result.maxFee,
+    finalFeePips: result.finalFee
+  };
+}
+function assertDirection(value) {
+  if (typeof value !== "boolean")
+    throw new InvalidMarketConfigError("zeroForOne", "Expected an explicit direction boolean.");
+}
+function getMarketFeeBreakdown(context, poolId, zeroForOne, options = {}) {
+  assertMarketPoolId(poolId);
+  assertDirection(zeroForOne);
+  return readMarketSnapshot(
+    context,
+    options,
+    (scope) => readFeeBreakdown(scope, poolId, zeroForOne, scope.block.timestamp, "current")
+  );
+}
+function previewMarketFeeAt(context, poolId, zeroForOne, timestamp, options = {}) {
+  assertMarketPoolId(poolId);
+  assertDirection(zeroForOne);
+  assertMarketUint(timestamp, "timestamp");
+  return readMarketSnapshot(
+    context,
+    options,
+    (scope) => readFeeBreakdown(scope, poolId, zeroForOne, timestamp, "preview")
+  );
+}
+function getMarketSession(context, poolId, options = {}) {
+  assertMarketPoolId(poolId);
+  const timestamp = options.timestamp;
+  if (timestamp !== void 0) assertMarketUint(timestamp, "timestamp");
+  return readMarketSnapshot(context, options, async (scope) => {
+    const pool = await readMarketPoolAt(scope, poolId);
+    const hook2 = requireMarketPoolHook(scope, pool);
+    const at = timestamp ?? scope.block.timestamp;
+    const session = hook2.kind === "rwa-ramp" ? sessionName(
+      await scope.publicClient.readContract({
+        address: hook2.address,
+        abi: marketRwaRampAbi,
+        functionName: "sessionAt",
+        args: [poolId, at],
+        blockNumber: scope.block.blockNumber
+      })
+    ) : null;
+    return { pool, session, timestamp: at, mode: timestamp === void 0 ? "current" : "preview" };
+  });
+}
+
+// src/actions/pool-state.ts
+import { isAddressEqual as isAddressEqual6 } from "viem";
+function getMarketPoolState(context, poolId, options = {}) {
+  assertMarketPoolId(poolId);
+  return readMarketSnapshot(context, options, async (scope) => {
+    const pool = await readMarketPoolAt(scope, poolId);
+    requireMarketPoolHook(scope, pool);
+    return { pool, ...await readMarketPoolStateAt(scope, poolId) };
+  });
+}
+async function readMarketPoolStateAt(scope, poolId) {
+  const reader = scope.deployment.poolStateReader;
+  if (!reader) throw new MarketFeatureUnavailableError("poolStateReader");
+  await assertMarketCode(scope, scope.deployment.poolManager);
+  const blockNumber = scope.block.blockNumber;
+  let state;
+  if (reader.kind === "state-view") {
+    await assertMarketCode(scope, reader.contract);
+    const target = {
+      address: reader.contract.address,
+      abi: marketStateViewAbi,
+      blockNumber
+    };
+    const manager = await scope.publicClient.readContract({
+      ...target,
+      functionName: "poolManager"
+    });
+    if (!isAddressEqual6(manager, scope.deployment.poolManager.address))
+      throw new MarketDeploymentVerificationError(
+        "stateView.poolManager",
+        scope.deployment.poolManager.address,
+        manager
+      );
+    const [slot0, activeLiquidity] = await Promise.all([
+      scope.publicClient.readContract({ ...target, functionName: "getSlot0", args: [poolId] }),
+      scope.publicClient.readContract({
+        ...target,
+        functionName: "getLiquidity",
+        args: [poolId]
+      })
+    ]);
+    state = {
+      sqrtPriceX96: slot0[0],
+      tick: slot0[1],
+      protocolFeePacked: slot0[2],
+      storedLpFeePips: slot0[3],
+      activeLiquidity
+    };
+  } else {
+    const words = await scope.publicClient.readContract({
+      address: scope.deployment.poolManager.address,
+      abi: marketExtsloadAbi,
+      functionName: "extsload",
+      args: [marketPoolStorageSlots(poolId)],
+      blockNumber
+    });
+    state = decodeMarketPoolStateWords(words);
+  }
+  if (state.tick < -887272 || state.tick > 887272)
+    throw new MarketDeploymentVerificationError("pool.tick", "v4 tick bounds", state.tick);
+  return { source: reader.kind, initialized: state.sqrtPriceX96 !== 0n, ...state };
+}
+
+// src/actions/write/preview.ts
+import { erc20Abi, isAddressEqual as isAddressEqual8, zeroAddress as zeroAddress5 } from "viem";
+
+// src/math/liquidity.ts
+var Q96 = 1n << 96n;
+var MIN_SQRT = 4295128739n;
+var MAX_SQRT = 1461446703485210103287273052203988822378723970342n;
+var FACTORS = [
+  0xfffcb933bd6fad37aa2d162d1a594001n,
+  0xfff97272373d413259a46990580e213an,
+  0xfff2e50f5f656932ef12357cf3c7fdccn,
+  0xffe5caca7e10e4e61c3624eaa0941cd0n,
+  0xffcb9843d60f6159c9db58835c926644n,
+  0xff973b41fa98c081472e6896dfb254c0n,
+  0xff2ea16466c96a3843ec78b326b52861n,
+  0xfe5dee046a99a2a811c461f1969c3053n,
+  0xfcbe86c7900a88aedcffc83b479aa3a4n,
+  0xf987a7253ac413176f2b074cf7815e54n,
+  0xf3392b0822b70005940c7a398e4b70f3n,
+  0xe7159475a2c29b7443b29c7fa6e889d9n,
+  0xd097f3bdfd2022b8845ad8f792aa5825n,
+  0xa9f746462d870fdf8a65dc1f90e061e5n,
+  0x70d869a156d2a1b890bb3df62baf32f7n,
+  0x31be135f97d08fd981231505542fcfa6n,
+  0x9aa508b5b7a84e1c677de54f3e99bc9n,
+  0x5d6af8dedb81196699c329225ee604n,
+  0x2216e584f5fa1ea926041bedfe98n,
+  0x48a170391f7dc42444e8fa2n
+];
+function getMarketSqrtPriceAtTick(tick) {
+  if (!Number.isInteger(tick) || Math.abs(tick) > 887272)
+    throw new InvalidMarketConfigError("tick", "Tick must be an integer in v4 bounds.");
+  const absolute = Math.abs(tick);
+  let ratio = 1n << 128n;
+  for (let i = 0; i < FACTORS.length; i++) {
+    const factor = FACTORS[i];
+    if (factor !== void 0 && (absolute & 1 << i) !== 0) ratio = ratio * factor >> 128n;
+  }
+  if (tick > 0) ratio = ((1n << 256n) - 1n) / ratio;
+  return ratio + (1n << 32n) - 1n >> 32n;
+}
+function assertPrice(price) {
+  if (typeof price !== "bigint" || price < MIN_SQRT || price >= MAX_SQRT)
+    throw new InvalidMarketConfigError(
+      "sqrtPriceX96",
+      "Price must be initialized and inside v4 bounds."
+    );
+}
+function getMarketTickAtSqrtPrice(sqrtPriceX96) {
+  assertPrice(sqrtPriceX96);
+  let lower = -887272;
+  let upper = 887272;
+  while (lower < upper) {
+    const middle = Math.ceil((lower + upper) / 2);
+    if (getMarketSqrtPriceAtTick(middle) <= sqrtPriceX96) lower = middle;
+    else upper = middle - 1;
+  }
+  return lower;
+}
+function getMarketPriceRatio(sqrtPriceX96, decimals0, decimals1) {
+  assertPrice(sqrtPriceX96);
+  for (const decimals of [decimals0, decimals1]) {
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 255)
+      throw new InvalidMarketConfigError("decimals", "Decimals must fit uint8.");
+  }
+  return {
+    numerator: sqrtPriceX96 ** 2n * 10n ** BigInt(decimals0),
+    denominator: (1n << 192n) * 10n ** BigInt(decimals1)
+  };
+}
+function boundaries(sqrtPriceX96, tickLower, tickUpper) {
+  assertPrice(sqrtPriceX96);
+  const lower = getMarketSqrtPriceAtTick(tickLower);
+  const upper = getMarketSqrtPriceAtTick(tickUpper);
+  if (lower >= upper)
+    throw new InvalidMarketConfigError("ticks", "Lower tick must precede upper tick.");
+  return {
+    lower,
+    upper,
+    current: sqrtPriceX96 < lower ? lower : sqrtPriceX96 > upper ? upper : sqrtPriceX96
+  };
+}
+function getMarketAmountsForLiquidity(params) {
+  assertMarketUint(params.liquidity, "liquidity", 128);
+  if (params.rounding !== "up" && params.rounding !== "down")
+    throw new InvalidMarketConfigError("rounding", "Expected up or down.");
+  const { lower, upper, current } = boundaries(
+    params.sqrtPriceX96,
+    params.tickLower,
+    params.tickUpper
+  );
+  const divide = (n, d) => params.rounding === "up" ? (n + d - 1n) / d : n / d;
+  return {
+    amount0: divide(params.liquidity * Q96 * (upper - current), current * upper),
+    amount1: divide(params.liquidity * (current - lower), Q96)
+  };
+}
+function getMarketLiquidityForAmounts(params) {
+  assertMarketUint(params.amount0, "amount0");
+  assertMarketUint(params.amount1, "amount1");
+  const { lower, upper, current } = boundaries(
+    params.sqrtPriceX96,
+    params.tickLower,
+    params.tickUpper
+  );
+  const l0 = current === upper ? void 0 : params.amount0 * (current * upper / Q96) / (upper - current);
+  const l1 = current === lower ? void 0 : params.amount1 * Q96 / (current - lower);
+  if (l0 !== void 0) assertMarketUint(l0, "liquidity0", 128);
+  if (l1 !== void 0) assertMarketUint(l1, "liquidity1", 128);
+  return l0 === void 0 ? l1 ?? 0n : l1 === void 0 || l0 < l1 ? l0 : l1;
+}
+
+// src/actions/write/guards.ts
+import { isAddressEqual as isAddressEqual7, zeroAddress as zeroAddress4 } from "viem";
+function liquidityKey(context, input) {
+  const key = defineMarketPoolKey(input);
+  const hook2 = requireMarketHook(context, key.hooks);
+  if (isAddressEqual7(key.currency0, zeroAddress4) && hook2.kind !== "ramp-eth")
+    throw new MarketFeatureUnavailableError("This Hook supports ERC-20 only");
+  return key;
+}
+function expiry(timestamp, seconds = 60) {
+  if (!Number.isInteger(seconds) || seconds < 1 || seconds > 300)
+    throw new InvalidMarketConfigError("validForSeconds", "Lifetime must be 1..300 seconds.");
+  return timestamp + BigInt(seconds);
+}
+function recipient(context, key, to) {
+  assertMarketAddress(to, "to");
+  if ([key.hooks, context.deployment.poolManager.address, zeroAddress4].some(
+    (value) => isAddressEqual7(value, to)
+  ))
+    throw new InvalidMarketConfigError("to", "Recipient cannot be zero, the Hook or PoolManager.");
+  return to;
+}
+function claimFee(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 2e3)
+    throw new InvalidMarketConfigError("maxFeeBps", "Claim fee tolerance must be 0..2000 bps.");
+}
+async function assertWriteDeployment(scope, key, claimOperator = false, management = false) {
+  const hook2 = requireMarketHook(scope, key.hooks);
+  if (management && hook2.capabilities.management !== "verified")
+    throw new MarketFeatureUnavailableError("verified management capability");
+  if (!management && hook2.capabilities.liquidity !== "verified")
+    throw new MarketFeatureUnavailableError("verified liquidity capability");
+  if (!management && isAddressEqual7(key.currency0, zeroAddress4) && hook2.capabilities.nativeLiquidity !== "verified")
+    throw new MarketFeatureUnavailableError("verified nativeLiquidity capability");
+  if (claimOperator && hook2.capabilities.claimOperator !== "verified")
+    throw new MarketFeatureUnavailableError("verified claimOperator capability");
+  for (const contract2 of [
+    hook2,
+    scope.deployment.poolManager,
+    scope.deployment.authority,
+    hook2.claimFeePolicy
+  ])
+    await assertMarketCode(scope, contract2);
+  if (hook2.kind === "rwa-ramp") {
+    if (!hook2.calendar) throw new MarketFeatureUnavailableError("RWA calendar");
+    await assertMarketCode(scope, hook2.calendar);
+    const [calendar, controller] = await Promise.all([
+      scope.publicClient.readContract({
+        address: hook2.address,
+        abi: marketRwaRampAbi,
+        functionName: "marketCalendar",
+        blockNumber: scope.block.blockNumber
+      }),
+      scope.publicClient.readContract({
+        address: hook2.calendar.address,
+        abi: marketMarketCalendarAbi,
+        functionName: "controller",
+        blockNumber: scope.block.blockNumber
+      })
+    ]);
+    if (!isAddressEqual7(calendar, hook2.calendar.address) || !isAddressEqual7(controller, hook2.address))
+      throw new MarketDeploymentVerificationError(
+        "write.calendar",
+        [hook2.calendar.address, hook2.address],
+        [calendar, controller]
+      );
+  }
+  const target = {
+    address: hook2.address,
+    abi: marketRampAbi,
+    blockNumber: scope.block.blockNumber
+  };
+  const actual = await Promise.all([
+    scope.publicClient.readContract({ ...target, functionName: "poolManager" }),
+    scope.publicClient.readContract({ ...target, functionName: "authority" }),
+    scope.publicClient.readContract({ ...target, functionName: "claimFeePolicy" }),
+    scope.publicClient.readContract({
+      address: hook2.claimFeePolicy.address,
+      abi: marketClaimFeePolicyAbi,
+      functionName: "ledger",
+      blockNumber: scope.block.blockNumber
+    })
+  ]);
+  const expected = [
+    scope.deployment.poolManager.address,
+    scope.deployment.authority.address,
+    hook2.claimFeePolicy.address,
+    hook2.address
+  ];
+  for (let index = 0; index < expected.length; index++) {
+    const want = expected[index];
+    const got = actual[index];
+    if (!want || !got || !isAddressEqual7(want, got))
+      throw new MarketDeploymentVerificationError(`write.binding.${index}`, want, got);
+  }
+}
+
+// src/actions/write/preview.ts
+async function previewMarketLiquidity(context, action, input) {
+  const params = immutableClone(input);
+  const key = liquidityKey(context, params.key);
+  const poolId = getMarketPoolId(key);
+  const rangeId = getMarketRangeId(poolId, params.tickLower, params.tickUpper, key.tickSpacing);
+  assertMarketUint(params.liquidity, "liquidity", 128);
+  assertMarketUint(params.deadline, "deadline");
+  if (params.liquidity === 0n)
+    throw new InvalidMarketConfigError("liquidity", "Liquidity must be positive.");
+  if (!Number.isInteger(params.slippageBps) || params.slippageBps < 0 || params.slippageBps >= 1e4)
+    throw new InvalidMarketConfigError(
+      "slippageBps",
+      "Slippage must be an integer from 0 to 9999 bps."
+    );
+  return immutableClone(
+    await readMarketSnapshot(context, {}, async (scope) => {
+      const lifetime = expiry(scope.block.timestamp, params.validForSeconds);
+      if (params.deadline < scope.block.timestamp)
+        throw new InvalidMarketConfigError("deadline", "Deadline has expired.");
+      const state = await readMarketPoolStateAt(scope, poolId);
+      const amounts = getMarketAmountsForLiquidity({
+        ...params,
+        sqrtPriceX96: state.sqrtPriceX96,
+        rounding: action === "deposit" ? "up" : "down"
+      });
+      const limit = (amount) => action === "deposit" ? (amount * BigInt(1e4 + params.slippageBps) + 9999n) / 10000n : amount * BigInt(1e4 - params.slippageBps) / 10000n;
+      const limit0 = limit(amounts.amount0);
+      const limit1 = limit(amounts.amount1);
+      assertMarketUint(limit0, "limit0", 128);
+      assertMarketUint(limit1, "limit1", 128);
+      return {
+        ...params,
+        key,
+        action,
+        rangeId,
+        sqrtPriceX96: state.sqrtPriceX96,
+        ...amounts,
+        limit0,
+        limit1,
+        nativeValue: action === "deposit" && isAddressEqual8(key.currency0, zeroAddress5) ? limit0 : 0n,
+        estimatedNativeRefund: action === "deposit" && isAddressEqual8(key.currency0, zeroAddress5) ? limit0 - amounts.amount0 : 0n,
+        expiresAt: params.deadline < lifetime ? params.deadline : lifetime
+      };
+    })
+  );
+}
+function getMarketSpendStatus(context, params) {
+  const key = liquidityKey(context, params.key);
+  const { owner, amount0, amount1 } = params;
+  assertMarketAddress(owner, "owner");
+  assertMarketUint(amount0, "amount0", 128);
+  assertMarketUint(amount1, "amount1", 128);
+  return readMarketSnapshot(context, params, async (scope) => ({
+    owner,
+    spender: key.hooks,
+    tokens: await Promise.all(
+      [
+        { token: key.currency0, requiredAmount: amount0 },
+        { token: key.currency1, requiredAmount: amount1 }
+      ].map(async ({ token, requiredAmount }) => {
+        if (isAddressEqual8(token, zeroAddress5)) {
+          const balance2 = await scope.publicClient.getBalance({
+            address: owner,
+            blockNumber: scope.block.blockNumber
+          });
+          return {
+            token,
+            kind: "native",
+            balance: balance2,
+            allowance: null,
+            requiredAmount,
+            needsApproval: false,
+            sufficientBalance: balance2 >= requiredAmount
+          };
+        }
+        const target = {
+          address: token,
+          abi: erc20Abi,
+          blockNumber: scope.block.blockNumber
+        };
+        const [balance, allowance] = await Promise.all([
+          scope.publicClient.readContract({ ...target, functionName: "balanceOf", args: [owner] }),
+          scope.publicClient.readContract({
+            ...target,
+            functionName: "allowance",
+            args: [owner, key.hooks]
+          })
+        ]);
+        return {
+          token,
+          kind: "erc20",
+          balance,
+          allowance,
+          requiredAmount,
+          needsApproval: allowance < requiredAmount,
+          sufficientBalance: balance >= requiredAmount
+        };
+      })
+    )
+  }));
+}
+
+// src/chains.ts
+function defineMarketChain(input) {
+  const deployment = defineMarketDeployment(input.deployment);
+  if (input.chainId !== deployment.chainId) {
+    throw new InvalidMarketConfigError("chainId", "Chain and deployment chain IDs must match.");
+  }
+  if (!Number.isSafeInteger(input.confirmations) || input.confirmations < 1) {
+    throw new InvalidMarketConfigError("confirmations", "Expected at least one confirmation.");
+  }
+  return Object.freeze({ chainId: input.chainId, deployment, confirmations: input.confirmations });
+}
+
+// src/actions/write/transactions.ts
+import {
+  decodeEventLog,
+  encodeFunctionData as encodeFunctionData2,
+  erc20Abi as erc20Abi2,
+  isAddressEqual as isAddressEqual10,
+  zeroAddress as zeroAddress7
+} from "viem";
+
+// src/actions/write/management.ts
+import {
+  encodeAbiParameters as encodeAbiParameters4,
+  encodeFunctionData,
+  isAddressEqual as isAddressEqual9,
+  keccak256 as keccak2565,
+  zeroAddress as zeroAddress6
+} from "viem";
+
+// src/math/calendar.ts
+function marketDaysInMonth(year, month) {
+  if (!Number.isInteger(year) || year < 1970 || year > 9999 || !Number.isInteger(month) || month < 1 || month > 12)
+    throw new InvalidMarketConfigError("date", "Expected year 1970..9999 and month 1..12.");
+  if (month === 2) return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28;
+  return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+function packMarketDayOverrides(year, month, days) {
+  const maximum = marketDaysInMonth(year, month);
+  if (!Array.isArray(days) || days.length > 10)
+    throw new InvalidMarketConfigError("days", "At most ten overrides per month.");
+  const seen = /* @__PURE__ */ new Set();
+  let packed = 0n;
+  for (const { day, status } of days) {
+    if (!Number.isInteger(day) || day < 1 || day > maximum || seen.has(day) || status !== "closed" && status !== "open")
+      throw new InvalidMarketConfigError("days", "Invalid or duplicate override date/status.");
+    seen.add(day);
+    packed |= (status === "closed" ? 1n : 2n) << BigInt((day - 1) * 2);
+  }
+  return packed;
+}
+
+// src/actions/write/management.ts
+function integer(value, field, min = 0, max = 16777215) {
+  if (!Number.isSafeInteger(value) || value < min || value > max)
+    throw new InvalidMarketConfigError(field, `Expected integer ${min}..${max}.`);
+}
+function condition(ok, field) {
+  if (!ok)
+    throw new InvalidMarketConfigError(
+      field,
+      `Invalid management parameter combination: ${field}.`
+    );
+}
+function encodeMarketManagement(context, a) {
+  const key = liquidityKey(context, a.key);
+  const hook2 = requireMarketHook(context, key.hooks);
+  const id = getMarketPoolId(key);
+  const target = hook2.address;
+  const ramp = marketRampAbi;
+  const rwa = marketRwaRampAbi;
+  const result = (data, to = target) => ({ key, to, data, value: 0n });
+  const requireRwa = () => {
+    if (hook2.kind !== "rwa-ramp") throw new MarketFeatureUnavailableError("RWA Hook required");
+  };
+  switch (a.kind) {
+    case "pokeFee":
+      integer(a.fee0For1, "fee0For1");
+      integer(a.fee1For0, "fee1For0");
+      integer(a.ttl, "ttl", 1, 259200);
+      condition(a.fee0For1 !== 0 || a.fee1For0 !== 0, "pokeFee");
+      return result(
+        encodeFunctionData({
+          abi: ramp,
+          functionName: "pokeFee",
+          args: [id, a.fee0For1, a.fee1For0, a.ttl]
+        })
+      );
+    case "clearPoke":
+      return result(encodeFunctionData({ abi: ramp, functionName: "clearPoke", args: [id] }));
+    case "setPoolAsymmetry":
+      integer(a.premiumPips, "premiumPips");
+      condition(typeof a.premiumZeroForOne === "boolean", "direction");
+      return result(
+        encodeFunctionData({
+          abi: ramp,
+          functionName: "setPoolAsymmetry",
+          args: [key, a.premiumPips, a.premiumZeroForOne]
+        })
+      );
+    case "setCryptoPoolConfig":
+      if (hook2.kind === "rwa-ramp") throw new MarketFeatureUnavailableError("Crypto Hook required");
+      integer(a.floorPips, "floorPips", 100);
+      integer(a.flatPips, "flatPips", a.floorPips);
+      integer(a.cap, "cap", a.flatPips);
+      return result(
+        encodeFunctionData({
+          abi: ramp,
+          functionName: "setPoolConfig",
+          args: [key, a.floorPips, a.flatPips, a.cap]
+        })
+      );
+    case "setRwaPoolConfig": {
+      requireRwa();
+      integer(a.cap, "cap", 100);
+      const c = a.config;
+      for (const field of ["openFloor", "overnightFloor", "closedFloor"])
+        integer(c[field], field, 100, a.cap);
+      integer(c.spikeMult, "spikeMult", 0, 20);
+      integer(c.closedSpike, "closedSpike");
+      integer(c.descentWindow, "descentWindow", 0, 21600);
+      integer(c.closeFloor, "closeFloor", 0, a.cap);
+      integer(c.closeBefore, "closeBefore", 0, 21600);
+      integer(c.closeAfter, "closeAfter", 0, 21600);
+      condition(
+        c.descentWindow === 0 ? c.spikeMult === 0 && c.closedSpike === 0 : c.overnightFloor * c.spikeMult > c.openFloor && c.closedSpike > c.openFloor,
+        "descentWindow"
+      );
+      condition(
+        c.closeFloor === 0 ? c.closeBefore === 0 && c.closeAfter === 0 : c.closeFloor >= c.openFloor && (c.closeBefore !== 0 || c.closeAfter !== 0),
+        "closeFloor"
+      );
+      return result(
+        encodeFunctionData({
+          abi: rwa.filter(
+            (item) => item.type !== "function" || item.name !== "setPoolConfig" || item.inputs.length === 3
+          ),
+          functionName: "setPoolConfig",
+          args: [key, c, a.cap]
+        })
+      );
+    }
+    case "setSessionHours":
+      requireRwa();
+      integer(a.openSec, "openSec", 32400, 36e3);
+      integer(a.closeSec, "closeSec", 55800, 59400);
+      condition(a.closeSec - a.openSec >= 3600 && a.closeSec - a.openSec <= 43200, "sessionHours");
+      return result(
+        encodeFunctionData({
+          abi: rwa,
+          functionName: "setSessionHours",
+          args: [id, a.openSec, a.closeSec]
+        })
+      );
+    case "setDayOverrides": {
+      requireRwa();
+      const packed = packMarketDayOverrides(a.year, a.month, a.days);
+      return result(
+        encodeFunctionData({
+          abi: rwa,
+          functionName: "setDayOverrides",
+          args: [id, BigInt(a.year * 100 + a.month), packed]
+        })
+      );
+    }
+    case "setDstMode":
+      requireRwa();
+      condition(["auto", "est", "edt"].includes(a.mode), "mode");
+      return result(
+        encodeFunctionData({
+          abi: rwa,
+          functionName: "setDstMode",
+          args: [id, a.mode === "auto" ? 0 : a.mode === "est" ? 1 : 2]
+        })
+      );
+    case "setEarlyClose":
+      requireRwa();
+      integer(a.day, "day", 1, marketDaysInMonth(a.year, a.month));
+      integer(a.closeSec, "closeSec", 0, 86400);
+      return result(
+        encodeFunctionData({
+          abi: rwa,
+          functionName: "setEarlyClose",
+          args: [id, BigInt(a.year), BigInt(a.month), BigInt(a.day), a.closeSec]
+        })
+      );
+    case "setPaused":
+    case "setPoolPaused":
+      integer(a.duration, "duration", 0, 604800);
+      return result(
+        a.kind === "setPaused" ? encodeFunctionData({ abi: ramp, functionName: "setPaused", args: [BigInt(a.duration)] }) : encodeFunctionData({
+          abi: ramp,
+          functionName: "setPoolPaused",
+          args: [key, BigInt(a.duration)]
+        })
+      );
+    case "setClaimFee":
+      claimFee(a.bps);
+      assertMarketAddress(a.recipient, "recipient", a.bps === 0);
+      if (!isAddressEqual9(a.recipient, zeroAddress6)) recipient(context, key, a.recipient);
+      condition(Array.isArray(a.settleFirst), "settleFirst");
+      for (const currency of a.settleFirst)
+        assertMarketAddress(currency, "settleFirst", hook2.kind === "ramp-eth");
+      condition(
+        new Set(a.settleFirst.map((v) => v.toLowerCase())).size === a.settleFirst.length,
+        "settleFirst"
+      );
+      return result(
+        encodeFunctionData({
+          abi: ramp,
+          functionName: "setClaimFee",
+          args: [key, a.settleFirst, a.bps, a.recipient]
+        })
+      );
+    case "setClaimFeeBps":
+      claimFee(a.bps);
+      return result(
+        encodeFunctionData({ abi: ramp, functionName: "setClaimFeeBps", args: [key, a.bps] })
+      );
+    case "sweepClaimFee":
+      assertMarketAddress(a.currency, "currency", hook2.kind === "ramp-eth");
+      return result(
+        encodeFunctionData({ abi: ramp, functionName: "sweepClaimFee", args: [a.currency] })
+      );
+    case "register":
+      return result(
+        encodeFunctionData({ abi: marketPoolRegistryAbi, functionName: "register", args: [key] }),
+        context.deployment.registry.address
+      );
+    case "deregister":
+    case "reregister":
+      return result(
+        encodeFunctionData({ abi: marketPoolRegistryAbi, functionName: a.kind, args: [id] }),
+        context.deployment.registry.address
+      );
+    case "setHook":
+    case "disableHook": {
+      const reader = context.deployment.reader;
+      if (!reader) throw new MarketFeatureUnavailableError("Reader required");
+      if (a.kind === "disableHook")
+        return result(
+          encodeFunctionData({
+            abi: marketRampReaderAbi,
+            functionName: "disableHook",
+            args: [hook2.address]
+          }),
+          reader.address
+        );
+      condition(
+        /^0x[0-9a-fA-F]{64}$/.test(a.expectedCodeHash) && a.expectedCodeHash.toLowerCase() === hook2.runtimeCodeHash.toLowerCase(),
+        "expectedCodeHash"
+      );
+      return result(
+        encodeFunctionData({
+          abi: marketRampReaderAbi,
+          functionName: "setHook",
+          args: [hook2.address, hook2.kind === "rwa-ramp" ? 2 : 1, a.expectedCodeHash]
+        }),
+        reader.address
+      );
+    }
+    default:
+      throw new InvalidMarketConfigError("kind", "Unknown management action.");
+  }
+}
+async function inspectMarketManagementAt(scope, a, account, when = 0) {
+  assertMarketAddress(account, "account");
+  integer(when, "when", 0, 2 ** 48 - 1);
+  const call = encodeMarketManagement(scope, a);
+  const hook2 = requireMarketHook(scope, call.key.hooks);
+  if (hook2.capabilities.management !== "verified")
+    throw new MarketFeatureUnavailableError("verified management capability");
+  const registryAction = [
+    "register",
+    "deregister",
+    "reregister",
+    "setHook",
+    "disableHook"
+  ].includes(a.kind);
+  const readerAction = a.kind === "setHook" || a.kind === "disableHook";
+  if (a.kind !== "disableHook" && a.kind !== "deregister" && a.kind !== "reregister")
+    await assertWriteDeployment(scope, call.key, false, true);
+  else await assertMarketCode(scope, scope.deployment.authority);
+  const read = { blockNumber: scope.block.blockNumber };
+  if (registryAction) {
+    await assertMarketCode(scope, scope.deployment.registry);
+    const actual = await scope.publicClient.readContract({
+      ...read,
+      address: scope.deployment.registry.address,
+      abi: marketPoolRegistryAbi,
+      functionName: "authority"
+    });
+    if (!isAddressEqual9(actual, scope.deployment.authority.address))
+      throw new MarketDeploymentVerificationError(
+        "registry.authority",
+        scope.deployment.authority.address,
+        actual
+      );
+  }
+  if (readerAction) {
+    const reader = scope.deployment.reader;
+    if (!reader) throw new MarketFeatureUnavailableError("Reader required");
+    await assertMarketCode(scope, reader);
+    const [registry, authority] = await Promise.all([
+      scope.publicClient.readContract({
+        ...read,
+        address: reader.address,
+        abi: marketRampReaderAbi,
+        functionName: "registry"
+      }),
+      scope.publicClient.readContract({
+        ...read,
+        address: reader.address,
+        abi: marketRampReaderAbi,
+        functionName: "authority"
+      })
+    ]);
+    if (!isAddressEqual9(registry, scope.deployment.registry.address) || !isAddressEqual9(authority, scope.deployment.authority.address))
+      throw new MarketDeploymentVerificationError("reader.bindings", scope.deployment, [
+        registry,
+        authority
+      ]);
+  }
+  const hookRead = { ...read, address: hook2.address, abi: marketRampAbi };
+  if (a.kind === "setCryptoPoolConfig" || a.kind === "setRwaPoolConfig") {
+    const absolute = await scope.publicClient.readContract({
+      ...hookRead,
+      functionName: "ABSOLUTE_MAX_FEE"
+    });
+    condition(a.cap <= absolute, "cap");
+  }
+  if (a.kind === "pokeFee" || a.kind === "setPoolAsymmetry") {
+    const id = getMarketPoolId(call.key);
+    const [floor, cap] = await Promise.all([
+      scope.publicClient.readContract({ ...hookRead, functionName: "pokeFloor", args: [id] }),
+      scope.publicClient.readContract({ ...hookRead, functionName: "maxFee", args: [id] })
+    ]);
+    if (a.kind === "pokeFee")
+      condition(
+        [a.fee0For1, a.fee1For0].every((fee) => fee === 0 || fee >= floor && fee <= cap),
+        "pokeFee.band"
+      );
+    else condition(a.premiumPips <= cap - floor, "premiumPips.band");
+  }
+  if (a.kind === "setEarlyClose" && a.closeSec !== 0) {
+    const id = getMarketPoolId(call.key);
+    const [open, close] = await Promise.all([
+      scope.publicClient.readContract({
+        ...read,
+        address: hook2.address,
+        abi: marketRwaRampAbi,
+        functionName: "openSec",
+        args: [id]
+      }),
+      scope.publicClient.readContract({
+        ...read,
+        address: hook2.address,
+        abi: marketRwaRampAbi,
+        functionName: "closeSec",
+        args: [id]
+      })
+    ]);
+    condition(a.closeSec <= close && a.closeSec - open >= 10800, "earlyClose");
+  }
+  const target = {
+    ...read,
+    address: scope.deployment.authority.address,
+    abi: marketAccessManagerAbi
+  };
+  const [immediate, delay] = a.kind === "sweepClaimFee" ? [true, 0] : await scope.publicClient.readContract({
+    ...target,
+    functionName: "canCall",
+    args: [account, call.to, call.data.slice(0, 10)]
+  });
+  const operationId = keccak2565(
+    encodeAbiParameters4(
+      [{ type: "address" }, { type: "address" }, { type: "bytes" }],
+      [account, call.to, call.data]
+    )
+  );
+  const scheduledAt = await scope.publicClient.readContract({
+    ...target,
+    functionName: "getSchedule",
+    args: [operationId]
+  });
+  return {
+    permission: immediate ? "immediate" : delay > 0 ? "delayed" : "denied",
+    delay,
+    operationId,
+    scheduledAt,
+    direct: { to: call.to, data: call.data, value: 0n },
+    schedule: {
+      to: target.address,
+      value: 0n,
+      data: encodeFunctionData({
+        abi: marketAccessManagerAbi,
+        functionName: "schedule",
+        args: [call.to, call.data, when]
+      })
+    },
+    execute: {
+      to: target.address,
+      value: 0n,
+      data: encodeFunctionData({
+        abi: marketAccessManagerAbi,
+        functionName: "execute",
+        args: [call.to, call.data]
+      })
+    }
+  };
+}
+function managementRequest(auth, execution, timestamp) {
+  if (auth.permission === "denied")
+    throw new InvalidMarketConfigError(
+      "permission",
+      "Account is not authorized for this management selector."
+    );
+  if (execution.mode === "direct") {
+    condition(auth.permission === "immediate", "permission.scheduleRequired");
+    return auth.direct;
+  }
+  if (execution.mode === "schedule") {
+    condition(auth.permission === "delayed" && auth.scheduledAt === 0, "schedule");
+    const when = execution.when ?? 0;
+    condition(when === 0 || BigInt(when) >= timestamp + BigInt(auth.delay), "when");
+    return auth.schedule;
+  }
+  if (execution.mode === "execute") {
+    condition(
+      auth.scheduledAt !== 0 && BigInt(auth.scheduledAt) <= timestamp,
+      "schedule.notReadyOrExpired"
+    );
+    return auth.execute;
+  }
+  throw new InvalidMarketConfigError("mode", "Unknown management execution mode.");
+}
+
+// src/actions/write/transactions.ts
+function createMarketWriteActions(publicClient, walletClient, chain) {
+  const context = { publicClient, deployment: chain.deployment };
+  const store = createPreparedTransactionStore();
+  const previews = /* @__PURE__ */ new WeakSet();
+  const sent = /* @__PURE__ */ new Map();
+  const submitting = /* @__PURE__ */ new WeakSet();
+  const submitted = /* @__PURE__ */ new WeakSet();
+  const account = () => resolveLiveWalletAccount(
+    walletClient,
+    chain.chainId,
+    (expected, actual) => new MarketDeploymentVerificationError("wallet.chainId", expected, actual)
+  );
+  async function simulate(request, blockNumber) {
+    try {
+      const result = await publicClient.call({ ...request, blockNumber, batch: false });
+      if (request.data.startsWith("0x095ea7b3") && result.data && result.data !== "0x" && BigInt(result.data) !== 1n)
+        throw new InvalidMarketConfigError("approve", "Token returned false for approve.");
+    } catch (cause) {
+      throw new MarketTransactionError("simulate", cause);
+    }
+  }
+  async function checkNativeBudget(request) {
+    if (request.gas === void 0 || request.maxFeePerGas === void 0) return;
+    const balance = await publicClient.getBalance({ address: request.account });
+    if (balance < request.value + request.gas * request.maxFeePerGas)
+      throw new InvalidMarketConfigError(
+        "nativeBalance",
+        "Insufficient native balance for prepaid value plus gas budget."
+      );
+  }
+  async function fresh(block, expiresAt) {
+    const [latest, original, chainId] = await Promise.all([
+      publicClient.getBlock({ blockTag: "latest" }),
+      publicClient.getBlock({ blockNumber: block.blockNumber }),
+      publicClient.getChainId()
+    ]);
+    if (chainId !== chain.chainId)
+      throw new MarketDeploymentVerificationError("publicClient.chainId", chain.chainId, chainId);
+    if (original.hash !== block.blockHash)
+      throw new MarketDeploymentVerificationError(
+        "preview.blockHash",
+        block.blockHash,
+        original.hash
+      );
+    if (latest.timestamp < block.timestamp || latest.timestamp > expiresAt)
+      throw new InvalidMarketConfigError(
+        "expiry",
+        "Preview or prepared transaction has expired; prepare again."
+      );
+  }
+  async function preview(action, params) {
+    const result = await previewMarketLiquidity(context, action, params);
+    previews.add(result);
+    return result;
+  }
+  async function prepare(input) {
+    const key = liquidityKey(context, input.key);
+    const live = await account();
+    if (input.preview) await fresh(input.preview.block, input.preview.data.expiresAt);
+    let managementContext;
+    const snapshot = await readMarketSnapshot(context, {}, async (scope) => {
+      if (!input.management)
+        await assertWriteDeployment(
+          scope,
+          key,
+          input.action === "setClaimOperator" || input.action === "claimFor"
+        );
+      let request = {
+        account: live.address,
+        to: input.target ?? key.hooks,
+        data: input.data,
+        value: input.action === "deposit" ? input.preview?.data.nativeValue ?? 0n : 0n,
+        chainId: chain.chainId
+      };
+      if (input.management) {
+        const { action, execution } = input.management;
+        const auth = await inspectMarketManagementAt(
+          scope,
+          action,
+          live.address,
+          execution.mode === "schedule" ? execution.when : 0
+        );
+        request = { ...request, ...managementRequest(auth, execution, scope.block.timestamp) };
+        managementContext = {
+          action,
+          execution,
+          target: auth.direct.to,
+          operationId: auth.operationId
+        };
+      }
+      if (input.action === "deposit" && input.preview) {
+        const status = await getMarketSpendStatus(context, {
+          key,
+          owner: live.address,
+          amount0: input.preview.data.limit0,
+          amount1: input.preview.data.limit1,
+          ...scope.block
+        });
+        if (status.data.tokens.some((token) => !token.sufficientBalance || token.needsApproval))
+          throw new InvalidMarketConfigError(
+            "spend",
+            "Insufficient token balance or allowance for deposit maxima."
+          );
+      }
+      await simulate(request, scope.block.blockNumber);
+      if (isAddressEqual10(key.currency0, zeroAddress7)) {
+        const fees = await publicClient.estimateFeesPerGas({ chain: void 0, type: "eip1559" });
+        const estimatedGas = await publicClient.estimateGas({ ...request, ...fees });
+        request = { ...request, ...fees, gas: (estimatedGas * 125n + 99n) / 100n };
+        await checkNativeBudget(request);
+      }
+      return request;
+    });
+    const after = await account();
+    if (!isAddressEqual10(live.address, after.address))
+      throw new InvalidMarketConfigError("account", "Wallet account changed during preparation.");
+    const expiresAt = input.preview?.data.expiresAt ?? expiry(snapshot.block.timestamp, input.validForSeconds);
+    const preparedContext = immutableClone({
+      action: input.action,
+      ...managementContext ? { management: managementContext } : {},
+      key,
+      rangeId: input.rangeId,
+      block: snapshot.block,
+      expiresAt,
+      owner: input.owner ?? live.address,
+      recipient: input.action === "deposit" || input.action === "approve" ? live.address : input.to
+    });
+    return store.create(snapshot.data, input.preview ?? null, preparedContext);
+  }
+  function requirePreview(value, action) {
+    if (!previews.has(value) || value.data.action !== action)
+      throw new InvalidMarketConfigError(
+        "preview",
+        "Use an unchanged preview from this client for the requested action."
+      );
+    return value.data;
+  }
+  async function prepareWithdraw(previewValue, to, maxFeeBps) {
+    const q = requirePreview(previewValue, "withdraw");
+    recipient(context, q.key, to);
+    if (maxFeeBps !== void 0) claimFee(maxFeeBps);
+    const args = [
+      q.key,
+      q.tickLower,
+      q.tickUpper,
+      q.liquidity,
+      to,
+      q.limit0,
+      q.limit1,
+      q.deadline
+    ];
+    return prepare({
+      action: maxFeeBps === void 0 ? "withdraw" : "withdrawAndClaim",
+      key: q.key,
+      to,
+      rangeId: q.rangeId,
+      preview: previewValue,
+      data: maxFeeBps === void 0 ? encodeFunctionData2({ abi: marketRampAbi, functionName: "withdraw", args }) : encodeFunctionData2({
+        abi: marketRampAbi,
+        functionName: "withdrawAndClaim",
+        args: [...args, maxFeeBps]
+      })
+    });
+  }
+  async function send(prepared) {
+    if (!prepared || typeof prepared !== "object" || !store.has(prepared))
+      throw new InvalidMarketConfigError(
+        "prepared",
+        "Transaction was not prepared by this client."
+      );
+    if (submitting.has(prepared) || submitted.has(prepared))
+      throw new InvalidMarketConfigError(
+        "prepared",
+        "Transaction is submitting or already submitted; prepare again for another action."
+      );
+    const request = store.getCanonical(prepared);
+    if (!request || !walletClient)
+      throw new InvalidMarketConfigError("wallet", "A wallet is required.");
+    submitting.add(prepared);
+    try {
+      const live = await account();
+      if (!isAddressEqual10(live.address, request.account))
+        throw new InvalidMarketConfigError("account", "Wallet account changed; prepare again.");
+      await fresh(prepared.context.block, prepared.context.expiresAt);
+      await readMarketSnapshot(context, {}, async (scope) => {
+        const management = prepared.context.management;
+        if (management) {
+          const execution = management.execution;
+          const auth = await inspectMarketManagementAt(
+            scope,
+            management.action,
+            live.address,
+            execution.mode === "schedule" ? execution.when : 0
+          );
+          const canonical = managementRequest(auth, execution, scope.block.timestamp);
+          if (!isAddressEqual10(canonical.to, request.to) || canonical.data !== request.data || auth.operationId !== management.operationId)
+            throw new InvalidMarketConfigError(
+              "management",
+              "Management request changed; prepare again."
+            );
+        } else
+          await assertWriteDeployment(
+            scope,
+            prepared.context.key,
+            prepared.context.action === "setClaimOperator" || prepared.context.action === "claimFor"
+          );
+      });
+      await simulate(request);
+      const finalAccount = await account();
+      if (!isAddressEqual10(finalAccount.address, request.account))
+        throw new InvalidMarketConfigError("account", "Wallet account changed before signing.");
+      await fresh(prepared.context.block, prepared.context.expiresAt);
+      await checkNativeBudget(request);
+      let hash;
+      try {
+        hash = await walletClient.sendTransaction({
+          ...request,
+          account: finalAccount,
+          chain: walletClient.chain ?? null
+        });
+      } catch (cause) {
+        throw new MarketTransactionError("send", cause);
+      }
+      sent.set(hash, prepared);
+      submitted.add(prepared);
+      return hash;
+    } finally {
+      submitting.delete(prepared);
+    }
+  }
+  async function waitForTransaction(hash, options = {}) {
+    const prepared = sent.get(hash);
+    if (!prepared)
+      throw new InvalidMarketConfigError(
+        "hash",
+        "Only hashes sent by this client can be reconciled with its prepared action."
+      );
+    if (await publicClient.getChainId() !== chain.chainId)
+      throw new InvalidMarketConfigError("chainId", "Receipt client is on a different chain.");
+    try {
+      let replacement;
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash,
+        confirmations: chain.confirmations,
+        timeout: options.timeout,
+        onReplaced: ({ reason, transaction }) => {
+          if (reason !== "repriced")
+            replacement = new MarketTransactionReplacedError(hash, transaction.hash, reason);
+        }
+      });
+      if (replacement) throw replacement;
+      const result = transactionResultFromReceipt(receipt);
+      const managementEvents = [];
+      const management = prepared.context.management;
+      if (receipt.status === "success" && management) {
+        const eventAbi = [
+          ...marketRampAbi,
+          ...marketRwaRampAbi,
+          ...marketPoolRegistryAbi,
+          ...marketRampReaderAbi,
+          ...marketAccessManagerAbi
+        ];
+        for (const log of receipt.logs) {
+          const isAuthority = isAddressEqual10(log.address, chain.deployment.authority.address);
+          if (!isAuthority && !isAddressEqual10(log.address, management.target)) continue;
+          try {
+            const decoded = decodeEventLog({
+              abi: eventAbi,
+              data: log.data,
+              topics: log.topics,
+              strict: true
+            });
+            const args = Object.fromEntries(Object.entries(decoded.args ?? {}));
+            if (isAuthority && args.operationId !== management.operationId) continue;
+            if (!isAuthority && management.execution.mode === "schedule") continue;
+            managementEvents.push({ address: log.address, eventName: decoded.eventName, args });
+          } catch {
+          }
+        }
+        if (management.execution.mode !== "direct") {
+          const eventName = management.execution.mode === "schedule" ? "OperationScheduled" : "OperationExecuted";
+          if (!managementEvents.some(
+            (event) => event.eventName === eventName && isAddressEqual10(event.address, chain.deployment.authority.address)
+          ))
+            throw new InvalidMarketConfigError(
+              "receipt.events",
+              "Missing matching AccessManager operation event."
+            );
+        }
+      }
+      const events = [];
+      const shareEvents = [];
+      if (receipt.status === "success")
+        for (const log of receipt.logs) {
+          if (!isAddressEqual10(log.address, prepared.context.key.hooks)) continue;
+          try {
+            const decoded = decodeEventLog({
+              abi: marketRampAbi,
+              data: log.data,
+              topics: log.topics,
+              strict: true
+            });
+            const expected = prepared.context;
+            if (decoded.eventName === "Transfer") {
+              const a = decoded.args;
+              if ((expected.action === "transferShares" || expected.action === "transferSharesFrom") && a.id === expected.rangeId && isAddressEqual10(a.from, expected.owner) && isAddressEqual10(a.to, expected.recipient) && isAddressEqual10(a.caller, prepared.request.account))
+                shareEvents.push({
+                  eventName: "Transfer",
+                  caller: a.caller,
+                  from: a.from,
+                  to: a.to,
+                  rangeId: a.id,
+                  amount: a.amount
+                });
+              continue;
+            }
+            if (decoded.eventName === "Approval") {
+              const a = decoded.args;
+              if (expected.action === "approveShares" && a.id === expected.rangeId && isAddressEqual10(a.owner, expected.owner) && isAddressEqual10(a.spender, expected.recipient))
+                shareEvents.push({
+                  eventName: "Approval",
+                  owner: a.owner,
+                  spender: a.spender,
+                  rangeId: a.id,
+                  amount: a.amount
+                });
+              continue;
+            }
+            if (decoded.eventName === "OperatorSet" || decoded.eventName === "ClaimOperatorSet") {
+              const a = decoded.args;
+              if (isAddressEqual10(a.owner, expected.owner) && isAddressEqual10(a.operator, expected.recipient)) {
+                if (decoded.eventName === "OperatorSet" && expected.action === "setShareOperator")
+                  shareEvents.push({ eventName: "OperatorSet", ...decoded.args });
+                if (decoded.eventName === "ClaimOperatorSet" && expected.action === "setClaimOperator" && decoded.args.rangeId === expected.rangeId)
+                  shareEvents.push({ eventName: "ClaimOperatorSet", ...decoded.args });
+              }
+              continue;
+            }
+            if (decoded.eventName !== "Deposited" && decoded.eventName !== "Withdrawn" && decoded.eventName !== "FeesClaimed")
+              continue;
+            const args = decoded.args;
+            const to = "to" in args ? args.to : args.owner;
+            if (!isAddressEqual10(args.owner, prepared.context.owner) || args.rangeId !== prepared.context.rangeId || !isAddressEqual10(to, prepared.context.recipient))
+              continue;
+            events.push({
+              eventName: decoded.eventName,
+              owner: args.owner,
+              rangeId: args.rangeId,
+              amount0: args.amount0,
+              amount1: args.amount1,
+              liquidity: "liquidity" in args ? args.liquidity : null,
+              to
+            });
+          } catch {
+          }
+        }
+      const requiredEvent = prepared.context.action === "deposit" ? "Deposited" : prepared.context.action === "withdraw" || prepared.context.action === "withdrawAndClaim" ? "Withdrawn" : null;
+      if (receipt.status === "success" && requiredEvent && !events.some((event) => event.eventName === requiredEvent))
+        throw new InvalidMarketConfigError(
+          "receipt.events",
+          "Successful receipt is missing the matching liquidity event."
+        );
+      if (receipt.status === "success" && [
+        "transferShares",
+        "transferSharesFrom",
+        "approveShares",
+        "setShareOperator",
+        "setClaimOperator"
+      ].includes(prepared.context.action) && shareEvents.length === 0)
+        throw new InvalidMarketConfigError(
+          "receipt.events",
+          "Successful receipt is missing the matching share/authorization event."
+        );
+      return {
+        hash: result.hash,
+        status: receipt.status === "success" ? "confirmed" : "reverted",
+        receipt,
+        events,
+        shareEvents,
+        managementEvents
+      };
+    } catch (cause) {
+      if (cause instanceof MarketTransactionReplacedError) throw cause;
+      throw new MarketTransactionError("receipt", cause);
+    }
+  }
+  function shareRange(params) {
+    const key = liquidityKey(context, params.key);
+    return {
+      key,
+      rangeId: getMarketRangeId(
+        getMarketPoolId(key),
+        params.tickLower,
+        params.tickUpper,
+        key.tickSpacing
+      )
+    };
+  }
+  function transferShares(input) {
+    const params = immutableClone(input);
+    const { key, rangeId } = shareRange(params);
+    recipient(context, key, params.to);
+    assertMarketUint(params.amount, "shares", 128);
+    if (params.amount === 0n)
+      throw new InvalidMarketConfigError("shares", "Share transfer amount must be positive.");
+    if (params.owner) assertMarketAddress(params.owner, "owner");
+    return prepare({
+      action: params.owner ? "transferSharesFrom" : "transferShares",
+      key,
+      rangeId,
+      owner: params.owner,
+      to: params.to,
+      validForSeconds: params.validForSeconds,
+      data: params.owner ? encodeFunctionData2({
+        abi: marketRampAbi,
+        functionName: "transferFrom",
+        args: [params.owner, params.to, rangeId, params.amount]
+      }) : encodeFunctionData2({
+        abi: marketRampAbi,
+        functionName: "transfer",
+        args: [params.to, rangeId, params.amount]
+      })
+    });
+  }
+  return {
+    getManagementAuthorization: (input, owner, options = {}) => {
+      const action = immutableClone(input);
+      return readMarketSnapshot(
+        context,
+        {},
+        (scope) => inspectMarketManagementAt(scope, action, owner, options.when)
+      );
+    },
+    prepareManagement: async (input, options = {}) => {
+      const action = immutableClone(input);
+      const execution = immutableClone(options.execution ?? { mode: "direct" });
+      const call = encodeMarketManagement(context, action);
+      return prepare({
+        action: "management",
+        key: call.key,
+        to: call.to,
+        target: call.to,
+        data: call.data,
+        rangeId: null,
+        validForSeconds: options.validForSeconds,
+        management: { action, execution }
+      });
+    },
+    previewDeposit: (params) => preview("deposit", params),
+    previewWithdraw: (params) => preview("withdraw", params),
+    getSpendStatus: (params) => getMarketSpendStatus(context, params),
+    prepareApproval: async (input) => {
+      const params = immutableClone(input);
+      const key = liquidityKey(context, params.key);
+      if (params.currency !== 0 && params.currency !== 1)
+        throw new InvalidMarketConfigError("currency", "Choose currency 0 or 1.");
+      if (params.currency === 0 && isAddressEqual10(key.currency0, zeroAddress7))
+        throw new InvalidMarketConfigError(
+          "currency",
+          "Native currency does not support approval."
+        );
+      assertMarketUint(params.amount, "amount", 128);
+      const live = await account();
+      return prepare({
+        action: "approve",
+        key,
+        to: live.address,
+        target: params.currency === 0 ? key.currency0 : key.currency1,
+        rangeId: null,
+        validForSeconds: params.validForSeconds,
+        data: encodeFunctionData2({
+          abi: erc20Abi2,
+          functionName: "approve",
+          args: [key.hooks, params.amount]
+        })
+      });
+    },
+    prepareDeposit: async (value) => {
+      const q = requirePreview(value, "deposit");
+      const live = await account();
+      return prepare({
+        action: "deposit",
+        key: q.key,
+        to: live.address,
+        rangeId: q.rangeId,
+        preview: value,
+        data: encodeFunctionData2({
+          abi: marketRampAbi,
+          functionName: "deposit",
+          args: [q.key, q.tickLower, q.tickUpper, q.liquidity, q.limit0, q.limit1, q.deadline]
+        })
+      });
+    },
+    prepareWithdraw: (value, to) => prepareWithdraw(value, to),
+    prepareWithdrawAndClaim: (value, to, maxFeeBps) => prepareWithdraw(value, to, maxFeeBps),
+    prepareClaim: (input) => {
+      const params = immutableClone(input);
+      const key = liquidityKey(context, params.key);
+      recipient(context, key, params.to);
+      claimFee(params.maxFeeBps);
+      const rangeId = getMarketRangeId(
+        getMarketPoolId(key),
+        params.tickLower,
+        params.tickUpper,
+        key.tickSpacing
+      );
+      return prepare({
+        action: "claim",
+        key,
+        to: params.to,
+        rangeId,
+        validForSeconds: params.validForSeconds,
+        data: encodeFunctionData2({
+          abi: marketRampAbi,
+          functionName: "claimFees",
+          args: [key, params.tickLower, params.tickUpper, params.to, params.maxFeeBps]
+        })
+      });
+    },
+    prepareTransferShares: (params) => transferShares({ ...params, owner: void 0 }),
+    prepareTransferSharesFrom: (params) => {
+      assertMarketAddress(params.owner, "owner");
+      return transferShares(params);
+    },
+    prepareApproveShares: (input) => {
+      const params = immutableClone(input);
+      const { key, rangeId } = shareRange(params);
+      assertMarketAddress(params.spender, "spender");
+      assertMarketUint(params.amount, "allowance");
+      return prepare({
+        action: "approveShares",
+        key,
+        rangeId,
+        to: params.spender,
+        validForSeconds: params.validForSeconds,
+        data: encodeFunctionData2({
+          abi: marketRampAbi,
+          functionName: "approve",
+          args: [params.spender, rangeId, params.amount]
+        })
+      });
+    },
+    prepareSetShareOperator: (input) => {
+      const params = immutableClone(input);
+      const key = liquidityKey(context, params.key);
+      assertMarketAddress(params.operator, "operator");
+      if (typeof params.approved !== "boolean")
+        throw new InvalidMarketConfigError("approved", "Expected a boolean.");
+      return prepare({
+        action: "setShareOperator",
+        key,
+        rangeId: null,
+        to: params.operator,
+        validForSeconds: params.validForSeconds,
+        data: encodeFunctionData2({
+          abi: marketRampAbi,
+          functionName: "setOperator",
+          args: [params.operator, params.approved]
+        })
+      });
+    },
+    prepareSetClaimOperator: (input) => {
+      const params = immutableClone(input);
+      const { key, rangeId } = shareRange(params);
+      assertMarketAddress(params.operator, "operator");
+      if (typeof params.approved !== "boolean")
+        throw new InvalidMarketConfigError("approved", "Expected a boolean.");
+      return prepare({
+        action: "setClaimOperator",
+        key,
+        rangeId,
+        to: params.operator,
+        validForSeconds: params.validForSeconds,
+        data: encodeFunctionData2({
+          abi: marketRampAbi,
+          functionName: "setClaimOperator",
+          args: [rangeId, params.operator, params.approved]
+        })
+      });
+    },
+    prepareClaimFeesFor: (input) => {
+      const params = immutableClone(input);
+      const { key, rangeId } = shareRange(params);
+      assertMarketAddress(params.owner, "owner");
+      recipient(context, key, params.to);
+      claimFee(params.maxFeeBps);
+      return prepare({
+        action: "claimFor",
+        key,
+        rangeId,
+        owner: params.owner,
+        to: params.to,
+        validForSeconds: params.validForSeconds,
+        data: encodeFunctionData2({
+          abi: marketRampAbi,
+          functionName: "claimFeesFor",
+          args: [
+            key,
+            params.tickLower,
+            params.tickUpper,
+            params.owner,
+            params.to,
+            params.maxFeeBps
+          ]
+        })
+      });
+    },
+    send,
+    waitForTransaction
+  };
+}
+
+// src/verify.ts
+import { isAddressEqual as isAddressEqual11, keccak256 as keccak2566 } from "viem";
+function assertEqual(field, expected, actual) {
+  if (expected !== actual) throw new MarketDeploymentVerificationError(field, expected, actual);
+}
+async function verifyMarketDeployment(publicClient, input, options = {}) {
+  const deployment = defineMarketDeployment(input);
+  try {
+    assertEqual("chainId", deployment.chainId, await publicClient.getChainId());
+    const block = await publicClient.getBlock(
+      options.blockNumber === void 0 ? { blockTag: "latest" } : { blockNumber: options.blockNumber }
+    );
+    if (block.number === null || block.hash === null) {
+      throw new MarketDeploymentVerificationError("block", "mined block", block);
+    }
+    const blockNumber = block.number;
+    const contracts = [
+      deployment.poolManager,
+      deployment.registry,
+      deployment.authority,
+      ...deployment.reader ? [deployment.reader] : [],
+      ...deployment.poolStateReader?.kind === "state-view" ? [deployment.poolStateReader.contract] : [],
+      ...deployment.hooks.flatMap((hook2) => [
+        hook2,
+        hook2.claimFeePolicy,
+        ...hook2.calendar ? [hook2.calendar] : []
+      ])
+    ];
+    for (const contract2 of contracts) {
+      const code = await publicClient.getCode({ address: contract2.address, blockNumber });
+      if (!code || code === "0x") {
+        throw new MarketDeploymentVerificationError(contract2.address, "deployed code", code);
+      }
+      assertEqual(contract2.address, contract2.runtimeCodeHash.toLowerCase(), keccak2566(code));
+    }
+    const assertAddress = (field, expected, actual) => {
+      if (!isAddressEqual11(expected, actual)) {
+        throw new MarketDeploymentVerificationError(field, expected, actual);
+      }
+    };
+    if (deployment.poolStateReader?.kind === "state-view") {
+      assertAddress(
+        "stateView.poolManager",
+        deployment.poolManager.address,
+        await publicClient.readContract({
+          address: deployment.poolStateReader.contract.address,
+          abi: marketStateViewAbi,
+          functionName: "poolManager",
+          blockNumber
+        })
+      );
+    }
+    assertAddress(
+      "registry.authority",
+      deployment.authority.address,
+      await publicClient.readContract({
+        address: deployment.registry.address,
+        abi: marketPoolRegistryAbi,
+        functionName: "authority",
+        blockNumber
+      })
+    );
+    if (deployment.reader) {
+      const reader = {
+        address: deployment.reader.address,
+        abi: marketRampReaderAbi,
+        blockNumber
+      };
+      assertAddress(
+        "reader.registry",
+        deployment.registry.address,
+        await publicClient.readContract({ ...reader, functionName: "registry" })
+      );
+      assertAddress(
+        "reader.authority",
+        deployment.authority.address,
+        await publicClient.readContract({ ...reader, functionName: "authority" })
+      );
+    }
+    for (const hook2 of deployment.hooks) {
+      const target = { address: hook2.address, abi: marketRampAbi, blockNumber };
+      assertAddress(
+        `${hook2.address}.poolManager`,
+        deployment.poolManager.address,
+        await publicClient.readContract({ ...target, functionName: "poolManager" })
+      );
+      assertAddress(
+        `${hook2.address}.authority`,
+        deployment.authority.address,
+        await publicClient.readContract({ ...target, functionName: "authority" })
+      );
+      assertAddress(
+        `${hook2.address}.claimFeePolicy`,
+        hook2.claimFeePolicy.address,
+        await publicClient.readContract({ ...target, functionName: "claimFeePolicy" })
+      );
+      assertAddress(
+        `${hook2.address}.policy.ledger`,
+        hook2.address,
+        await publicClient.readContract({
+          address: hook2.claimFeePolicy.address,
+          abi: marketClaimFeePolicyAbi,
+          functionName: "ledger",
+          blockNumber
+        })
+      );
+      assertEqual(
+        `${hook2.address}.MAX_POKE_DISCOUNT_BPS`,
+        5e3,
+        await publicClient.readContract({ ...target, functionName: "MAX_POKE_DISCOUNT_BPS" })
+      );
+      if (hook2.calendar) {
+        assertAddress(
+          `${hook2.address}.calendar`,
+          hook2.calendar.address,
+          await publicClient.readContract({
+            address: hook2.address,
+            abi: marketRwaRampAbi,
+            functionName: "marketCalendar",
+            blockNumber
+          })
+        );
+        assertAddress(
+          `${hook2.address}.calendar.controller`,
+          hook2.address,
+          await publicClient.readContract({
+            address: hook2.calendar.address,
+            abi: marketMarketCalendarAbi,
+            functionName: "controller",
+            blockNumber
+          })
+        );
+      }
+      if (deployment.reader) {
+        assertEqual(
+          `${hook2.address}.readerKind`,
+          hook2.kind === "rwa-ramp" ? 2 : 1,
+          await publicClient.readContract({
+            address: deployment.reader.address,
+            abi: marketRampReaderAbi,
+            functionName: "hookKind",
+            args: [hook2.address],
+            blockNumber
+          })
+        );
+      }
+    }
+    const finalBlock = await publicClient.getBlock({ blockNumber });
+    assertEqual("blockHash", block.hash, finalBlock.hash);
+    return Object.freeze({
+      chainId: deployment.chainId,
+      deploymentId: deployment.deploymentId,
+      blockNumber,
+      blockHash: block.hash,
+      scope: "code-and-wiring",
+      checkedContracts: contracts.length
+    });
+  } catch (error) {
+    if (error instanceof MarketDeploymentVerificationError) throw error;
+    throw new MarketReadError(error);
+  }
+}
+
+// src/client.ts
+function createMarketClient(options) {
+  const chain = defineMarketChain(options.chain);
+  const publicClient = options.publicClient;
+  if (publicClient.chain && publicClient.chain.id !== chain.chainId) {
+    throw new InvalidMarketConfigError("publicClient.chain", "Public client chain does not match.");
+  }
+  const context = { publicClient, deployment: chain.deployment };
+  return Object.freeze({
+    chain,
+    getClaimOperator: (params) => getMarketClaimOperator(context, params),
+    getShareAuthorization: (params) => getMarketShareAuthorization(context, params),
+    getFeeSnapshot: (params) => getMarketFeeSnapshot(context, params),
+    estimateClaimableFees: (params) => estimateMarketClaimableFees(context, params),
+    ...createMarketWriteActions(publicClient, options.walletClient, chain),
+    verifyDeployment: (readOptions) => verifyMarketDeployment(publicClient, chain.deployment, readOptions),
+    getPool: (poolId, readOptions) => getMarketPool(context, poolId, readOptions),
+    listPools: (params) => listMarketPools(context, params),
+    getCurrentFees: (poolId, readOptions) => getMarketCurrentFees(context, poolId, readOptions),
+    getFeeBreakdown: (poolId, zeroForOne, readOptions) => getMarketFeeBreakdown(context, poolId, zeroForOne, readOptions),
+    previewFeeAt: (poolId, zeroForOne, timestamp, readOptions) => previewMarketFeeAt(context, poolId, zeroForOne, timestamp, readOptions),
+    getSession: (poolId, readOptions) => getMarketSession(context, poolId, readOptions),
+    getRange: (params) => getMarketRange(context, params),
+    getPosition: (params) => getMarketPosition(context, params),
+    getPoolState: (poolId, readOptions) => getMarketPoolState(context, poolId, readOptions)
+  });
+}
+
+// src/test-pools.ts
+var marketTestPools = [
+  {
+    chainId: 5042,
+    name: "tBTC/tUSDC",
+    testAssets: true,
+    permissionlessMint: true,
+    hookKind: "ramp",
+    poolId: "0x1a325fe4671d6584778464cbe5ea68b111c2a72718f128a9427717298e85e2cd",
+    key: {
+      currency0: "0x442fc5b4d43fb7ec18ff8ac0a8fb9fdd2efec0db",
+      currency1: "0x44e90eb500868af9b0b16406f3ce165c90e1e85e",
+      fee: 8388608,
+      tickSpacing: 1,
+      hooks: "0x928f4c9b7f80dcbe95b606867e76336a956fa080"
+    },
+    base: {
+      symbol: "tBTC",
+      address: "0x442fc5b4d43fb7ec18ff8ac0a8fb9fdd2efec0db",
+      decimals: 8
+    },
+    quote: {
+      symbol: "tUSDC",
+      address: "0x44e90eb500868af9b0b16406f3ce165c90e1e85e",
+      decimals: 6
+    },
+    components: {
+      poolManager: "0x8366a39cc670b4001a1121b8f6a443a643e40951",
+      registry: "0x3386feb5016983790ef05410e888a8b7bf5a722d",
+      reader: "0xbd782f3de07f2c8f27ef3a2cb165f36c5a505e45",
+      accessManager: "0x005710955b542c11fa2259721840329cddf44914"
+    },
+    source: {
+      commit: "cf16bd9376c12ea50de04658b279176d8d56e4f5",
+      path: "docs/test-pools/arc.json",
+      blockNumber: 23523593,
+      blockHash: "0xea3eb1e8cd308955ad999df48212f3b839e3eec7b55cf7702aba213d548f847d"
+    }
+  },
+  {
+    chainId: 56,
+    name: "tBNB/tUSDT",
+    testAssets: true,
+    permissionlessMint: true,
+    hookKind: "ramp",
+    poolId: "0xb1cf54cb728bb02bb40def7d4f088a7274f35ef05b6257cb518d5f10be438bee",
+    key: {
+      currency0: "0x78e708f1f8fe842abaaeaf23ade31e524e153980",
+      currency1: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d",
+      fee: 8388608,
+      tickSpacing: 1,
+      hooks: "0xa6a75d930f7a920391c4afffe744069233c4e080"
+    },
+    base: {
+      symbol: "tBNB",
+      address: "0x78e708f1f8fe842abaaeaf23ade31e524e153980",
+      decimals: 18
+    },
+    quote: {
+      symbol: "tUSDT",
+      address: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d",
+      decimals: 18
+    },
+    components: {
+      poolManager: "0x28e2Ea090877bF75740558f6BFB36A5ffeE9e9dF",
+      registry: "0xe75be888ae3d92be2f962f62f78775228eb3cbc9",
+      reader: "0x2fd8d887a67bf61166e5aacae375cda0ad72d292",
+      accessManager: "0x09e9f944a86c5c239eb0dceac85e1f4805d61256"
+    },
+    source: {
+      commit: "cf16bd9376c12ea50de04658b279176d8d56e4f5",
+      path: "docs/test-pools/bsc.json",
+      blockNumber: 124890195,
+      blockHash: "0xba1ae7df7b719fc6d0cf4b49a2278926fc6c62aaf12e2bc49c9788579bba948e"
+    }
+  },
+  {
+    chainId: 56,
+    name: "tQQQ/tUSDT",
+    testAssets: true,
+    permissionlessMint: true,
+    hookKind: "rwa-ramp",
+    poolId: "0x9ccf485776611256dd717db8c53808e370160d8c90668a75c6d456dd07f21423",
+    key: {
+      currency0: "0x51984c455a78c072f9a23453e236bd3729dc3efd",
+      currency1: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d",
+      fee: 8388608,
+      tickSpacing: 1,
+      hooks: "0x7b144d9583c71a1b20cb26954d2ccd330af46080"
+    },
+    base: {
+      symbol: "tQQQ",
+      address: "0x51984c455a78c072f9a23453e236bd3729dc3efd",
+      decimals: 18
+    },
+    quote: {
+      symbol: "tUSDT",
+      address: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d",
+      decimals: 18
+    },
+    components: {
+      poolManager: "0x28e2Ea090877bF75740558f6BFB36A5ffeE9e9dF",
+      registry: "0xe75be888ae3d92be2f962f62f78775228eb3cbc9",
+      reader: "0x2fd8d887a67bf61166e5aacae375cda0ad72d292",
+      accessManager: "0x09e9f944a86c5c239eb0dceac85e1f4805d61256"
+    },
+    source: {
+      commit: "cf16bd9376c12ea50de04658b279176d8d56e4f5",
+      path: "docs/test-pools/bsc.json",
+      blockNumber: 124890195,
+      blockHash: "0xba1ae7df7b719fc6d0cf4b49a2278926fc6c62aaf12e2bc49c9788579bba948e"
+    }
+  }
+];
+export {
+  InvalidMarketConfigError,
+  MarketDeploymentVerificationError,
+  MarketFeatureUnavailableError,
+  MarketReadError,
+  MarketSettlingError,
+  MarketTransactionError,
+  MarketTransactionReplacedError,
+  calculateMarketClaimableFees,
+  createMarketClient,
+  defineMarketChain,
+  defineMarketDeployment,
+  defineMarketPoolKey,
+  estimateMarketClaimableFees,
+  getMarketAmountsForLiquidity,
+  getMarketClaimOperator,
+  getMarketCurrentFees,
+  getMarketFeeBreakdown,
+  getMarketFeeSnapshot,
+  getMarketLiquidityForAmounts,
+  getMarketPool,
+  getMarketPoolId,
+  getMarketPoolState,
+  getMarketPosition,
+  getMarketPriceRatio,
+  getMarketRange,
+  getMarketRangeId,
+  getMarketSession,
+  getMarketShareAuthorization,
+  getMarketSpendStatus,
+  getMarketSqrtPriceAtTick,
+  getMarketSwapDirection,
+  getMarketTickAtSqrtPrice,
+  listMarketPools,
+  marketDaysInMonth,
+  marketTestPools,
+  packMarketDayOverrides,
+  previewMarketFeeAt,
+  verifyMarketDeployment
+};
+//# sourceMappingURL=index.js.map