@mento-protocol/config 0.1.0

package/dist/rebalance-abi.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Single source of truth for the FPMM liquidity-strategy ABI subset and
+ * Solidity-error → human-readable message map used by the rebalance probe.
+ *
+ * Two consumers today:
+ *   - `ui-dashboard/src/lib/rebalance-check.ts` (pool-detail tooltip + KPI strip)
+ *   - `metrics-bridge/src/rebalance-check.ts` (Slack alert annotation)
+ *
+ * Drift between the two would mean the dashboard explains a revert that the
+ * Slack alert reports as `unknown` (or vice versa). Keeping the data here
+ * forces both probes to see exactly the same vocabulary.
+ *
+ * Implementation notes:
+ *   - `STRATEGY_ABI_SOURCES` is a plain string[] of human-readable ABI fragments.
+ *     Consumers feed it into viem's `parseAbi(...)` to materialise the typed
+ *     ABI — that keeps the viem dependency out of `shared-config/`. The
+ *     `as const` annotation preserves literal types so `parseAbi` can produce
+ *     a strongly-typed ABI on the consumer side.
+ *   - `ERROR_MESSAGES` is a flat lookup map. The `decodeBlockedRevert` glue
+ *     stays in each consumer because it carries probe-specific concerns
+ *     (the dashboard adds enrichment fetches for `CDPLS_*_BALANCE_TOO_LOW` /
+ *     `RLS_RESERVE_OUT_OF_COLLATERAL`; the bridge collapses healthy no-ops
+ *     to `ok` and routes the unbounded payload to the diagnostic log channel
+ *     for cardinality + Slack-injection-safety reasons).
+ */
+/**
+ * Strategy ABI as a const-string array — feed this into viem's `parseAbi(...)`
+ * on the consumer side. The list covers every error code emitted by the
+ * FPMM rebalance pipeline plus the detection-only getters
+ * (`getCDPConfig`/`reserve`/`getPools`) needed to identify the strategy
+ * type before simulating.
+ *
+ * Drift across the two consumers (dashboard tooltip + Slack alert annotation)
+ * would mean a revert decoded by one probe falls through to `unknown` on
+ * the other. Add new errors / detection getters here, never inline.
+ */
+export declare const STRATEGY_ABI_SOURCES: readonly ["function rebalance(address pool) external", "function determineAction(address pool) external view returns ((address pool, uint256 reserveNumerator, uint256 reserveDenominator, uint256 oraclePriceNumerator, uint256 oraclePriceDenominator, bool reservePriceAboveOraclePrice, uint16 rebalanceThreshold, address token0, address token1, uint8 decimals0, uint8 decimals1, bool isToken0Debt, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction) ctx, (uint8 direction, uint256 amount0Out, uint256 amount1Out, uint256 amountOwedToPool) action)", "function poolConfigs(address pool) external view returns (bool isToken0Debt, uint32 lastRebalance, uint32 rebalanceCooldown, address protocolFeeRecipient, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction)", "function getCDPConfig(address pool) external view returns ((address stabilityPool, address collateralRegistry, uint256 stabilityPoolPercentage, uint256 maxIterations))", "function reserve() external view returns (address)", "function getPools() external view returns (address[])", "error LS_BAD_INCENTIVE()", "error LS_CAN_ONLY_REBALANCE_ONCE(address pool)", "error LS_COOLDOWN_ACTIVE()", "error LS_DEBT_TOKEN_NOT_IN_POOL()", "error LS_HOOK_NOT_CALLED()", "error LS_INCENTIVE_TOO_HIGH()", "error LS_INVALID_DECIMAL()", "error LS_INVALID_OWNER()", "error LS_INVALID_PRICES()", "error LS_INVALID_SENDER()", "error LS_INVALID_THRESHOLD()", "error LS_POOL_ALREADY_EXISTS()", "error LS_POOL_MUST_BE_SET()", "error LS_POOL_NOT_FOUND()", "error LS_POOL_NOT_REBALANCEABLE()", "error LS_PROTOCOL_FEE_RECIPIENT_REQUIRED()", "error LS_STRATEGY_EXECUTION_FAILED()", "error LS_ZERO_DECIMAL()", "error CDPLS_COLLATERAL_REGISTRY_IS_ZERO()", "error CDPLS_INVALID_STABILITY_POOL_PERCENTAGE()", "error CDPLS_OUT_OF_FUNDS_FOR_REDEMPTION_SUBSIDY()", "error CDPLS_REDEMPTION_FEE_TOO_LARGE()", "error CDPLS_REDEMPTION_SHORTFALL_TOO_LARGE(uint256 shortfall)", "error CDPLS_STABILITY_POOL_BALANCE_TOO_LOW()", "error CDPLS_STABILITY_POOL_IS_ZERO()", "error RLS_COLLATERAL_TO_POOL_FAILED()", "error RLS_INVALID_RESERVE()", "error RLS_RESERVE_OUT_OF_COLLATERAL()", "error RLS_TOKEN_IN_NOT_SUPPORTED()", "error RLS_TOKEN_OUT_NOT_SUPPORTED()", "error OLS_OUT_OF_COLLATERAL()", "error OLS_OUT_OF_DEBT()", "error NotLiquidityStrategy()", "error PriceDifferenceTooSmall()", "error PriceDifferenceNotImproved()", "error PriceDifferenceMovedInWrongDirection()", "error PriceDifferenceMovedTooFarFromThresholds()", "error RebalanceDirectionInvalid()", "error RebalanceThresholdTooHigh()", "error RebalanceIncentiveTooHigh()", "error ReferenceRateNotSet()", "error ReserveValueDecreased()", "error ReservesEmpty()"];
+/**
+ * Solidity error name → human-readable explanation. Slack alert annotations
+ * and dashboard tooltips share the same vocabulary so operators see the
+ * same wording across surfaces.
+ *
+ * Bounded enum (~30 codes). Both consumers' `decodeBlockedRevert` glue
+ * MUST keep `reason_message` inside this map (built-in `Error(string)` /
+ * `Panic(uint256)` reverts collapse to fixed strings — see
+ * `metrics-bridge/src/rebalance-check.ts`) so the Prometheus label
+ * cardinality stays bounded and a non-canonical strategy can't inject
+ * Slack mrkdwn through the alert body.
+ *
+ * INVARIANT — entries MUST be bare phrases (no trailing punctuation): the
+ * Slack alert template at `alerts/rules/main.tf` appends a "." when
+ * rendering ("Rebalance Blocked: <reason_message>."). Trailing "." / "!" /
+ * "—" here would render as double punctuation. The dashboard tooltip
+ * (`ui-dashboard/src/components/pool-header/rebalance-status-value.tsx`)
+ * concatenates with " — " so it's also happiest with bare phrases.
+ */
+export declare const ERROR_MESSAGES: {
+    readonly CDPLS_STABILITY_POOL_BALANCE_TOO_LOW: "Stability pool has insufficient liquidity";
+    readonly CDPLS_STABILITY_POOL_IS_ZERO: "No stability pool configured for this strategy";
+    readonly CDPLS_COLLATERAL_REGISTRY_IS_ZERO: "Collateral registry not configured";
+    readonly CDPLS_OUT_OF_FUNDS_FOR_REDEMPTION_SUBSIDY: "Insufficient funds to cover redemption subsidy";
+    readonly CDPLS_REDEMPTION_FEE_TOO_LARGE: "Redemption fee exceeds tolerance";
+    readonly CDPLS_REDEMPTION_SHORTFALL_TOO_LARGE: "Redemption shortfall exceeds tolerance";
+    readonly CDPLS_INVALID_STABILITY_POOL_PERCENTAGE: "Invalid stability pool percentage configuration";
+    readonly RLS_RESERVE_OUT_OF_COLLATERAL: "Reserve has insufficient collateral";
+    readonly RLS_INVALID_RESERVE: "Reserve contract not configured";
+    readonly RLS_COLLATERAL_TO_POOL_FAILED: "Collateral transfer to pool failed";
+    readonly RLS_TOKEN_IN_NOT_SUPPORTED: "Collateral token not supported by reserve";
+    readonly RLS_TOKEN_OUT_NOT_SUPPORTED: "Debt token not supported by reserve";
+    readonly OLS_OUT_OF_COLLATERAL: "Strategy has no collateral liquidity available";
+    readonly OLS_OUT_OF_DEBT: "Strategy has no debt liquidity available";
+    readonly LS_COOLDOWN_ACTIVE: "Rebalance cooldown is active — retry shortly";
+    readonly LS_POOL_NOT_REBALANCEABLE: "Pool deviation is below the rebalance threshold";
+    readonly LS_INVALID_PRICES: "Oracle price data is invalid or stale";
+    readonly LS_CAN_ONLY_REBALANCE_ONCE: "Pool was already rebalanced this block";
+    readonly LS_POOL_NOT_FOUND: "Pool is not registered with this strategy";
+    readonly LS_STRATEGY_EXECUTION_FAILED: "Strategy execution failed internally";
+    readonly LS_HOOK_NOT_CALLED: "Pool hook was not invoked — possible contract misconfiguration";
+    readonly LS_BAD_INCENTIVE: "Incentive configuration is invalid";
+    readonly LS_INCENTIVE_TOO_HIGH: "Rebalance incentive exceeds allowed maximum";
+    readonly LS_DEBT_TOKEN_NOT_IN_POOL: "Debt token not found in pool pair";
+    readonly LS_INVALID_DECIMAL: "Token decimal configuration is invalid";
+    readonly LS_INVALID_OWNER: "Unauthorized — only owner can call this";
+    readonly LS_INVALID_SENDER: "Unauthorized caller";
+    readonly LS_INVALID_THRESHOLD: "Rebalance threshold is out of valid range";
+    readonly LS_POOL_ALREADY_EXISTS: "Pool is already registered";
+    readonly LS_POOL_MUST_BE_SET: "Pool address cannot be zero";
+    readonly LS_PROTOCOL_FEE_RECIPIENT_REQUIRED: "Protocol fee recipient must be set";
+    readonly LS_ZERO_DECIMAL: "Token has zero decimals";
+    readonly NotLiquidityStrategy: "Caller is not a registered liquidity strategy";
+    readonly PriceDifferenceTooSmall: "Pool deviation is below the rebalance threshold";
+    readonly PriceDifferenceNotImproved: "Rebalance did not improve the price deviation";
+    readonly PriceDifferenceMovedInWrongDirection: "Rebalance moved the price in the wrong direction";
+    readonly PriceDifferenceMovedTooFarFromThresholds: "Rebalance moved the price too far past the threshold";
+    readonly RebalanceDirectionInvalid: "Invalid rebalance direction";
+    readonly RebalanceThresholdTooHigh: "Rebalance threshold exceeds allowed maximum";
+    readonly RebalanceIncentiveTooHigh: "Rebalance incentive exceeds allowed maximum";
+    readonly ReferenceRateNotSet: "Oracle reference rate is not configured";
+    readonly ReserveValueDecreased: "Pool reserve value decreased after rebalance";
+    readonly ReservesEmpty: "Pool reserves are empty";
+};
+/**
+ * Canonical Solidity-error names — the keys of `ERROR_MESSAGES` exposed as a
+ * string-literal union. Use `ReasonCode` whenever you compare against a code
+ * (e.g. `code === REASON_CODES.RLS_RESERVE_OUT_OF_COLLATERAL`); a typo on a
+ * string literal silently disables the comparison, which would in turn skip
+ * enrichment fetches and ship a degraded alert annotation. The `as const`
+ * map + `satisfies` annotation force compile-time validation.
+ */
+export type ReasonCode = keyof typeof ERROR_MESSAGES;
+/**
+ * Built-in Solidity revert kinds — `Error(string)` and `Panic(uint256)` —
+ * plus a catch-all `unknown` for unrecognised payloads. Both consumers
+ * (`metrics-bridge` probe + `ui-dashboard` probe) collapse these to a fixed
+ * `reasonMessage` to keep the Prometheus label space bounded and the Slack
+ * alert body free of strategy-supplied mrkdwn.
+ *
+ * `SyntheticReasonCode | ReasonCode` is the full set of values that can land
+ * on a `RebalanceProbeBlocked.reasonCode` — the discriminated union the
+ * dashboard tooltip + Slack annotation render against.
+ */
+export type SyntheticReasonCode = "Error" | "Panic" | "unknown";
+/**
+ * Const-object mirror of `ReasonCode` so consumers can write
+ * `REASON_CODES.RLS_RESERVE_OUT_OF_COLLATERAL` instead of a bare string
+ * literal. Catches typos at the call site (the bare-string form would
+ * silently disable enrichment if mistyped).
+ */
+export declare const REASON_CODES: Readonly<{
+    CDPLS_STABILITY_POOL_BALANCE_TOO_LOW: "CDPLS_STABILITY_POOL_BALANCE_TOO_LOW";
+    CDPLS_STABILITY_POOL_IS_ZERO: "CDPLS_STABILITY_POOL_IS_ZERO";
+    CDPLS_COLLATERAL_REGISTRY_IS_ZERO: "CDPLS_COLLATERAL_REGISTRY_IS_ZERO";
+    CDPLS_OUT_OF_FUNDS_FOR_REDEMPTION_SUBSIDY: "CDPLS_OUT_OF_FUNDS_FOR_REDEMPTION_SUBSIDY";
+    CDPLS_REDEMPTION_FEE_TOO_LARGE: "CDPLS_REDEMPTION_FEE_TOO_LARGE";
+    CDPLS_REDEMPTION_SHORTFALL_TOO_LARGE: "CDPLS_REDEMPTION_SHORTFALL_TOO_LARGE";
+    CDPLS_INVALID_STABILITY_POOL_PERCENTAGE: "CDPLS_INVALID_STABILITY_POOL_PERCENTAGE";
+    RLS_RESERVE_OUT_OF_COLLATERAL: "RLS_RESERVE_OUT_OF_COLLATERAL";
+    RLS_INVALID_RESERVE: "RLS_INVALID_RESERVE";
+    RLS_COLLATERAL_TO_POOL_FAILED: "RLS_COLLATERAL_TO_POOL_FAILED";
+    RLS_TOKEN_IN_NOT_SUPPORTED: "RLS_TOKEN_IN_NOT_SUPPORTED";
+    RLS_TOKEN_OUT_NOT_SUPPORTED: "RLS_TOKEN_OUT_NOT_SUPPORTED";
+    OLS_OUT_OF_COLLATERAL: "OLS_OUT_OF_COLLATERAL";
+    OLS_OUT_OF_DEBT: "OLS_OUT_OF_DEBT";
+    LS_COOLDOWN_ACTIVE: "LS_COOLDOWN_ACTIVE";
+    LS_POOL_NOT_REBALANCEABLE: "LS_POOL_NOT_REBALANCEABLE";
+    LS_INVALID_PRICES: "LS_INVALID_PRICES";
+    LS_CAN_ONLY_REBALANCE_ONCE: "LS_CAN_ONLY_REBALANCE_ONCE";
+    LS_POOL_NOT_FOUND: "LS_POOL_NOT_FOUND";
+    LS_STRATEGY_EXECUTION_FAILED: "LS_STRATEGY_EXECUTION_FAILED";
+    LS_HOOK_NOT_CALLED: "LS_HOOK_NOT_CALLED";
+    LS_BAD_INCENTIVE: "LS_BAD_INCENTIVE";
+    LS_INCENTIVE_TOO_HIGH: "LS_INCENTIVE_TOO_HIGH";
+    LS_DEBT_TOKEN_NOT_IN_POOL: "LS_DEBT_TOKEN_NOT_IN_POOL";
+    LS_INVALID_DECIMAL: "LS_INVALID_DECIMAL";
+    LS_INVALID_OWNER: "LS_INVALID_OWNER";
+    LS_INVALID_SENDER: "LS_INVALID_SENDER";
+    LS_INVALID_THRESHOLD: "LS_INVALID_THRESHOLD";
+    LS_POOL_ALREADY_EXISTS: "LS_POOL_ALREADY_EXISTS";
+    LS_POOL_MUST_BE_SET: "LS_POOL_MUST_BE_SET";
+    LS_PROTOCOL_FEE_RECIPIENT_REQUIRED: "LS_PROTOCOL_FEE_RECIPIENT_REQUIRED";
+    LS_ZERO_DECIMAL: "LS_ZERO_DECIMAL";
+    NotLiquidityStrategy: "NotLiquidityStrategy";
+    PriceDifferenceTooSmall: "PriceDifferenceTooSmall";
+    PriceDifferenceNotImproved: "PriceDifferenceNotImproved";
+    PriceDifferenceMovedInWrongDirection: "PriceDifferenceMovedInWrongDirection";
+    PriceDifferenceMovedTooFarFromThresholds: "PriceDifferenceMovedTooFarFromThresholds";
+    RebalanceDirectionInvalid: "RebalanceDirectionInvalid";
+    RebalanceThresholdTooHigh: "RebalanceThresholdTooHigh";
+    RebalanceIncentiveTooHigh: "RebalanceIncentiveTooHigh";
+    ReferenceRateNotSet: "ReferenceRateNotSet";
+    ReserveValueDecreased: "ReserveValueDecreased";
+    ReservesEmpty: "ReservesEmpty";
+}>;
+/**
+ * Revert codes where the strategy refuses to rebalance BECAUSE the pool is
+ * healthy — not because anything is wrong. Both consumers collapse these
+ * to a passive "no action needed" state so no red "blocked" line appears
+ * in the UI / alert annotation when the rebalancer is just waiting for
+ * the pool to drift further past threshold.
+ */
+export declare const HEALTHY_NO_OP_ERRORS: ReadonlySet<string>;
+//# sourceMappingURL=rebalance-abi.d.ts.map

package/dist/rebalance-abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalance-abi.d.ts","sourceRoot":"","sources":["../src/rebalance-abi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,myFAgEvB,CAAC;AAEX;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDgB,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,cAAc,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIxB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAGnD,CAAC"}

package/dist/rebalance-abi.js

@@ -0,0 +1,188 @@
+/**
+ * Single source of truth for the FPMM liquidity-strategy ABI subset and
+ * Solidity-error → human-readable message map used by the rebalance probe.
+ *
+ * Two consumers today:
+ *   - `ui-dashboard/src/lib/rebalance-check.ts` (pool-detail tooltip + KPI strip)
+ *   - `metrics-bridge/src/rebalance-check.ts` (Slack alert annotation)
+ *
+ * Drift between the two would mean the dashboard explains a revert that the
+ * Slack alert reports as `unknown` (or vice versa). Keeping the data here
+ * forces both probes to see exactly the same vocabulary.
+ *
+ * Implementation notes:
+ *   - `STRATEGY_ABI_SOURCES` is a plain string[] of human-readable ABI fragments.
+ *     Consumers feed it into viem's `parseAbi(...)` to materialise the typed
+ *     ABI — that keeps the viem dependency out of `shared-config/`. The
+ *     `as const` annotation preserves literal types so `parseAbi` can produce
+ *     a strongly-typed ABI on the consumer side.
+ *   - `ERROR_MESSAGES` is a flat lookup map. The `decodeBlockedRevert` glue
+ *     stays in each consumer because it carries probe-specific concerns
+ *     (the dashboard adds enrichment fetches for `CDPLS_*_BALANCE_TOO_LOW` /
+ *     `RLS_RESERVE_OUT_OF_COLLATERAL`; the bridge collapses healthy no-ops
+ *     to `ok` and routes the unbounded payload to the diagnostic log channel
+ *     for cardinality + Slack-injection-safety reasons).
+ */
+/**
+ * Strategy ABI as a const-string array — feed this into viem's `parseAbi(...)`
+ * on the consumer side. The list covers every error code emitted by the
+ * FPMM rebalance pipeline plus the detection-only getters
+ * (`getCDPConfig`/`reserve`/`getPools`) needed to identify the strategy
+ * type before simulating.
+ *
+ * Drift across the two consumers (dashboard tooltip + Slack alert annotation)
+ * would mean a revert decoded by one probe falls through to `unknown` on
+ * the other. Add new errors / detection getters here, never inline.
+ */
+export const STRATEGY_ABI_SOURCES = [
+    // Shared
+    "function rebalance(address pool) external",
+    // OLS-specific probe: view-only, handles the zero-sender path explicitly.
+    // CDP/Reserve `rebalance` simulates fine from address(0) (tokens move
+    // strategy → pool), but OLS routes ERC20 transfers from `msg.sender`,
+    // so the address(0) probe always reverts inside ERC20 — meaningless.
+    "function determineAction(address pool) external view returns ((address pool, uint256 reserveNumerator, uint256 reserveDenominator, uint256 oraclePriceNumerator, uint256 oraclePriceDenominator, bool reservePriceAboveOraclePrice, uint16 rebalanceThreshold, address token0, address token1, uint8 decimals0, uint8 decimals1, bool isToken0Debt, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction) ctx, (uint8 direction, uint256 amount0Out, uint256 amount1Out, uint256 amountOwedToPool) action)",
+    // Used by the dashboard's reserve-enrichment path (find the debt token).
+    // Bridge ignores it — dropping enrichment keeps the alert annotation
+    // bounded — but keeping it in the canonical ABI is harmless.
+    "function poolConfigs(address pool) external view returns (bool isToken0Debt, uint32 lastRebalance, uint32 rebalanceCooldown, address protocolFeeRecipient, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction)",
+    // Strategy-type detection probes (zero-arg getters, cheap).
+    "function getCDPConfig(address pool) external view returns ((address stabilityPool, address collateralRegistry, uint256 stabilityPoolPercentage, uint256 maxIterations))",
+    "function reserve() external view returns (address)",
+    "function getPools() external view returns (address[])",
+    // Shared LS_*
+    "error LS_BAD_INCENTIVE()",
+    "error LS_CAN_ONLY_REBALANCE_ONCE(address pool)",
+    "error LS_COOLDOWN_ACTIVE()",
+    "error LS_DEBT_TOKEN_NOT_IN_POOL()",
+    "error LS_HOOK_NOT_CALLED()",
+    "error LS_INCENTIVE_TOO_HIGH()",
+    "error LS_INVALID_DECIMAL()",
+    "error LS_INVALID_OWNER()",
+    "error LS_INVALID_PRICES()",
+    "error LS_INVALID_SENDER()",
+    "error LS_INVALID_THRESHOLD()",
+    "error LS_POOL_ALREADY_EXISTS()",
+    "error LS_POOL_MUST_BE_SET()",
+    "error LS_POOL_NOT_FOUND()",
+    "error LS_POOL_NOT_REBALANCEABLE()",
+    "error LS_PROTOCOL_FEE_RECIPIENT_REQUIRED()",
+    "error LS_STRATEGY_EXECUTION_FAILED()",
+    "error LS_ZERO_DECIMAL()",
+    // CDP strategy
+    "error CDPLS_COLLATERAL_REGISTRY_IS_ZERO()",
+    "error CDPLS_INVALID_STABILITY_POOL_PERCENTAGE()",
+    "error CDPLS_OUT_OF_FUNDS_FOR_REDEMPTION_SUBSIDY()",
+    "error CDPLS_REDEMPTION_FEE_TOO_LARGE()",
+    "error CDPLS_REDEMPTION_SHORTFALL_TOO_LARGE(uint256 shortfall)",
+    "error CDPLS_STABILITY_POOL_BALANCE_TOO_LOW()",
+    "error CDPLS_STABILITY_POOL_IS_ZERO()",
+    // Reserve strategy
+    "error RLS_COLLATERAL_TO_POOL_FAILED()",
+    "error RLS_INVALID_RESERVE()",
+    "error RLS_RESERVE_OUT_OF_COLLATERAL()",
+    "error RLS_TOKEN_IN_NOT_SUPPORTED()",
+    "error RLS_TOKEN_OUT_NOT_SUPPORTED()",
+    // OLS strategy
+    "error OLS_OUT_OF_COLLATERAL()",
+    "error OLS_OUT_OF_DEBT()",
+    // FPMM pool-side errors (can bubble through strategy.rebalance → pool.rebalance)
+    "error NotLiquidityStrategy()",
+    "error PriceDifferenceTooSmall()",
+    "error PriceDifferenceNotImproved()",
+    "error PriceDifferenceMovedInWrongDirection()",
+    "error PriceDifferenceMovedTooFarFromThresholds()",
+    "error RebalanceDirectionInvalid()",
+    "error RebalanceThresholdTooHigh()",
+    "error RebalanceIncentiveTooHigh()",
+    "error ReferenceRateNotSet()",
+    "error ReserveValueDecreased()",
+    "error ReservesEmpty()",
+];
+/**
+ * Solidity error name → human-readable explanation. Slack alert annotations
+ * and dashboard tooltips share the same vocabulary so operators see the
+ * same wording across surfaces.
+ *
+ * Bounded enum (~30 codes). Both consumers' `decodeBlockedRevert` glue
+ * MUST keep `reason_message` inside this map (built-in `Error(string)` /
+ * `Panic(uint256)` reverts collapse to fixed strings — see
+ * `metrics-bridge/src/rebalance-check.ts`) so the Prometheus label
+ * cardinality stays bounded and a non-canonical strategy can't inject
+ * Slack mrkdwn through the alert body.
+ *
+ * INVARIANT — entries MUST be bare phrases (no trailing punctuation): the
+ * Slack alert template at `alerts/rules/main.tf` appends a "." when
+ * rendering ("Rebalance Blocked: <reason_message>."). Trailing "." / "!" /
+ * "—" here would render as double punctuation. The dashboard tooltip
+ * (`ui-dashboard/src/components/pool-header/rebalance-status-value.tsx`)
+ * concatenates with " — " so it's also happiest with bare phrases.
+ */
+export const ERROR_MESSAGES = {
+    // CDP strategy
+    CDPLS_STABILITY_POOL_BALANCE_TOO_LOW: "Stability pool has insufficient liquidity",
+    CDPLS_STABILITY_POOL_IS_ZERO: "No stability pool configured for this strategy",
+    CDPLS_COLLATERAL_REGISTRY_IS_ZERO: "Collateral registry not configured",
+    CDPLS_OUT_OF_FUNDS_FOR_REDEMPTION_SUBSIDY: "Insufficient funds to cover redemption subsidy",
+    CDPLS_REDEMPTION_FEE_TOO_LARGE: "Redemption fee exceeds tolerance",
+    CDPLS_REDEMPTION_SHORTFALL_TOO_LARGE: "Redemption shortfall exceeds tolerance",
+    CDPLS_INVALID_STABILITY_POOL_PERCENTAGE: "Invalid stability pool percentage configuration",
+    // Reserve strategy
+    RLS_RESERVE_OUT_OF_COLLATERAL: "Reserve has insufficient collateral",
+    RLS_INVALID_RESERVE: "Reserve contract not configured",
+    RLS_COLLATERAL_TO_POOL_FAILED: "Collateral transfer to pool failed",
+    RLS_TOKEN_IN_NOT_SUPPORTED: "Collateral token not supported by reserve",
+    RLS_TOKEN_OUT_NOT_SUPPORTED: "Debt token not supported by reserve",
+    // Open liquidity strategy
+    OLS_OUT_OF_COLLATERAL: "Strategy has no collateral liquidity available",
+    OLS_OUT_OF_DEBT: "Strategy has no debt liquidity available",
+    // Shared
+    LS_COOLDOWN_ACTIVE: "Rebalance cooldown is active — retry shortly",
+    LS_POOL_NOT_REBALANCEABLE: "Pool deviation is below the rebalance threshold",
+    LS_INVALID_PRICES: "Oracle price data is invalid or stale",
+    LS_CAN_ONLY_REBALANCE_ONCE: "Pool was already rebalanced this block",
+    LS_POOL_NOT_FOUND: "Pool is not registered with this strategy",
+    LS_STRATEGY_EXECUTION_FAILED: "Strategy execution failed internally",
+    LS_HOOK_NOT_CALLED: "Pool hook was not invoked — possible contract misconfiguration",
+    LS_BAD_INCENTIVE: "Incentive configuration is invalid",
+    LS_INCENTIVE_TOO_HIGH: "Rebalance incentive exceeds allowed maximum",
+    LS_DEBT_TOKEN_NOT_IN_POOL: "Debt token not found in pool pair",
+    LS_INVALID_DECIMAL: "Token decimal configuration is invalid",
+    LS_INVALID_OWNER: "Unauthorized — only owner can call this",
+    LS_INVALID_SENDER: "Unauthorized caller",
+    LS_INVALID_THRESHOLD: "Rebalance threshold is out of valid range",
+    LS_POOL_ALREADY_EXISTS: "Pool is already registered",
+    LS_POOL_MUST_BE_SET: "Pool address cannot be zero",
+    LS_PROTOCOL_FEE_RECIPIENT_REQUIRED: "Protocol fee recipient must be set",
+    LS_ZERO_DECIMAL: "Token has zero decimals",
+    // FPMM pool-side errors
+    NotLiquidityStrategy: "Caller is not a registered liquidity strategy",
+    PriceDifferenceTooSmall: "Pool deviation is below the rebalance threshold",
+    PriceDifferenceNotImproved: "Rebalance did not improve the price deviation",
+    PriceDifferenceMovedInWrongDirection: "Rebalance moved the price in the wrong direction",
+    PriceDifferenceMovedTooFarFromThresholds: "Rebalance moved the price too far past the threshold",
+    RebalanceDirectionInvalid: "Invalid rebalance direction",
+    RebalanceThresholdTooHigh: "Rebalance threshold exceeds allowed maximum",
+    RebalanceIncentiveTooHigh: "Rebalance incentive exceeds allowed maximum",
+    ReferenceRateNotSet: "Oracle reference rate is not configured",
+    ReserveValueDecreased: "Pool reserve value decreased after rebalance",
+    ReservesEmpty: "Pool reserves are empty",
+};
+/**
+ * Const-object mirror of `ReasonCode` so consumers can write
+ * `REASON_CODES.RLS_RESERVE_OUT_OF_COLLATERAL` instead of a bare string
+ * literal. Catches typos at the call site (the bare-string form would
+ * silently disable enrichment if mistyped).
+ */
+export const REASON_CODES = Object.freeze(Object.fromEntries(Object.keys(ERROR_MESSAGES).map((k) => [k, k])));
+/**
+ * Revert codes where the strategy refuses to rebalance BECAUSE the pool is
+ * healthy — not because anything is wrong. Both consumers collapse these
+ * to a passive "no action needed" state so no red "blocked" line appears
+ * in the UI / alert annotation when the rebalancer is just waiting for
+ * the pool to drift further past threshold.
+ */
+export const HEALTHY_NO_OP_ERRORS = new Set([
+    "LS_POOL_NOT_REBALANCEABLE",
+    "PriceDifferenceTooSmall",
+]);

package/dist/rebalance-enrichment.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Reserve-strategy enrichment helper — shared by the dashboard's pool-detail
+ * tooltip and the metrics-bridge Slack-alert probe. Both consumers walk the
+ * same chain (`reserve()` → debt-leg lookup → `balanceOf` + `decimals` on
+ * collateral); the only consumer-specific concerns are:
+ *
+ *   - WHERE the debt-leg flag comes from. Bridge reads `determineAction(pool)`
+ *     to also recover `amountOwedToPool` (the strategy's required transfer to
+ *     close the breach); dashboard reads `poolConfigs(pool)` and skips the
+ *     needed-amount lookup. Encoded by `mode: "needed" | "balance-only"`.
+ *   - WHAT the symbol resolver looks like. Bridge calls
+ *     `tokenSymbol(chainId, addr)` from the canonical manifest; dashboard
+ *     reads `symbol()` on-chain. Encoded by an injected `resolveSymbol`
+ *     callback.
+ *   - HOW decimals get resolved. Bridge memoizes via the canonical manifest
+ *     plus a process-lifetime cache; dashboard reads `decimals()` on-chain.
+ *     Encoded by an injected `resolveDecimals` callback.
+ *
+ * shared-config stays viem-free: the consumer passes an opaque
+ * `EnrichmentRpc` shape (just the `readContract` calls we need) so the
+ * function compiles without depending on viem's `PublicClient`.
+ */
+import { ERC20_ABI_SOURCES, POOL_PAIR_ABI_SOURCES } from "./erc20-abi.js";
+import { STRATEGY_ABI_SOURCES } from "./rebalance-abi.js";
+/**
+ * Re-export the source ABI strings so consumers don't have to thread two
+ * imports together to call `parseAbi(...)` on the same fragments. Keeping
+ * the strings (not parsed ABIs) keeps shared-config viem-free.
+ */
+export { ERC20_ABI_SOURCES, POOL_PAIR_ABI_SOURCES, STRATEGY_ABI_SOURCES };
+/**
+ * Minimal RPC surface the enrichment fetch needs. The four dispatchers
+ * mirror viem's `client.readContract` shape (per-callsite ABI / function
+ * name / args / return type) so consumers can adapt their viem client with
+ * a single thin wrapper. See `metrics-bridge/src/rebalance-check.ts` and
+ * `ui-dashboard/src/lib/rebalance-check.ts` for the call shape.
+ *
+ * Each dispatcher accepts an optional `signal: AbortSignal`. When present
+ * and aborted, the dispatcher MUST reject promptly so the caller's await
+ * unblocks (the underlying viem `client.readContract` doesn't natively
+ * accept a per-call signal in viem 2.47.0, so consumers wrap each call in
+ * a `Promise.race`-style abort guard — see metrics-bridge's `abortable`
+ * helper). This lets the metrics-bridge probe runner cancel an outlived
+ * cycle's enrichment fetches without leaking RPC calls.
+ */
+export interface EnrichmentRpc {
+    /** Read `determineAction(pool)` — used in `mode: "needed"`. */
+    readDetermineAction(args: {
+        strategy: `0x${string}`;
+        pool: `0x${string}`;
+        signal?: AbortSignal;
+    }): Promise<{
+        isToken0Debt: boolean;
+        amountOwedToPool: bigint;
+    }>;
+    /** Read `poolConfigs(pool)` — used in `mode: "balance-only"`. */
+    readPoolConfigs(args: {
+        strategy: `0x${string}`;
+        pool: `0x${string}`;
+        signal?: AbortSignal;
+    }): Promise<{
+        isToken0Debt: boolean;
+    }>;
+    /** Read pool's `token0()` and `token1()` in parallel. */
+    readPoolTokens(pool: `0x${string}`, signal?: AbortSignal): Promise<{
+        token0: `0x${string}`;
+        token1: `0x${string}`;
+    }>;
+    /** Read `balanceOf(holder)` against an ERC20. */
+    readBalanceOf(args: {
+        token: `0x${string}`;
+        holder: `0x${string}`;
+        signal?: AbortSignal;
+    }): Promise<bigint>;
+}
+export interface EnrichmentOptions {
+    chainId: number;
+    /**
+     * Reserve address — bridge threads this in from the upstream detection
+     * call (Reserve detection itself reads `reserve()`, so it's free), saving
+     * one RPC per probe. Dashboard reads it on-demand and passes the resolved
+     * value here.
+     */
+    reserveAddr: `0x${string}`;
+    /**
+     * `"needed"` reads `determineAction(pool)` (returns `amountOwedToPool`
+     * alongside `isToken0Debt`). `"balance-only"` reads `poolConfigs(pool)`
+     * and skips the needed-amount lookup.
+     */
+    mode: "needed" | "balance-only";
+    /**
+     * Symbol resolver — receives `(chainId, address)`, returns the canonical
+     * symbol or `null`. Bridge passes `tokenSymbol` from the contracts
+     * manifest; dashboard passes a wrapper around its on-chain `symbol()`
+     * read.
+     */
+    resolveSymbol(chainId: number, address: `0x${string}`): Promise<string | null> | string | null;
+    /**
+     * Decimals resolver — receives `(chainId, address)`, returns the
+     * decimals. Both consumers prefer the canonical manifest first (zero
+     * RPC) and fall back to an on-chain read; the difference is in the
+     * caching strategy. Throw on unrecoverable RPC failure.
+     *
+     * The optional `signal` is forwarded by the bridge probe so a timed-out
+     * cycle can short-circuit on-chain decimal lookups too — dashboards
+     * that don't aim a signal at this resolver simply omit the argument.
+     */
+    resolveDecimals(chainId: number, address: `0x${string}`, signal?: AbortSignal): Promise<number>;
+    /**
+     * Optional abort signal threaded through every RPC call this enrichment
+     * fetch issues. When the signal aborts, all in-flight reads MUST reject
+     * promptly so the caller can stop holding stale state. The metrics-bridge
+     * probe sets this to its per-probe AbortController; the dashboard tooltip
+     * leaves it undefined (no cancellation requirement on user-initiated
+     * tooltip fetches).
+     */
+    signal?: AbortSignal;
+}
+export interface EnrichmentResult {
+    collateralToken: `0x${string}`;
+    /** Reserve's current ERC20 balance of the collateral, in human units. */
+    balance: number;
+    /** Strategy's required transfer to close the breach, in human units. Absent in `balance-only` mode. */
+    needed?: number;
+    /** Resolved collateral token symbol — `null` when the manifest lookup misses. */
+    tokenSymbol: string | null;
+    /** Decimals of the collateral token. */
+    decimals: number;
+}
+/**
+ * Fetch the reserve-collateral state needed to annotate a
+ * `RLS_RESERVE_OUT_OF_COLLATERAL` revert with on-chain context. Returns
+ * `null` on any RPC failure so consumers can fall back to the generic
+ * reason message without crashing the breach alert.
+ */
+export declare function fetchReserveEnrichment(rpc: EnrichmentRpc, strategy: `0x${string}`, pool: `0x${string}`, options: EnrichmentOptions): Promise<EnrichmentResult | null>;
+//# sourceMappingURL=rebalance-enrichment.d.ts.map

package/dist/rebalance-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalance-enrichment.d.ts","sourceRoot":"","sources":["../src/rebalance-enrichment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAG1D;;;;GAIG;AACH,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,CAAC;AAE1E;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,mBAAmB,CAAC,IAAI,EAAE;QACxB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;QACxB,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjE,iEAAiE;IACjE,eAAe,CAAC,IAAI,EAAE;QACpB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;QACxB,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACvC,yDAAyD;IACzD,cAAc,CACZ,IAAI,EAAE,KAAK,MAAM,EAAE,EACnB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC;QAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,KAAK,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAC7D,iDAAiD;IACjD,aAAa,CAAC,IAAI,EAAE;QAClB,KAAK,EAAE,KAAK,MAAM,EAAE,CAAC;QACrB,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;QACtB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;IAC3B;;;;OAIG;IACH,IAAI,EAAE,QAAQ,GAAG,cAAc,CAAC;IAChC;;;;;OAKG;IACH,aAAa,CACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,KAAK,MAAM,EAAE,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;IAC1C;;;;;;;;;OASG;IACH,eAAe,CACb,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,KAAK,MAAM,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,uGAAuG;IACvG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,aAAa,EAClB,QAAQ,EAAE,KAAK,MAAM,EAAE,EACvB,IAAI,EAAE,KAAK,MAAM,EAAE,EACnB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAgElC"}

package/dist/rebalance-enrichment.js

@@ -0,0 +1,96 @@
+/**
+ * Reserve-strategy enrichment helper — shared by the dashboard's pool-detail
+ * tooltip and the metrics-bridge Slack-alert probe. Both consumers walk the
+ * same chain (`reserve()` → debt-leg lookup → `balanceOf` + `decimals` on
+ * collateral); the only consumer-specific concerns are:
+ *
+ *   - WHERE the debt-leg flag comes from. Bridge reads `determineAction(pool)`
+ *     to also recover `amountOwedToPool` (the strategy's required transfer to
+ *     close the breach); dashboard reads `poolConfigs(pool)` and skips the
+ *     needed-amount lookup. Encoded by `mode: "needed" | "balance-only"`.
+ *   - WHAT the symbol resolver looks like. Bridge calls
+ *     `tokenSymbol(chainId, addr)` from the canonical manifest; dashboard
+ *     reads `symbol()` on-chain. Encoded by an injected `resolveSymbol`
+ *     callback.
+ *   - HOW decimals get resolved. Bridge memoizes via the canonical manifest
+ *     plus a process-lifetime cache; dashboard reads `decimals()` on-chain.
+ *     Encoded by an injected `resolveDecimals` callback.
+ *
+ * shared-config stays viem-free: the consumer passes an opaque
+ * `EnrichmentRpc` shape (just the `readContract` calls we need) so the
+ * function compiles without depending on viem's `PublicClient`.
+ */
+import { ERC20_ABI_SOURCES, POOL_PAIR_ABI_SOURCES } from "./erc20-abi.js";
+import { STRATEGY_ABI_SOURCES } from "./rebalance-abi.js";
+import { toHumanUnits } from "./units.js";
+/**
+ * Re-export the source ABI strings so consumers don't have to thread two
+ * imports together to call `parseAbi(...)` on the same fragments. Keeping
+ * the strings (not parsed ABIs) keeps shared-config viem-free.
+ */
+export { ERC20_ABI_SOURCES, POOL_PAIR_ABI_SOURCES, STRATEGY_ABI_SOURCES };
+/**
+ * Fetch the reserve-collateral state needed to annotate a
+ * `RLS_RESERVE_OUT_OF_COLLATERAL` revert with on-chain context. Returns
+ * `null` on any RPC failure so consumers can fall back to the generic
+ * reason message without crashing the breach alert.
+ */
+export async function fetchReserveEnrichment(rpc, strategy, pool, options) {
+    try {
+        // 1. Determine which leg is debt + (in needed-mode) the required
+        //    transfer amount. Issued in parallel with the pool's token0/token1
+        //    reads since neither dependency-graphs into the other. Strategy
+        //    debt-leg read goes first so consumers with sequential / order-
+        //    sensitive mocks (vitest `mockResolvedValueOnce` chains) can stay
+        //    deterministic without overhauling their fixtures.
+        const { signal } = options;
+        const [debtInfo, { token0, token1 }] = await Promise.all([
+            options.mode === "needed"
+                ? rpc.readDetermineAction({ strategy, pool, signal })
+                : rpc.readPoolConfigs({ strategy, pool, signal }),
+            rpc.readPoolTokens(pool, signal),
+        ]);
+        // 2. Collateral is the non-debt leg.
+        const collateralToken = debtInfo.isToken0Debt ? token1 : token0;
+        // 3. balanceOf + symbol + decimals on the collateral token. All three
+        //    reads are independent of each other given `collateralToken`, so
+        //    we issue them in parallel. Decimals + symbol may resolve from the
+        //    consumer's manifest / cache (zero RPC) or fall back to an on-chain
+        //    read; balanceOf is always fresh.
+        const [balance, tokenSymbol, decimals] = await Promise.all([
+            rpc.readBalanceOf({
+                token: collateralToken,
+                holder: options.reserveAddr,
+                signal,
+            }),
+            options.resolveSymbol(options.chainId, collateralToken),
+            options.resolveDecimals(options.chainId, collateralToken, signal),
+        ]);
+        const result = {
+            collateralToken,
+            balance: toHumanUnits(balance, decimals),
+            tokenSymbol,
+            decimals,
+        };
+        if (options.mode === "needed" &&
+            "amountOwedToPool" in debtInfo &&
+            typeof debtInfo.amountOwedToPool === "bigint") {
+            result.needed = toHumanUnits(debtInfo.amountOwedToPool, decimals);
+        }
+        return result;
+    }
+    catch (err) {
+        // Re-throw aborts so the caller's wall-clock timeout actually short-
+        // circuits — otherwise an AbortError mid-enrichment gets swallowed and
+        // the probe returns the un-enriched blocked result instead of a
+        // transport_error, defeating the abort guarantee for any pool whose
+        // signal happens to fire during reserve enrichment.
+        if (err &&
+            typeof err === "object" &&
+            (err.name === "AbortError" ||
+                err.code === "ABORT_ERR")) {
+            throw err;
+        }
+        return null;
+    }
+}

package/dist/thresholds.d.ts

@@ -0,0 +1,25 @@
+/**
+ * OK/WARN boundary. A pool is considered "within tolerance" while
+ * `priceDifference / rebalanceThreshold ≤ DEVIATION_TOLERANCE_RATIO`.
+ * Strict `>` flips the pool to WARN (or above).
+ *
+ * Mirrors `DEVIATION_TOLERANCE_NUM / DEVIATION_TOLERANCE_DEN` in
+ * `indexer-envio/src/pool/health.ts`; `test/deviationThresholdSharedConfigSync.test.ts`
+ * enforces numeric parity and `test/healthStatusParity.test.ts` enforces
+ * behavioral parity with the dashboard's `computeHealthStatus`.
+ */
+export declare const DEVIATION_TOLERANCE_RATIO = 1.01;
+/**
+ * WARN/CRITICAL magnitude boundary. A pool past `DEVIATION_TOLERANCE_RATIO`
+ * stays WARN until `priceDifference / rebalanceThreshold > DEVIATION_CRITICAL_RATIO`
+ * AND the breach has outlived `DEVIATION_BREACH_GRACE_SECONDS`. Below this
+ * magnitude, duration alone never escalates a breach to CRITICAL.
+ *
+ * Mirrors `DEVIATION_CRITICAL_NUM / DEVIATION_CRITICAL_DEN` in
+ * `indexer-envio/src/pool/health.ts`; `test/deviationThresholdSharedConfigSync.test.ts`
+ * enforces numeric parity and `test/healthStatusParity.test.ts` enforces
+ * behavioral parity. Also gates the metrics-bridge rebalance-reason probe so
+ * the annotation only attaches to alerts that can actually fire.
+ */
+export declare const DEVIATION_CRITICAL_RATIO = 1.05;
+//# sourceMappingURL=thresholds.d.ts.map

package/dist/thresholds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thresholds.d.ts","sourceRoot":"","sources":["../src/thresholds.ts"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC"}