@masterpeach/market-sdk 0.2.0-beta.20260930.1

package/dist/index.d.ts

@@ -0,0 +1,840 @@
+import * as viem from 'viem';
+import { Address, Hex, PublicClient, TransactionReceipt, WalletClient } from 'viem';
+
+/** Expected runtime hash must come from reviewed deployment evidence, not a fresh RPC read. */
+interface MarketContractDeployment {
+    readonly address: Address;
+    readonly runtimeCodeHash: Hex;
+}
+type MarketHookKind = "ramp" | "ramp-eth" | "rwa-ramp";
+/** Caller-supplied acceptance evidence. Code identity checks never promote this status. */
+type MarketCapabilityStatus = "disabled" | "unverified" | "verified";
+interface MarketHookCapabilities {
+    readonly liquidity: MarketCapabilityStatus;
+    readonly nativeLiquidity: MarketCapabilityStatus;
+    readonly claimOperator: MarketCapabilityStatus;
+    readonly management: MarketCapabilityStatus;
+}
+interface MarketHookDeployment extends MarketContractDeployment {
+    readonly kind: MarketHookKind;
+    readonly implementation: "ramp-v1";
+    readonly claimFeePolicy: MarketContractDeployment;
+    /** Required for rwa-ramp, forbidden for other kinds. */
+    readonly calendar?: MarketContractDeployment;
+    readonly capabilities: MarketHookCapabilities;
+}
+interface MarketDeployment {
+    readonly chainId: number;
+    readonly deploymentId: string;
+    readonly poolManager: MarketContractDeployment;
+    readonly registry: MarketContractDeployment;
+    readonly authority: MarketContractDeployment;
+    readonly reader?: MarketContractDeployment;
+    /** No implicit storage layout or StateView address is assumed. */
+    readonly poolStateReader?: {
+        readonly kind: "state-view";
+        readonly contract: MarketContractDeployment;
+    } | {
+        readonly kind: "extsload";
+        readonly layout: "uniswap-v4-v1";
+    };
+    readonly hooks: readonly MarketHookDeployment[];
+}
+interface MarketChainConfig {
+    readonly chainId: number;
+    readonly deployment: MarketDeployment;
+    readonly confirmations: number;
+}
+/** Raw v4 coordinates. Pool IDs are not token-pair IDs. */
+interface MarketPoolKey {
+    readonly currency0: Address;
+    readonly currency1: Address;
+    readonly fee: number;
+    readonly tickSpacing: number;
+    readonly hooks: Address;
+}
+interface MarketDeploymentVerification {
+    readonly chainId: number;
+    readonly deploymentId: string;
+    readonly blockNumber: bigint;
+    readonly blockHash: Hex;
+    /** Code and wiring only; does not certify liquidity actions or future state. */
+    readonly scope: "code-and-wiring";
+    readonly checkedContracts: number;
+}
+
+interface MarketReadContext {
+    readonly publicClient: PublicClient;
+    readonly deployment: MarketDeployment;
+}
+interface MarketReadOptions {
+    readonly blockNumber?: bigint;
+    /** For continuing pagination or composing multiple reads across exactly the same snapshot. */
+    readonly blockHash?: Hex;
+}
+interface MarketBlock {
+    readonly chainId: number;
+    readonly deploymentId: string;
+    readonly blockNumber: bigint;
+    readonly blockHash: Hex;
+    readonly timestamp: bigint;
+}
+interface MarketSnapshot<T> {
+    readonly block: MarketBlock;
+    readonly data: T;
+}
+interface MarketPool {
+    readonly key: MarketPoolKey;
+    readonly poolId: Hex;
+    readonly active: boolean;
+    /** Registry discovery alone does not establish SDK support or readiness to trade. */
+    readonly hookKind: MarketHookKind | null;
+}
+interface MarketListPoolsParams extends MarketReadOptions {
+    readonly offset?: bigint;
+    /** Number of registry entries scanned, not the number of active results; maximum 100. */
+    readonly limit?: number;
+    readonly activeOnly?: boolean;
+}
+interface MarketPoolPage {
+    readonly pools: readonly MarketPool[];
+    readonly totalCount: bigint;
+    readonly nextOffset: bigint | null;
+}
+type MarketSession = "open" | "overnight" | "closed";
+interface MarketFeeBreakdown {
+    readonly pool: MarketPool;
+    readonly zeroForOne: boolean;
+    readonly timestamp: bigint;
+    readonly mode: "current" | "preview";
+    readonly session: MarketSession | null;
+    readonly baseFeePips: bigint;
+    readonly directionalPremiumPips: number;
+    readonly cappedAutonomousFeePips: number;
+    readonly overrideActive: boolean;
+    readonly overrideFeePips: number;
+    readonly overrideExpiry: bigint;
+    readonly overrideMinFeePips: number;
+    readonly maxFeePips: number;
+    readonly finalFeePips: number;
+}
+interface MarketCurrentFees {
+    readonly pool: MarketPool;
+    readonly fee0For1Pips: number;
+    readonly fee1For0Pips: number;
+    readonly globalPaused: boolean;
+    readonly poolPaused: boolean;
+}
+interface MarketSessionState {
+    readonly pool: MarketPool;
+    readonly session: MarketSession | null;
+    readonly timestamp: bigint;
+    readonly mode: "current" | "preview";
+}
+interface MarketRangeParams extends MarketReadOptions {
+    readonly hook: Address;
+    readonly rangeId: bigint;
+}
+interface MarketPositionParams extends MarketRangeParams {
+    readonly owner: Address;
+}
+interface MarketRangeState {
+    readonly totalShares: bigint;
+    readonly accFee0X128: bigint;
+    readonly accFee1X128: bigint;
+    readonly collectionSeq: bigint;
+    readonly resetSeq: bigint;
+}
+type MarketRange = {
+    readonly status: "unset";
+    readonly hook: Address;
+    readonly rangeId: bigint;
+} | {
+    readonly status: "set";
+    readonly hook: Address;
+    readonly rangeId: bigint;
+    readonly poolId: Hex;
+    readonly key: MarketPoolKey;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly state: MarketRangeState;
+    readonly globalPaused: boolean;
+    readonly poolPaused: boolean;
+    readonly effectiveClaimFeeBps: number;
+};
+interface MarketPosition {
+    readonly range: MarketRange;
+    readonly owner: Address;
+    readonly shares: bigint;
+    /** Already settled net token base units only; NOT total live claimable earnings. */
+    readonly settledOwed0: bigint;
+    readonly settledOwed1: bigint;
+    readonly checkpoint0X128: bigint;
+    readonly checkpoint1X128: bigint;
+    readonly remainder0X128: bigint;
+    readonly remainder1X128: bigint;
+}
+interface MarketPoolState {
+    readonly pool: MarketPool;
+    readonly source: "state-view" | "extsload";
+    readonly initialized: boolean;
+    readonly sqrtPriceX96: bigint;
+    readonly tick: number;
+    readonly protocolFeePacked: number;
+    /** Stored v4 fee, not the directional Hook fee used for an actual swap. */
+    readonly storedLpFeePips: number;
+    readonly activeLiquidity: bigint;
+}
+
+interface MarketFeeLedger {
+    readonly position: MarketPosition & {
+        readonly range: Extract<MarketPosition["range"], {
+            status: "set";
+        }>;
+    };
+    readonly managerLiquidity: bigint;
+    readonly growth0X128: bigint;
+    readonly growth1X128: bigint;
+    readonly lastGrowth0X128: bigint;
+    readonly lastGrowth1X128: bigint;
+    readonly claimFeeSyncIndex: bigint;
+    readonly policyHistoryLength: bigint;
+    readonly currentClaimFeeBps: number;
+    readonly allTimeMinClaimFeeBps: number;
+}
+interface MarketTokenEarnings {
+    readonly settled: bigint;
+    /** Net earnings already accumulated by the Hook but not checkpointed to this owner. */
+    readonly synchronized: bigint;
+    /** Additional whole base units this owner would earn after collecting manager fees now. */
+    readonly pending: bigint;
+    readonly claimable: bigint;
+    readonly remainderX128: bigint;
+    readonly pendingRangeGross: bigint;
+    readonly pendingRangeProtocolFee: bigint;
+}
+interface MarketClaimableFees {
+    readonly ledger: MarketFeeLedger;
+    readonly token0: MarketTokenEarnings;
+    readonly token1: MarketTokenEarnings;
+    /** Accounting estimate, even if paused or no whole units can currently be claimed. */
+    readonly paused: boolean;
+    readonly hasClaimableAmount: boolean;
+}
+interface MarketShareAuthorization {
+    readonly hook: Address;
+    readonly rangeId: bigint;
+    readonly owner: Address;
+    readonly operator: Address;
+    readonly shares: bigint;
+    readonly allowance: bigint;
+    readonly isShareOperator: boolean;
+    /** Independently authorized fee payouts for this one range. */
+    readonly isClaimOperator: boolean;
+}
+
+declare function getMarketShareAuthorization(context: MarketReadContext, params: MarketReadOptions & {
+    readonly hook: Address;
+    readonly rangeId: bigint;
+    readonly owner: Address;
+    readonly operator: Address;
+}): Promise<MarketSnapshot<MarketShareAuthorization>>;
+declare function getMarketClaimOperator(context: MarketReadContext, params: Parameters<typeof getMarketShareAuthorization>[1]): Promise<MarketSnapshot<{
+    hook: `0x${string}`;
+    owner: `0x${string}`;
+    operator: `0x${string}`;
+    rangeId: bigint;
+    approved: boolean;
+}>>;
+
+declare function getMarketFeeSnapshot(context: MarketReadContext, input: MarketPositionParams): Promise<MarketSnapshot<MarketFeeLedger>>;
+declare function estimateMarketClaimableFees(context: MarketReadContext, params: MarketPositionParams): Promise<{
+    block: MarketBlock;
+    data: MarketClaimableFees;
+}>;
+
+declare function getMarketCurrentFees(context: MarketReadContext, poolId: Hex, options?: MarketReadOptions): Promise<MarketSnapshot<MarketCurrentFees>>;
+declare function getMarketFeeBreakdown(context: MarketReadContext, poolId: Hex, zeroForOne: boolean, options?: MarketReadOptions): Promise<MarketSnapshot<MarketFeeBreakdown>>;
+/** Uses the selected block's configuration, not historical configuration at the requested timestamp. */
+declare function previewMarketFeeAt(context: MarketReadContext, poolId: Hex, zeroForOne: boolean, timestamp: bigint, options?: MarketReadOptions): Promise<MarketSnapshot<MarketFeeBreakdown>>;
+declare function getMarketSession(context: MarketReadContext, poolId: Hex, options?: MarketReadOptions & {
+    readonly timestamp?: bigint;
+}): Promise<MarketSnapshot<MarketSessionState>>;
+
+declare function getMarketPoolState(context: MarketReadContext, poolId: Hex, options?: MarketReadOptions): Promise<MarketSnapshot<MarketPoolState>>;
+
+declare function getMarketPool(context: MarketReadContext, poolId: Hex, options?: MarketReadOptions): Promise<MarketSnapshot<MarketPool>>;
+declare function listMarketPools(context: MarketReadContext, params?: MarketListPoolsParams): Promise<MarketSnapshot<MarketPoolPage>>;
+
+declare function getMarketRange(context: MarketReadContext, params: MarketRangeParams): Promise<MarketSnapshot<MarketRange>>;
+declare function getMarketPosition(context: MarketReadContext, params: MarketPositionParams): Promise<MarketSnapshot<MarketPosition>>;
+
+interface MarketRwaFloorConfig {
+    readonly openFloor: number;
+    readonly overnightFloor: number;
+    readonly closedFloor: number;
+    readonly spikeMult: number;
+    readonly closedSpike: number;
+    readonly descentWindow: number;
+    readonly closeFloor: number;
+    readonly closeBefore: number;
+    readonly closeAfter: number;
+}
+interface MarketDayOverride {
+    readonly day: number;
+    readonly status: "closed" | "open";
+}
+/** key selects an audited Hook even for Hook-wide operations. settleFirst is intentionally required. */
+type MarketManagementAction = {
+    readonly key: MarketPoolKey;
+} & ({
+    readonly kind: "pokeFee";
+    readonly fee0For1: number;
+    readonly fee1For0: number;
+    readonly ttl: number;
+} | {
+    readonly kind: "clearPoke";
+} | {
+    readonly kind: "setPoolAsymmetry";
+    readonly premiumPips: number;
+    readonly premiumZeroForOne: boolean;
+} | {
+    readonly kind: "setCryptoPoolConfig";
+    readonly floorPips: number;
+    readonly flatPips: number;
+    readonly cap: number;
+} | {
+    readonly kind: "setRwaPoolConfig";
+    readonly config: MarketRwaFloorConfig;
+    readonly cap: number;
+} | {
+    readonly kind: "setSessionHours";
+    readonly openSec: number;
+    readonly closeSec: number;
+} | {
+    readonly kind: "setDayOverrides";
+    readonly year: number;
+    readonly month: number;
+    readonly days: readonly MarketDayOverride[];
+} | {
+    readonly kind: "setDstMode";
+    readonly mode: "auto" | "est" | "edt";
+} | {
+    readonly kind: "setEarlyClose";
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly closeSec: number;
+} | {
+    readonly kind: "setPaused" | "setPoolPaused";
+    readonly duration: number;
+} | {
+    readonly kind: "setClaimFee";
+    readonly bps: number;
+    readonly recipient: Address;
+    readonly settleFirst: readonly Address[];
+} | {
+    readonly kind: "setClaimFeeBps";
+    readonly bps: number;
+} | {
+    readonly kind: "sweepClaimFee";
+    readonly currency: Address;
+} | {
+    readonly kind: "register" | "deregister" | "reregister";
+} | {
+    readonly kind: "disableHook";
+} | {
+    readonly kind: "setHook";
+    readonly expectedCodeHash: Hex;
+});
+type MarketManagementExecution = {
+    readonly mode: "direct";
+} | {
+    readonly mode: "schedule" /** Zero lets AccessManager choose block.timestamp + delay. */;
+    readonly when?: number;
+} | {
+    readonly mode: "execute";
+};
+interface MarketManagementAuthorization {
+    readonly permission: "immediate" | "delayed" | "denied";
+    readonly delay: number;
+    readonly operationId: Hex;
+    readonly scheduledAt: number;
+    readonly direct: {
+        readonly to: Address;
+        readonly data: Hex;
+        readonly value: 0n;
+    };
+    readonly schedule: {
+        readonly to: Address;
+        readonly data: Hex;
+        readonly value: 0n;
+    };
+    readonly execute: {
+        readonly to: Address;
+        readonly data: Hex;
+        readonly value: 0n;
+    };
+}
+interface MarketManagementContext {
+    readonly action: MarketManagementAction;
+    readonly execution: MarketManagementExecution;
+    readonly target: Address;
+    readonly operationId: Hex;
+}
+interface MarketManagementEvent {
+    readonly address: Address;
+    readonly eventName: string;
+    readonly args: Readonly<Record<string, unknown>>;
+}
+
+interface MarketLiquidityParams {
+    readonly key: MarketPoolKey;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly liquidity: bigint;
+    /** Token amount tolerance, not a tick or price tolerance. 0..9999. */
+    readonly slippageBps: number;
+    readonly deadline: bigint;
+    /** Snapshot lifetime; default 60 seconds, maximum 300. */
+    readonly validForSeconds?: number;
+}
+interface MarketLiquidityQuote extends MarketLiquidityParams {
+    readonly action: "deposit" | "withdraw";
+    readonly rangeId: bigint;
+    readonly sqrtPriceX96: bigint;
+    readonly amount0: bigint;
+    readonly amount1: bigint;
+    /** Maximum spend for deposit, minimum principal returned for withdrawal. */
+    readonly limit0: bigint;
+    readonly limit1: bigint;
+    /** Exact prepaid native maximum; refund is an estimate at the preview price. */
+    readonly nativeValue: bigint;
+    readonly estimatedNativeRefund: bigint;
+    readonly expiresAt: bigint;
+}
+type MarketLiquidityPreview = MarketSnapshot<MarketLiquidityQuote>;
+interface MarketClaimParams {
+    readonly key: MarketPoolKey;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly to: Address;
+    readonly maxFeeBps: number;
+    /** Local prepared-request expiry; claimFees has no on-chain deadline parameter. */
+    readonly validForSeconds?: number;
+}
+interface MarketApprovalParams {
+    readonly key: MarketPoolKey;
+    readonly currency: 0 | 1;
+    /** Exact replacement allowance, not the missing delta. Zero explicitly revokes/resets. */
+    readonly amount: bigint;
+    readonly validForSeconds?: number;
+}
+interface MarketSpendStatus {
+    readonly owner: Address;
+    readonly spender: Address;
+    readonly tokens: readonly {
+        readonly token: Address;
+        readonly balance: bigint;
+        readonly kind: "native" | "erc20";
+        /** Native currency has no allowance. Balance sufficiency excludes gas. */
+        readonly allowance: bigint | null;
+        readonly requiredAmount: bigint;
+        readonly needsApproval: boolean;
+        readonly sufficientBalance: boolean;
+    }[];
+}
+interface MarketTransactionRequest {
+    readonly account: Address;
+    readonly to: Address;
+    readonly data: Hex;
+    readonly value: bigint;
+    /** Native-pool transactions bind an EIP-1559 gas budget during preparation. */
+    readonly gas?: bigint;
+    readonly maxFeePerGas?: bigint;
+    readonly maxPriorityFeePerGas?: bigint;
+    readonly chainId: number;
+}
+type MarketWriteAction = "approve" | "deposit" | "withdraw" | "claim" | "withdrawAndClaim" | "transferShares" | "transferSharesFrom" | "approveShares" | "setShareOperator" | "setClaimOperator" | "claimFor" | "management";
+interface MarketPreparedTransaction {
+    readonly request: MarketTransactionRequest;
+    readonly preview: MarketLiquidityPreview | null;
+    readonly context: {
+        readonly action: MarketWriteAction;
+        readonly management?: MarketManagementContext;
+        readonly key: MarketPoolKey;
+        readonly rangeId: bigint | null;
+        readonly block: MarketBlock;
+        readonly expiresAt: bigint;
+        readonly recipient: Address;
+        /** Beneficiary / share owner; may differ from the wallet performing delegated actions. */
+        readonly owner: Address;
+    };
+}
+interface MarketLiquidityEvent {
+    readonly eventName: "Deposited" | "Withdrawn" | "FeesClaimed";
+    readonly owner: Address;
+    readonly rangeId: bigint;
+    readonly amount0: bigint;
+    readonly amount1: bigint;
+    readonly liquidity: bigint | null;
+    readonly to: Address;
+}
+interface MarketTransactionResult {
+    readonly hash: Hex;
+    readonly status: "confirmed" | "reverted";
+    readonly receipt: TransactionReceipt;
+    /** Only matching Hook, owner, range and recipient logs. Claim may succeed with no payout. */
+    readonly events: readonly MarketLiquidityEvent[];
+    readonly shareEvents: readonly MarketShareEvent[];
+    readonly managementEvents: readonly MarketManagementEvent[];
+}
+interface MarketShareRangeParams {
+    readonly key: MarketPoolKey;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly validForSeconds?: number;
+}
+interface MarketShareTransferParams extends MarketShareRangeParams {
+    readonly to: Address;
+    readonly amount: bigint;
+}
+type MarketShareEvent = {
+    readonly eventName: "Transfer";
+    readonly caller: Address;
+    readonly from: Address;
+    readonly to: Address;
+    readonly rangeId: bigint;
+    readonly amount: bigint;
+} | {
+    readonly eventName: "Approval";
+    readonly owner: Address;
+    readonly spender: Address;
+    readonly rangeId: bigint;
+    readonly amount: bigint;
+} | {
+    readonly eventName: "OperatorSet";
+    readonly owner: Address;
+    readonly operator: Address;
+    readonly approved: boolean;
+} | {
+    readonly eventName: "ClaimOperatorSet";
+    readonly owner: Address;
+    readonly operator: Address;
+    readonly rangeId: bigint;
+    readonly approved: boolean;
+};
+
+declare function getMarketSpendStatus(context: MarketReadContext, params: {
+    readonly key: MarketLiquidityParams["key"];
+    readonly owner: Address;
+    readonly amount0: bigint;
+    readonly amount1: bigint;
+} & MarketReadOptions): Promise<MarketSnapshot<MarketSpendStatus>>;
+
+declare function defineMarketChain(input: MarketChainConfig): MarketChainConfig;
+
+interface MarketClientOptions {
+    readonly publicClient: PublicClient;
+    readonly chain: MarketChainConfig;
+    readonly walletClient?: WalletClient;
+}
+/** Construction does not issue RPC requests or certify the deployment. Wallet is optional for reads. */
+declare function createMarketClient(options: MarketClientOptions): Readonly<{
+    verifyDeployment: (readOptions?: {
+        readonly blockNumber?: bigint;
+    }) => Promise<MarketDeploymentVerification>;
+    getPool: (poolId: Hex, readOptions?: MarketReadOptions) => Promise<MarketSnapshot<MarketPool>>;
+    listPools: (params?: MarketListPoolsParams) => Promise<MarketSnapshot<MarketPoolPage>>;
+    getCurrentFees: (poolId: Hex, readOptions?: MarketReadOptions) => Promise<MarketSnapshot<MarketCurrentFees>>;
+    getFeeBreakdown: (poolId: Hex, zeroForOne: boolean, readOptions?: MarketReadOptions) => Promise<MarketSnapshot<MarketFeeBreakdown>>;
+    previewFeeAt: (poolId: Hex, zeroForOne: boolean, timestamp: bigint, readOptions?: MarketReadOptions) => Promise<MarketSnapshot<MarketFeeBreakdown>>;
+    getSession: (poolId: Hex, readOptions?: MarketReadOptions & {
+        readonly timestamp?: bigint;
+    }) => Promise<MarketSnapshot<MarketSessionState>>;
+    getRange: (params: MarketRangeParams) => Promise<MarketSnapshot<MarketRange>>;
+    getPosition: (params: MarketPositionParams) => Promise<MarketSnapshot<MarketPosition>>;
+    getPoolState: (poolId: Hex, readOptions?: MarketReadOptions) => Promise<MarketSnapshot<MarketPoolState>>;
+    getManagementAuthorization: (input: MarketManagementAction, owner: viem.Address, options?: {
+        readonly when?: number;
+    }) => Promise<MarketSnapshot<MarketManagementAuthorization>>;
+    prepareManagement: (input: MarketManagementAction, options?: {
+        readonly execution?: MarketManagementExecution;
+        readonly validForSeconds?: number;
+    }) => Promise<MarketPreparedTransaction>;
+    previewDeposit: (params: MarketLiquidityParams) => Promise<MarketLiquidityPreview>;
+    previewWithdraw: (params: MarketLiquidityParams) => Promise<MarketLiquidityPreview>;
+    getSpendStatus: (params: Parameters<typeof getMarketSpendStatus>[1]) => Promise<MarketSnapshot<MarketSpendStatus>>;
+    prepareApproval: (input: MarketApprovalParams) => Promise<MarketPreparedTransaction>;
+    prepareDeposit: (value: MarketLiquidityPreview) => Promise<MarketPreparedTransaction>;
+    prepareWithdraw: (value: MarketLiquidityPreview, to: viem.Address) => Promise<MarketPreparedTransaction>;
+    prepareWithdrawAndClaim: (value: MarketLiquidityPreview, to: viem.Address, maxFeeBps: number) => Promise<MarketPreparedTransaction>;
+    prepareClaim: (input: MarketClaimParams) => Promise<MarketPreparedTransaction>;
+    prepareTransferShares: (params: MarketShareTransferParams) => Promise<MarketPreparedTransaction>;
+    prepareTransferSharesFrom: (params: MarketShareTransferParams & {
+        readonly owner: viem.Address;
+    }) => Promise<MarketPreparedTransaction>;
+    prepareApproveShares: (input: MarketShareRangeParams & {
+        readonly spender: viem.Address;
+        readonly amount: bigint;
+    }) => Promise<MarketPreparedTransaction>;
+    prepareSetShareOperator: (input: {
+        readonly key: MarketPoolKey;
+        readonly operator: viem.Address;
+        readonly approved: boolean;
+        readonly validForSeconds?: number;
+    }) => Promise<MarketPreparedTransaction>;
+    prepareSetClaimOperator: (input: MarketShareRangeParams & {
+        readonly operator: viem.Address;
+        readonly approved: boolean;
+    }) => Promise<MarketPreparedTransaction>;
+    prepareClaimFeesFor: (input: MarketClaimParams & {
+        readonly owner: viem.Address;
+    }) => Promise<MarketPreparedTransaction>;
+    send: (prepared: MarketPreparedTransaction) => Promise<Hex>;
+    waitForTransaction: (hash: Hex, options?: {
+        readonly timeout?: number;
+    }) => Promise<MarketTransactionResult>;
+    chain: MarketChainConfig;
+    getClaimOperator: (params: Parameters<typeof getMarketClaimOperator>[1]) => Promise<MarketSnapshot<{
+        hook: `0x${string}`;
+        owner: `0x${string}`;
+        operator: `0x${string}`;
+        rangeId: bigint;
+        approved: boolean;
+    }>>;
+    getShareAuthorization: (params: Parameters<typeof getMarketShareAuthorization>[1]) => Promise<MarketSnapshot<MarketShareAuthorization>>;
+    getFeeSnapshot: (params: MarketPositionParams) => Promise<MarketSnapshot<MarketFeeLedger>>;
+    estimateClaimableFees: (params: MarketPositionParams) => Promise<{
+        block: MarketBlock;
+        data: MarketClaimableFees;
+    }>;
+}>;
+type MarketClient = ReturnType<typeof createMarketClient>;
+
+/** Validates and copies configuration. Does not claim that the supplied contracts are deployed. */
+declare function defineMarketDeployment(input: MarketDeployment): MarketDeployment;
+
+declare class InvalidMarketConfigError extends Error {
+    readonly field: string;
+    constructor(field: string, message: string);
+}
+declare class MarketDeploymentVerificationError extends Error {
+    readonly field: string;
+    readonly expected: unknown;
+    readonly actual: unknown;
+    constructor(field: string, expected: unknown, actual: unknown);
+}
+declare class MarketReadError extends Error {
+    constructor(cause: unknown);
+}
+declare class MarketFeatureUnavailableError extends Error {
+    readonly feature: string;
+    constructor(feature: string);
+}
+declare class MarketSettlingError extends Error {
+    readonly hook: `0x${string}`;
+    constructor(hook: `0x${string}`);
+}
+declare class MarketTransactionError extends Error {
+    readonly stage: "simulate" | "send" | "receipt";
+    constructor(stage: "simulate" | "send" | "receipt", cause: unknown);
+}
+declare class MarketTransactionReplacedError extends Error {
+    readonly originalHash: `0x${string}`;
+    readonly replacementHash: `0x${string}`;
+    readonly reason: string;
+    constructor(originalHash: `0x${string}`, replacementHash: `0x${string}`, reason: string);
+}
+
+/** Gregorian input domain for the SDK calendar helpers: years 1970..9999. */
+declare function marketDaysInMonth(year: number, month: number): number;
+/** Replaces the whole month's overrides. Empty days clears the month; at most ten distinct dates. */
+declare function packMarketDayOverrides(year: number, month: number, days: readonly MarketDayOverride[]): bigint;
+
+/** Only v4 gross growth wraps. Ramp net accumulators and debts use checked arithmetic. */
+declare function calculateMarketClaimableFees(ledger: MarketFeeLedger): MarketClaimableFees;
+
+/** Keeps caller direction intact: rejects unsorted currencies rather than silently swapping them. */
+declare function defineMarketPoolKey(key: MarketPoolKey): MarketPoolKey;
+declare function getMarketPoolId(input: MarketPoolKey): Hex;
+declare function getMarketRangeId(poolId: Hex, tickLower: number, tickUpper: number, tickSpacing?: number): bigint;
+/** Buy means quote -> base; sell means base -> quote. Labels never depend on token symbols. */
+declare function getMarketSwapDirection(key: MarketPoolKey, base: Address, quote: Address, side: "buy" | "sell"): boolean;
+
+declare function getMarketSqrtPriceAtTick(tick: number): bigint;
+declare function getMarketTickAtSqrtPrice(sqrtPriceX96: bigint): number;
+/** Exact currency1/currency0 human-unit price; no floating point conversion. */
+declare function getMarketPriceRatio(sqrtPriceX96: bigint, decimals0: number, decimals1: number): {
+    numerator: bigint;
+    denominator: bigint;
+};
+/** Principal only. Round up for deposits, down for withdrawals. */
+declare function getMarketAmountsForLiquidity(params: {
+    readonly sqrtPriceX96: bigint;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly liquidity: bigint;
+    readonly rounding: "up" | "down";
+}): {
+    amount0: bigint;
+    amount1: bigint;
+};
+/** Same intermediate floor and uint128 casts as v4 LiquidityAmounts. */
+declare function getMarketLiquidityForAmounts(params: {
+    readonly sqrtPriceX96: bigint;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly amount0: bigint;
+    readonly amount1: bigint;
+}): bigint;
+
+/** Historical discovery data, not a verified deployment or a write-capability grant. */
+interface MarketTestPool {
+    readonly chainId: number;
+    readonly name: string;
+    readonly testAssets: true;
+    readonly permissionlessMint: true;
+    readonly hookKind: MarketHookKind;
+    readonly poolId: Hex;
+    readonly key: Readonly<MarketPoolKey>;
+    readonly base: {
+        readonly symbol: string;
+        readonly address: Address;
+        readonly decimals: number;
+    };
+    readonly quote: {
+        readonly symbol: string;
+        readonly address: Address;
+        readonly decimals: number;
+    };
+    readonly components: {
+        readonly poolManager: Address;
+        readonly registry: Address;
+        readonly reader: Address;
+        readonly accessManager: Address;
+    };
+    readonly source: {
+        readonly commit: string;
+        readonly path: string;
+        readonly blockNumber: number;
+        readonly blockHash: Hex;
+    };
+}
+/** Valueless, openly mintable ERC-20 pools on mainnets; tBNB is not native BNB. */
+declare const marketTestPools: readonly [{
+    readonly chainId: 5042;
+    readonly name: "tBTC/tUSDC";
+    readonly testAssets: true;
+    readonly permissionlessMint: true;
+    readonly hookKind: "ramp";
+    readonly poolId: "0x1a325fe4671d6584778464cbe5ea68b111c2a72718f128a9427717298e85e2cd";
+    readonly key: {
+        readonly currency0: "0x442fc5b4d43fb7ec18ff8ac0a8fb9fdd2efec0db";
+        readonly currency1: "0x44e90eb500868af9b0b16406f3ce165c90e1e85e";
+        readonly fee: 8388608;
+        readonly tickSpacing: 1;
+        readonly hooks: "0x928f4c9b7f80dcbe95b606867e76336a956fa080";
+    };
+    readonly base: {
+        readonly symbol: "tBTC";
+        readonly address: "0x442fc5b4d43fb7ec18ff8ac0a8fb9fdd2efec0db";
+        readonly decimals: 8;
+    };
+    readonly quote: {
+        readonly symbol: "tUSDC";
+        readonly address: "0x44e90eb500868af9b0b16406f3ce165c90e1e85e";
+        readonly decimals: 6;
+    };
+    readonly components: {
+        readonly poolManager: "0x8366a39cc670b4001a1121b8f6a443a643e40951";
+        readonly registry: "0x3386feb5016983790ef05410e888a8b7bf5a722d";
+        readonly reader: "0xbd782f3de07f2c8f27ef3a2cb165f36c5a505e45";
+        readonly accessManager: "0x005710955b542c11fa2259721840329cddf44914";
+    };
+    readonly source: {
+        readonly commit: "cf16bd9376c12ea50de04658b279176d8d56e4f5";
+        readonly path: "docs/test-pools/arc.json";
+        readonly blockNumber: 23523593;
+        readonly blockHash: "0xea3eb1e8cd308955ad999df48212f3b839e3eec7b55cf7702aba213d548f847d";
+    };
+}, {
+    readonly chainId: 56;
+    readonly name: "tBNB/tUSDT";
+    readonly testAssets: true;
+    readonly permissionlessMint: true;
+    readonly hookKind: "ramp";
+    readonly poolId: "0xb1cf54cb728bb02bb40def7d4f088a7274f35ef05b6257cb518d5f10be438bee";
+    readonly key: {
+        readonly currency0: "0x78e708f1f8fe842abaaeaf23ade31e524e153980";
+        readonly currency1: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d";
+        readonly fee: 8388608;
+        readonly tickSpacing: 1;
+        readonly hooks: "0xa6a75d930f7a920391c4afffe744069233c4e080";
+    };
+    readonly base: {
+        readonly symbol: "tBNB";
+        readonly address: "0x78e708f1f8fe842abaaeaf23ade31e524e153980";
+        readonly decimals: 18;
+    };
+    readonly quote: {
+        readonly symbol: "tUSDT";
+        readonly address: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d";
+        readonly decimals: 18;
+    };
+    readonly components: {
+        readonly poolManager: "0x28e2Ea090877bF75740558f6BFB36A5ffeE9e9dF";
+        readonly registry: "0xe75be888ae3d92be2f962f62f78775228eb3cbc9";
+        readonly reader: "0x2fd8d887a67bf61166e5aacae375cda0ad72d292";
+        readonly accessManager: "0x09e9f944a86c5c239eb0dceac85e1f4805d61256";
+    };
+    readonly source: {
+        readonly commit: "cf16bd9376c12ea50de04658b279176d8d56e4f5";
+        readonly path: "docs/test-pools/bsc.json";
+        readonly blockNumber: 124890195;
+        readonly blockHash: "0xba1ae7df7b719fc6d0cf4b49a2278926fc6c62aaf12e2bc49c9788579bba948e";
+    };
+}, {
+    readonly chainId: 56;
+    readonly name: "tQQQ/tUSDT";
+    readonly testAssets: true;
+    readonly permissionlessMint: true;
+    readonly hookKind: "rwa-ramp";
+    readonly poolId: "0x9ccf485776611256dd717db8c53808e370160d8c90668a75c6d456dd07f21423";
+    readonly key: {
+        readonly currency0: "0x51984c455a78c072f9a23453e236bd3729dc3efd";
+        readonly currency1: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d";
+        readonly fee: 8388608;
+        readonly tickSpacing: 1;
+        readonly hooks: "0x7b144d9583c71a1b20cb26954d2ccd330af46080";
+    };
+    readonly base: {
+        readonly symbol: "tQQQ";
+        readonly address: "0x51984c455a78c072f9a23453e236bd3729dc3efd";
+        readonly decimals: 18;
+    };
+    readonly quote: {
+        readonly symbol: "tUSDT";
+        readonly address: "0x8a5218b1b296ced5c88cd55c256fcb58c32f227d";
+        readonly decimals: 18;
+    };
+    readonly components: {
+        readonly poolManager: "0x28e2Ea090877bF75740558f6BFB36A5ffeE9e9dF";
+        readonly registry: "0xe75be888ae3d92be2f962f62f78775228eb3cbc9";
+        readonly reader: "0x2fd8d887a67bf61166e5aacae375cda0ad72d292";
+        readonly accessManager: "0x09e9f944a86c5c239eb0dceac85e1f4805d61256";
+    };
+    readonly source: {
+        readonly commit: "cf16bd9376c12ea50de04658b279176d8d56e4f5";
+        readonly path: "docs/test-pools/bsc.json";
+        readonly blockNumber: 124890195;
+        readonly blockHash: "0xba1ae7df7b719fc6d0cf4b49a2278926fc6c62aaf12e2bc49c9788579bba948e";
+    };
+}];
+
+/** Pins all reads to one block and rejects a reorg before returning a code-and-wiring report. */
+declare function verifyMarketDeployment(publicClient: PublicClient, input: MarketDeployment, options?: {
+    readonly blockNumber?: bigint;
+}): Promise<MarketDeploymentVerification>;
+
+export { InvalidMarketConfigError, type MarketApprovalParams, type MarketBlock, type MarketCapabilityStatus, type MarketChainConfig, type MarketClaimParams, type MarketClaimableFees, type MarketClient, type MarketClientOptions, type MarketContractDeployment, type MarketCurrentFees, type MarketDayOverride, type MarketDeployment, type MarketDeploymentVerification, MarketDeploymentVerificationError, MarketFeatureUnavailableError, type MarketFeeBreakdown, type MarketFeeLedger, type MarketHookCapabilities, type MarketHookDeployment, type MarketHookKind, type MarketLiquidityEvent, type MarketLiquidityParams, type MarketLiquidityPreview, type MarketLiquidityQuote, type MarketListPoolsParams, type MarketManagementAction, type MarketManagementAuthorization, type MarketManagementContext, type MarketManagementEvent, type MarketManagementExecution, type MarketPool, type MarketPoolKey, type MarketPoolPage, type MarketPoolState, type MarketPosition, type MarketPositionParams, type MarketPreparedTransaction, type MarketRange, type MarketRangeParams, type MarketRangeState, type MarketReadContext, MarketReadError, type MarketReadOptions, type MarketRwaFloorConfig, type MarketSession, type MarketSessionState, MarketSettlingError, type MarketShareAuthorization, type MarketShareEvent, type MarketShareRangeParams, type MarketShareTransferParams, type MarketSnapshot, type MarketSpendStatus, type MarketTestPool, type MarketTokenEarnings, MarketTransactionError, MarketTransactionReplacedError, type MarketTransactionRequest, type MarketTransactionResult, type MarketWriteAction, 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 };