@aegis-engine/core 0.7.0 → 0.8.1

package/dist/engine/balancedLending.d.ts

@@ -0,0 +1,82 @@
+import { type Address, type Hex, type PublicClient } from 'viem';
+import type { AegisSwapChainConfig } from '../config/index.js';
+import type { AegisEngineActionCallbacks, AegisEngineApprovalInput, AegisEngineDepositQuoteResult, AegisEngineMarket, AegisEnginePreparedTransaction, AegisEngineReadFrame, AegisEngineTransactionResult, AegisEngineWalletSession } from './types.js';
+export type AegisEngineLendIntent = {
+    mode: 'single-token';
+    inputIsToken0: boolean;
+    amountIn: bigint;
+} | {
+    mode: 'balanced';
+    amount0Max: bigint;
+    amount1Max: bigint;
+};
+export type AegisEngineBalancedDepositInput = {
+    publicClient: PublicClient;
+    market: AegisEngineMarket;
+    owner: Address;
+    amount0Max: bigint;
+    amount1Max: bigint;
+    slippageBps: number;
+    /** Caller-selected native balance reserve; not a gas-cost estimate. */
+    nativeGasReserve: bigint;
+    signal?: AbortSignal;
+    /** Fresh full-call simulation at the canonical head, after authorization. */
+    withExecutionEvidence?: boolean;
+};
+export type AegisEngineBalancedDepositQuote = {
+    kind: 'lend-balanced';
+    owner: Address;
+    market: AegisEngineMarket;
+    slippageBps: number;
+    frame: AegisEngineReadFrame & {
+        blockHash: Hex;
+    };
+    expiresAt: bigint;
+    feasible: boolean;
+    reason: string | null;
+    execution: 'indicative' | 'verified-at-frame' | 'refresh-required' | 'preflight-failed' | 'infeasible';
+    deposit: AegisEngineDepositQuoteResult['deposit'];
+    approvalPlans: readonly {
+        token: Address;
+        amount: bigint;
+        required: boolean;
+    }[];
+    walletRemainder: {
+        amount0: bigint;
+        amount1: bigint;
+    } | null;
+    funding: {
+        balance0: bigint;
+        balance1: bigint;
+        nativeBalance: bigint;
+        nativeGasReserve: bigint;
+    };
+    limitingSide: 'token0' | 'token1' | 'both' | null;
+    nativeValue: bigint;
+    display: AegisEngineDepositQuoteResult['display'];
+    postDeposit: AegisEngineDepositQuoteResult['postDeposit'];
+    tx: AegisEnginePreparedTransaction | null;
+};
+/** Direct two-currency lending. Funding and token metadata are re-read at one
+ * frame. No swap, wrap, signature request or wallet mutation occurs here. */
+export declare function quoteEngineBalancedDeposit(input: AegisEngineBalancedDepositInput): Promise<AegisEngineBalancedDepositQuote>;
+export type AegisEngineBalancedDepositExecutionInput = {
+    quote: AegisEngineBalancedDepositQuote;
+    publicClient: PublicClient;
+    wallet: AegisEngineWalletSession;
+    activeChain: AegisSwapChainConfig;
+    signal?: AbortSignal;
+    onAuthorizationExecution?: AegisEngineApprovalInput['onAuthorizationExecution'];
+    /** Awaited between wallet requests to confirm the host's reviewed scope. */
+    onCheckpoint?: () => Promise<void>;
+} & AegisEngineActionCallbacks;
+/** Authorize exact bounded spends for each token using the existing Engine
+ * executor, then re-quote/simulate before the single deposit. A worse share
+ * floor or larger spend requires a new review. No quoted calldata is reused. */
+export declare function executeEngineBalancedDeposit(input: AegisEngineBalancedDepositExecutionInput): Promise<{
+    status: 'review-required';
+    quote: AegisEngineBalancedDepositQuote;
+} | {
+    status: 'confirmed';
+    result: AegisEngineTransactionResult;
+}>;

package/dist/engine/dataSource.d.ts

@@ -5,6 +5,8 @@ export declare function clearEngineMarketHistoryCache(): void;
 export declare function clearEnginePositionsCache(): void;
 export declare function clearEnginePositionActivityCache(): void;
 export declare function clearEnginePositionsV2ProbeCache(): void;
+export declare function clearEngineMarketsV2ProbeCache(): void;
+export declare function clearEngineMarketHistoryV2ProbeCache(): void;
 export declare function fetchEngineMarkets(args: {
     source: AegisEngineDataSource;
     chainId: number;

package/dist/engine/index.d.ts

@@ -1,13 +1,32 @@
 export * from './types.js';
+export * from './account/types.js';
+export * from './account/client.js';
+export * from './account/activity.js';
+export * from './account/management.js';
+export * from './account/transactions.js';
+export * from './account/transactionHistory.js';
+export * from './account/history.js';
 export * from './activityLotDisplay.js';
 export * from './dataSource.js';
 export * from './lendHistory.js';
 export * from './simpleYield.js';
 export * from './marketAdapter.js';
+export * from './marketTrust.js';
+export { engineMarketIdSchema, engineMarketsRestResponseSchema, engineMarketsV2RestResponseSchema, engineMetricHistoryRestResponseSchema, engineMetricHistoryV2RestResponseSchema, enginePositionActivityRestResponseSchema, enginePositionsRestResponseSchema, enginePositionsV2RestResponseSchema } from './restSchemas.js';
 export * from './registry.js';
+export * from './adaptiveFee.js';
 export * from './reads.js';
 export * from './quotes.js';
 export * from './borrowCollateralFloor.js';
 export * from './actions.js';
+export * from './balancedLending.js';
 export * from './positionAmounts.js';
 export * from './positionStrategy.js';
+export * from './marketSeries.js';
+export { createEngineTradeOpenExecutionSession, engineAuthorizationPlanReviewReasons, engineTradeQuoteReviewReasons } from './tradeExecutionSession.js';
+export type { AegisEngineAuthorizationReviewReason, AegisEngineTradeExecutionCommand, AegisEngineTradeExecutionFailure, AegisEngineTradeExecutionNext, AegisEngineTradeExecutionPhase, AegisEngineTradeExecutionRecovery, AegisEngineTradeExecutionReview, AegisEngineTradeExecutionSnapshot, AegisEngineTradeExecutionStep, AegisEngineTradeExecutionStepStatus, AegisEngineTradeOpenExecutionSession, AegisEngineTradeOpenExecutionSessionOptions, AegisEngineTradeOpenIntent, AegisEngineTradeQuoteReviewReason } from './tradeExecutionSession.js';
+export { engineOpeningExecutionResponseSchema, fetchEngineOpeningEntry } from './openingEntry.js';
+export { AccountingResponseSchema as enginePositionAccountingResponseSchema } from './account/accountingSchemas.js';
+export { PositionPnlResponseSchema as enginePositionPnlResponseSchema } from './account/positionPnlSchemas.js';
+export { PositionPerformanceResponseSchema as enginePositionPerformanceResponseSchema } from './account/positionPerformanceSchemas.js';
+export { PORTFOLIO_CHAINS as ENGINE_PORTFOLIO_CHAIN_IDS } from './account/portfolioSchemas.js';

package/dist/engine/marketAdapter.d.ts

@@ -4,5 +4,8 @@ export declare function normalizeEngineMarkets(args: {
     chainId: number;
     markets: readonly unknown[];
     source?: AegisEngineMarketSource;
+    /** Selects the strict REST row schema. The frozen v1 schema rejects v2-only
+     * adaptive fee fields; v2 validates them as one optional semantic pair. */
+    restResponseVersion?: '1' | '2';
     defaultV4Quoter?: Address;
 }): AegisEngineMarket[];

package/dist/engine/marketSeries.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import type { AegisEngineRestSource } from './types.js';
+import { EngineMarketCandlesResponseSchema, EngineTokenMarketReferenceResponseSchema } from './marketSeriesSchemas.js';
+import { RateHistoryResponseSchema } from './rateHistorySchemas.js';
+export type EnginePoolPriceSegment = {
+    from: number;
+    to: number;
+    price: number;
+};
+export type AegisEnginePoolCandleHistory = z.infer<typeof EngineMarketCandlesResponseSchema> & {
+    priceSegments?: EnginePoolPriceSegment[];
+};
+export type AegisEngineMarketReferenceHistory = z.infer<typeof EngineTokenMarketReferenceResponseSchema>;
+export type AegisEngineRateHistory = z.infer<typeof RateHistoryResponseSchema>;
+export type AegisEngineMarketSeriesInput = {
+    source: AegisEngineRestSource;
+    /** Pass the backend market ID verbatim; its partition key is case-sensitive. */
+    marketId: string;
+    signal?: AbortSignal;
+    /** Bind chart units to the selected market, including token decimals. */
+    expectedAssets?: {
+        baseAsset: {
+            address: string;
+            decimals: number;
+        };
+        quoteAsset: {
+            address: string;
+            decimals: number;
+        };
+    };
+};
+export declare class AegisEngineMarketDataReadError extends Error {
+    readonly code: 'invalid-query' | 'unavailable' | 'invalid-response' | 'response-limit';
+    readonly status: number;
+    readonly retryAfterSeconds: number | null;
+    readonly name = "AegisEngineMarketDataReadError";
+    constructor(code: 'invalid-query' | 'unavailable' | 'invalid-response' | 'response-limit', status?: number, retryAfterSeconds?: number | null);
+}
+export declare const ENGINE_MARKET_SERIES_TTL_MS = 30000;
+/** Clear display history on an explicit host reset; never an execution cache. */
+export declare function clearEngineMarketSeriesCache(): void;
+/** Cached, bounded pool history. A missing feed never becomes another price source. */
+export declare function fetchEngineMarketCandles(input: AegisEngineMarketSeriesInput & {
+    window?: AegisEnginePoolCandleHistory['window'];
+}): Promise<AegisEnginePoolCandleHistory>;
+/** Opt-in display history; older backends may still return the unchanged candle response. */
+export declare function fetchEnginePoolPriceHistory(input: AegisEngineMarketSeriesInput): Promise<AegisEnginePoolCandleHistory>;
+/** Shared covered price holds for charts and exported cards. */
+export declare function enginePoolPriceSegments(history: AegisEnginePoolCandleHistory): readonly EnginePoolPriceSegment[];
+/** Explicit reference history shares reads, but never shares a cache key with pool OHLC. */
+export declare function fetchEngineMarketReferenceHistory(input: AegisEngineMarketSeriesInput & {
+    window?: AegisEngineMarketReferenceHistory['window'];
+}): Promise<AegisEngineMarketReferenceHistory>;
+export declare function fetchEngineRateHistory(input: AegisEngineMarketSeriesInput & {
+    window?: AegisEngineRateHistory['window'];
+}): Promise<AegisEngineRateHistory>;
+/** Keep every valid candle while breaking the plot across explicit data gaps.
+ * Render all segments on coverage.requestedFrom/requestedTo; do not rescale
+ * segments independently or manufacture OHLC for quiet buckets. */
+export declare function splitEngineMarketCandleSegments(history: AegisEnginePoolCandleHistory): AegisEnginePoolCandleHistory['candles'][];
+export { EngineMarketCandlesResponseSchema as engineMarketCandlesResponseSchema } from './marketSeriesSchemas.js';

package/dist/engine/marketSeriesSchemas.d.ts

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+export declare const ENGINE_CANDLE_RESOLUTION_SECONDS: {
+    readonly '5m': 300;
+    readonly '1h': 3600;
+    readonly '1d': 86400;
+};
+export declare const ENGINE_CANDLE_WINDOW_PLANS: {
+    readonly '1d': {
+        readonly resolution: "5m";
+        readonly windowSeconds: 86400;
+        readonly bucketCount: 288;
+    };
+    readonly '7d': {
+        readonly resolution: "1h";
+        readonly windowSeconds: 604800;
+        readonly bucketCount: 168;
+    };
+    readonly '30d': {
+        readonly resolution: "1d";
+        readonly windowSeconds: 2592000;
+        readonly bucketCount: 30;
+    };
+    readonly '90d': {
+        readonly resolution: "1d";
+        readonly windowSeconds: 7776000;
+        readonly bucketCount: 90;
+    };
+    readonly '180d': {
+        readonly resolution: "1d";
+        readonly windowSeconds: 15552000;
+        readonly bucketCount: 180;
+    };
+};
+export declare const EngineCandleQueryParamsSchema: z.ZodObject<{
+    window: z.ZodDefault<z.ZodEnum<{
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        "180d": "180d";
+        "1d": "1d";
+    }>>;
+    basis: z.ZodDefault<z.ZodEnum<{
+        pool: "pool";
+        token_market_reference: "token_market_reference";
+    }>>;
+}, z.core.$strip>;
+export declare const EngineCandleMarketIdSchema: z.ZodString;
+export declare const EngineMarketCandlesResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"2">;
+    chainId: z.ZodNumber;
+    marketId: z.ZodString;
+    poolId: z.ZodString;
+    poolManager: z.ZodString;
+    baseAsset: z.ZodObject<{
+        address: z.ZodString;
+        decimals: z.ZodNumber;
+    }, z.core.$strict>;
+    quoteAsset: z.ZodObject<{
+        address: z.ZodString;
+        decimals: z.ZodNumber;
+    }, z.core.$strict>;
+    orientation: z.ZodLiteral<"quote_per_base">;
+    resolution: z.ZodEnum<{
+        "1d": "1d";
+        "5m": "5m";
+        "1h": "1h";
+    }>;
+    window: z.ZodEnum<{
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        "180d": "180d";
+        "1d": "1d";
+    }>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        no_data: "no_data";
+        partial: "partial";
+    }>;
+    candles: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        aggregation: z.ZodLiteral<"exact_swaps">;
+        swapCount: z.ZodNumber;
+        provenance: z.ZodObject<{
+            firstSwap: z.ZodObject<{
+                blockNumber: z.ZodNumber;
+                blockHash: z.ZodNullable<z.ZodString>;
+                transactionHash: z.ZodString;
+                logIndex: z.ZodNumber;
+            }, z.core.$strict>;
+            lastSwap: z.ZodObject<{
+                blockNumber: z.ZodNumber;
+                blockHash: z.ZodNullable<z.ZodString>;
+                transactionHash: z.ZodString;
+                logIndex: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        t: z.ZodNumber;
+        open: z.ZodNumber;
+        high: z.ZodNumber;
+        low: z.ZodNumber;
+        close: z.ZodNumber;
+        volumeToken0: z.ZodString;
+        volumeToken1: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        aggregation: z.ZodLiteral<"uniswap_pool_aggregate">;
+        txCount: z.ZodNumber;
+        volumeUSD: z.ZodOptional<z.ZodString>;
+        feesUSD: z.ZodOptional<z.ZodString>;
+        tvlUSD: z.ZodOptional<z.ZodString>;
+        t: z.ZodNumber;
+        open: z.ZodNumber;
+        high: z.ZodNumber;
+        low: z.ZodNumber;
+        close: z.ZodNumber;
+        volumeToken0: z.ZodString;
+        volumeToken1: z.ZodString;
+    }, z.core.$strict>], "aggregation">>;
+    candleCount: z.ZodNumber;
+    priceReference: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"pool_state">;
+        price: z.ZodNumber;
+        blockNumber: z.ZodNumber;
+        blockHash: z.ZodString;
+        timestamp: z.ZodNumber;
+        observedAt: z.ZodString;
+    }, z.core.$strict>>>;
+    coverage: z.ZodObject<{
+        requestedFrom: z.ZodNumber;
+        requestedTo: z.ZodNumber;
+        coverageStart: z.ZodNumber;
+        completedThrough: z.ZodNumber;
+        expectedBucketCount: z.ZodNumber;
+        completeBucketCount: z.ZodNumber;
+    }, z.core.$strict>;
+    gaps: z.ZodArray<z.ZodObject<{
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+        reason: z.ZodEnum<{
+            indexing_gap: "indexing_gap";
+            invalid_row: "invalid_row";
+        }>;
+    }, z.core.$strict>>;
+    source: z.ZodEnum<{
+        uniswap_v4_subgraph: "uniswap_v4_subgraph";
+        pool_manager_rpc: "pool_manager_rpc";
+    }>;
+    asOf: z.ZodObject<{
+        blockNumber: z.ZodNullable<z.ZodNumber>;
+        blockHash: z.ZodNullable<z.ZodString>;
+        timestamp: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    freshness: z.ZodObject<{
+        status: z.ZodEnum<{
+            ready: "ready";
+            warming_up: "warming_up";
+            source_unavailable: "source_unavailable";
+            reorg_detected: "reorg_detected";
+        }>;
+        lastProcessedBlockNumber: z.ZodNullable<z.ZodNumber>;
+        lastProcessedBlockHash: z.ZodNullable<z.ZodString>;
+        confirmationDepth: z.ZodNumber;
+        observedAt: z.ZodString;
+        updatedAt: z.ZodString;
+        warnings: z.ZodArray<z.ZodEnum<{
+            "ENGINE-CANDLE-SOURCE-001": "ENGINE-CANDLE-SOURCE-001";
+            "ENGINE-CANDLE-SOURCE-002": "ENGINE-CANDLE-SOURCE-002";
+            "ENGINE-CANDLE-SOURCE-003": "ENGINE-CANDLE-SOURCE-003";
+            "ENGINE-CANDLE-SOURCE-004": "ENGINE-CANDLE-SOURCE-004";
+            "ENGINE-CANDLE-SOURCE-005": "ENGINE-CANDLE-SOURCE-005";
+            "ENGINE-CANDLE-SOURCE-006": "ENGINE-CANDLE-SOURCE-006";
+            "ENGINE-CANDLE-SOURCE-010": "ENGINE-CANDLE-SOURCE-010";
+            "ENGINE-CANDLE-REORG-001": "ENGINE-CANDLE-REORG-001";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const EngineTokenMarketReferenceResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    basis: z.ZodLiteral<"token_market_reference">;
+    format: z.ZodLiteral<"line">;
+    method: z.ZodLiteral<"ratio_of_bucket_closes">;
+    sampleSynchronization: z.ZodLiteral<"bucket_only">;
+    usage: z.ZodLiteral<"display_only">;
+    chainId: z.ZodNumber;
+    marketId: z.ZodString;
+    poolId: z.ZodString;
+    baseAsset: z.ZodObject<{
+        address: z.ZodString;
+        decimals: z.ZodNumber;
+    }, z.core.$strict>;
+    quoteAsset: z.ZodObject<{
+        address: z.ZodString;
+        decimals: z.ZodNumber;
+    }, z.core.$strict>;
+    orientation: z.ZodLiteral<"quote_per_base">;
+    resolution: z.ZodEnum<{
+        "1d": "1d";
+        "1h": "1h";
+    }>;
+    window: z.ZodEnum<{
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        "180d": "180d";
+    }>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        no_data: "no_data";
+        partial: "partial";
+    }>;
+    points: z.ZodArray<z.ZodObject<{
+        t: z.ZodNumber;
+        value: z.ZodNumber;
+        baseCloseUsd: z.ZodString;
+        quoteCloseUsd: z.ZodString;
+        baseSource: z.ZodObject<{
+            blockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            timestamp: z.ZodNumber;
+            observedAt: z.ZodString;
+        }, z.core.$strict>;
+        quoteSource: z.ZodObject<{
+            blockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            timestamp: z.ZodNumber;
+            observedAt: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    pointCount: z.ZodNumber;
+    components: z.ZodTuple<[z.ZodObject<{
+        role: z.ZodEnum<{
+            quote: "quote";
+            base: "base";
+        }>;
+        chainId: z.ZodNumber;
+        address: z.ZodString;
+        decimals: z.ZodNumber;
+        resolution: z.ZodEnum<{
+            "1d": "1d";
+            "1h": "1h";
+        }>;
+        sourceDataset: z.ZodEnum<{
+            TokenHourData: "TokenHourData";
+            TokenDayData: "TokenDayData";
+        }>;
+        status: z.ZodEnum<{
+            ready: "ready";
+            warming_up: "warming_up";
+            source_unavailable: "source_unavailable";
+        }>;
+        independence: z.ZodLiteral<"unknown">;
+        independenceReason: z.ZodLiteral<"historical_price_venue_untracked">;
+        coverageStart: z.ZodNumber;
+        completedThrough: z.ZodNumber;
+        sourceHead: z.ZodNullable<z.ZodObject<{
+            blockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            timestamp: z.ZodNumber;
+            observedAt: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        role: z.ZodEnum<{
+            quote: "quote";
+            base: "base";
+        }>;
+        chainId: z.ZodNumber;
+        address: z.ZodString;
+        decimals: z.ZodNumber;
+        resolution: z.ZodEnum<{
+            "1d": "1d";
+            "1h": "1h";
+        }>;
+        sourceDataset: z.ZodEnum<{
+            TokenHourData: "TokenHourData";
+            TokenDayData: "TokenDayData";
+        }>;
+        status: z.ZodEnum<{
+            ready: "ready";
+            warming_up: "warming_up";
+            source_unavailable: "source_unavailable";
+        }>;
+        independence: z.ZodLiteral<"unknown">;
+        independenceReason: z.ZodLiteral<"historical_price_venue_untracked">;
+        coverageStart: z.ZodNumber;
+        completedThrough: z.ZodNumber;
+        sourceHead: z.ZodNullable<z.ZodObject<{
+            blockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            timestamp: z.ZodNumber;
+            observedAt: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], null>;
+    gaps: z.ZodArray<z.ZodObject<{
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+        reason: z.ZodEnum<{
+            missing_component: "missing_component";
+            invalid_component: "invalid_component";
+            outside_coverage: "outside_coverage";
+        }>;
+    }, z.core.$strict>>;
+    coverage: z.ZodObject<{
+        requestedFrom: z.ZodNumber;
+        requestedTo: z.ZodNumber;
+        expectedBucketCount: z.ZodNumber;
+        observedPairCount: z.ZodNumber;
+    }, z.core.$strict>;
+    source: z.ZodLiteral<"uniswap_v4_subgraph">;
+    attribution: z.ZodObject<{
+        label: z.ZodLiteral<"Uniswap V4 subgraph">;
+        url: z.ZodLiteral<"https://github.com/Uniswap/v4-subgraph">;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/engine/marketTrust.d.ts

@@ -0,0 +1,26 @@
+import type { Hex } from 'viem';
+import { type AegisEngineChainAddresses } from './registry.js';
+import type { AegisEngineMarket } from './types.js';
+type PoolKey = AegisEngineMarket['poolKey'];
+export declare function sameEngineMarketId(left: string, right: string): boolean;
+/**
+ * Checks the market-controlled execution identity without making an RPC call.
+ * Call this before reading allowances, quoting, or opening a wallet request.
+ */
+export declare function assertEngineMarketIdentity(market: AegisEngineMarket): void;
+/** Resolves all signing-adjacent addresses from the SDK-shipped registry. */
+export declare function assertTrustedEngineMarket(market: AegisEngineMarket, options?: {
+    vaultRegistry?: boolean;
+    quoter?: boolean;
+    permit2?: boolean;
+}): AegisEngineChainAddresses;
+/** Rebinds a hydrated SDK frame to the exact reviewed REST market. */
+export declare function assertHydratedEngineMarket(args: {
+    market: AegisEngineMarket;
+    chainId: number;
+    poolId: Hex;
+    poolKey: PoolKey;
+    decimals0?: number;
+    decimals1?: number;
+}): void;
+export {};

package/dist/engine/openingEntry.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import type { AegisEnginePosition, AegisEngineRestSource, AegisEngineTradePositionStrategy } from './types.js';
+export declare const engineOpeningExecutionResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    chainId: z.ZodNumber;
+    txHash: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    account: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    status: z.ZodLiteral<"reconciled">;
+    execution: z.ZodObject<{
+        basis: z.ZodLiteral<"receipt-reconciled-opening-swap-leg">;
+        poolId: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        vaultId: z.ZodString;
+        owner: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        key: z.ZodObject<{
+            currency0: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            currency1: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        }, z.core.$strip>;
+        block: z.ZodObject<{
+            canonicality: z.ZodLiteral<"rpc-checked-at-read">;
+        }, z.core.$strip>;
+        swap: z.ZodObject<{
+            inputCurrency: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            outputCurrency: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            inputRaw: z.ZodString;
+            outputRaw: z.ZodString;
+            inputBasis: z.ZodLiteral<"pool-input-plus-hook-input-fee">;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    chainId: z.ZodNumber;
+    txHash: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    account: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    status: z.ZodLiteral<"unavailable">;
+}, z.core.$loose>]>;
+export declare function fetchEngineOpeningEntry({ source, position, strategy, signal }: {
+    source: AegisEngineRestSource;
+    position: Pick<AegisEnginePosition, 'chainId' | 'account' | 'poolId' | 'vaultId' | 'token0' | 'token1'>;
+    strategy: Pick<AegisEngineTradePositionStrategy, 'openTxHash' | 'poolId'>;
+    signal?: AbortSignal;
+}): Promise<number | null>;

package/dist/engine/rateHistorySchemas.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const RateHistoryPointSchema: z.ZodObject<{
+    t: z.ZodNumber;
+    observedAt: z.ZodString;
+    evmBlockNumber: z.ZodNumber;
+    borrowAprPct: z.ZodNullable<z.ZodNumber>;
+    lendAprPct: z.ZodNullable<z.ZodNumber>;
+    lendingRateBasis: z.ZodLiteral<"simple-borrow-interest-apr">;
+    utilizationPct: z.ZodNullable<z.ZodNumber>;
+    ratePerSecondWad: z.ZodNullable<z.ZodString>;
+    fullUtilizationRate: z.ZodNullable<z.ZodString>;
+    sharePriceWad: z.ZodNullable<z.ZodString>;
+    rateObservation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"verified">;
+        basis: z.ZodLiteral<"irm-accrual-preview">;
+        rpcBlockNumber: z.ZodNumber;
+        blockHash: z.ZodString;
+        observedAt: z.ZodString;
+        elapsedSeconds: z.ZodString;
+        canonicality: z.ZodLiteral<"rpc-checked-at-read">;
+        finality: z.ZodLiteral<"not-a-finality-verdict">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            "legacy-unpinned": "legacy-unpinned";
+            "invalid-provenance": "invalid-provenance";
+        }>;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>;
+export declare const RateHistoryResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    marketId: z.ZodString;
+    resolution: z.ZodLiteral<"12h">;
+    window: z.ZodEnum<{
+        "7d": "7d";
+        "30d": "30d";
+        "60d": "60d";
+    }>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        warming_up: "warming_up";
+        no_data: "no_data";
+        partial: "partial";
+    }>;
+    pointCount: z.ZodNumber;
+    points: z.ZodArray<z.ZodObject<{
+        t: z.ZodNumber;
+        observedAt: z.ZodString;
+        evmBlockNumber: z.ZodNumber;
+        borrowAprPct: z.ZodNullable<z.ZodNumber>;
+        lendAprPct: z.ZodNullable<z.ZodNumber>;
+        lendingRateBasis: z.ZodLiteral<"simple-borrow-interest-apr">;
+        utilizationPct: z.ZodNullable<z.ZodNumber>;
+        ratePerSecondWad: z.ZodNullable<z.ZodString>;
+        fullUtilizationRate: z.ZodNullable<z.ZodString>;
+        sharePriceWad: z.ZodNullable<z.ZodString>;
+        rateObservation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"verified">;
+            basis: z.ZodLiteral<"irm-accrual-preview">;
+            rpcBlockNumber: z.ZodNumber;
+            blockHash: z.ZodString;
+            observedAt: z.ZodString;
+            elapsedSeconds: z.ZodString;
+            canonicality: z.ZodLiteral<"rpc-checked-at-read">;
+            finality: z.ZodLiteral<"not-a-finality-verdict">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                "legacy-unpinned": "legacy-unpinned";
+                "invalid-provenance": "invalid-provenance";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+    coverage: z.ZodObject<{
+        fromBucket: z.ZodNumber;
+        throughClosedBucket: z.ZodNumber;
+        expectedClosedBuckets: z.ZodNumber;
+        firstObservedBucket: z.ZodNullable<z.ZodNumber>;
+        leadingMissingBucketCount: z.ZodNumber;
+        presentClosedBuckets: z.ZodNumber;
+        missingBuckets: z.ZodArray<z.ZodNumber>;
+        missingRateBuckets: z.ZodArray<z.ZodNumber>;
+        verifiedRatePoints: z.ZodNumber;
+        legacyRatePoints: z.ZodNumber;
+        invalidRows: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/engine/reads.d.ts

@@ -1,4 +1,4 @@
-import type { Address } from 'viem';
+import { type Address } from 'viem';
 import { UserFacingError } from '../errors.js';
 import type { AegisEngineBorrowQuoteContext, AegisEngineMarket, AegisEngineMarketMark, AegisEngineMarketReadInput, AegisEngineMarketSnapshot, AegisEnginePositionsHydration, AegisEnginePositionsHydrationInput, AegisEngineVaultActivityEntry } from './types.js';
 export declare class AegisEngineMarketNotReadyError extends UserFacingError {