@gearbox-protocol/sdk 16.0.0-next.8 → 16.0.0

package/dist/types/preview/preview/{previewCloseOrRepayCreditAccount.d.ts → previewExitOrRepayStrategyPosition.d.ts}

@@ -1,4 +1,4 @@
-import { CloseCreditAccountPreview, RepayCreditAccountPreview } from "../../model/previews.js";
+import { ExitStrategyPositionPreview, RepayStrategyPositionPreview } from "../../model/previews.js";
 import "../../model/index.js";
 import { PluginsMap } from "../../onchain/plugins/types.js";
 import "../../onchain/index.js";
@@ -6,13 +6,13 @@ import { CloseCreditAccountOperation, MulticallOperation } from "../parse/types-
 import { RWAMulticallOperation } from "../parse/types-rwa.js";
 import { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
 import "../parse/index.js";
-//#region src/preview/preview/previewCloseOrRepayCreditAccount.d.ts
+//#region src/preview/preview/previewExitOrRepayStrategyPosition.d.ts
 /**
  * Any parsed operation that fully closes or repays a credit account: the
  * facade `closeCreditAccount` entry point (permanent closure) or a plain
  * multicall detected by `isCloseOrRepay` (`decreaseDebt(MAX)`).
  */
 type CloseOrRepayOperation = CloseCreditAccountOperation | MulticallOperation | RWAMulticallOperation;
-declare function previewCloseOrRepayCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: CloseOrRepayOperation, permanent: boolean, options: PreviewOperationOptions<true>): Promise<CloseCreditAccountPreview | RepayCreditAccountPreview>;
+declare function previewExitOrRepayStrategyPosition<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: CloseOrRepayOperation, permanent: boolean, options: PreviewOperationOptions<true>): ExitStrategyPositionPreview | RepayStrategyPositionPreview;
 //#endregion
-export { CloseOrRepayOperation, previewCloseOrRepayCreditAccount };
+export { CloseOrRepayOperation, previewExitOrRepayStrategyPosition };

package/dist/types/preview/preview/previewOpenStrategyPosition.d.ts

@@ -0,0 +1,12 @@
+import { OpenStrategyPositionPreview } from "../../model/previews.js";
+import "../../model/index.js";
+import { PluginsMap } from "../../onchain/plugins/types.js";
+import "../../onchain/index.js";
+import { OpenCreditAccountOperation } from "../parse/types-facades.js";
+import { RWAOpenCreditAccountOperation } from "../parse/types-rwa.js";
+import { PreviewOperationInput } from "../types.js";
+import "../parse/index.js";
+//#region src/preview/preview/previewOpenStrategyPosition.d.ts
+declare function previewOpenStrategyPosition<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: OpenCreditAccountOperation | RWAOpenCreditAccountOperation): OpenStrategyPositionPreview;
+//#endregion
+export { previewOpenStrategyPosition };

package/dist/types/preview/preview/previewOperation.d.ts

@@ -1,13 +1,32 @@
 import { OperationPreview } from "../../model/previews.js";
+import { SDKReturn } from "../../model/result.js";
 import "../../model/index.js";
+import { InvalidDelayedIntentError } from "../../onchain/accounts/withdrawal-compressor/errors.js";
+import { UnsupportedZapperFunctionError } from "../../onchain/market/zapper/errors.js";
 import { PluginsMap } from "../../onchain/plugins/types.js";
 import "../../onchain/index.js";
+import { UnsupportedPoolFunctionError, UnsupportedTargetError } from "../parse/errors.js";
 import { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import "../parse/index.js";
+import { UnsupportedOperationError } from "./errors.js";
+import { PreviewSimulationError } from "../simulate/errors.js";
 //#region src/preview/preview/previewOperation.d.ts
+/**
+ * Everything {@link previewOperation} can refuse with: the refusal errors
+ * its pipeline raises, discriminated by `code`. Each is a plain object —
+ * never a thrown `Error` — per the SDK's refusal vocabulary.
+ */
+type PreviewOperationError = UnsupportedTargetError | UnsupportedPoolFunctionError | UnsupportedZapperFunctionError | UnsupportedOperationError | InvalidDelayedIntentError | PreviewSimulationError;
 /**
  * Previews a raw operation calldata: decodes it into a typed operation and
  * assembles an operation-specific, human-displayable preview.
+ *
+ * Answers an {@link SDKReturn} envelope: the preview behind `ok: true`, or —
+ * when the transaction is one the previewer refuses to read — a
+ * {@link PreviewOperationError} behind `ok: false`. A thrown exception
+ * still means the SDK could not do its job (a read failed, the targeted
+ * credit account could not be resolved), not a refusal of the transaction.
  */
-declare function previewOperation<P extends PluginsMap = PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<OperationPreview>;
+declare function previewOperation<P extends PluginsMap = PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<SDKReturn<OperationPreview, PreviewOperationError>>;
 //#endregion
-export { previewOperation };
+export { PreviewOperationError, previewOperation };

package/dist/types/preview/preview/previewPoolPositionOperation.d.ts

@@ -0,0 +1,13 @@
+import { PoolPositionOperationPreview } from "../../model/previews.js";
+import { SDKReturn } from "../../model/result.js";
+import "../../model/index.js";
+import { PluginsMap } from "../../onchain/plugins/types.js";
+import "../../onchain/index.js";
+import { PoolOperation } from "../parse/types-pools.js";
+import { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import "../parse/index.js";
+import { PreviewSimulationError } from "../simulate/errors.js";
+//#region src/preview/preview/previewPoolPositionOperation.d.ts
+declare function previewPoolPositionOperation<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: PoolOperation, options?: PreviewOperationOptions): Promise<SDKReturn<PoolPositionOperationPreview, PreviewSimulationError>>;
+//#endregion
+export { previewPoolPositionOperation };

package/dist/types/preview/preview/replayInnerOperations.d.ts

@@ -41,11 +41,11 @@ declare function makeReplayState(account: CreditAccountState): ReplayState;
  * facade execution order. The result is the *minimal guaranteed* post-state.
  *
  * The function assumes that the call was generated by our frontend using
- * router/withdrawal compressor, otherwise it returns an error, but still
+ * router/withdrawal compressor, otherwise it returns a warning, but still
  * proceeds best-effort.
  *
- * @returns `undefined` on success, the error on a malformed multicall.
+ * @returns `undefined` on success, the warning on a malformed multicall.
  */
-declare function replayInnerOperations<P extends PluginsMap>(sdk: OnchainSDK<P>, multicall: InnerOperation[], state: ReplayState): Promise<OperationPreviewError | undefined>;
+declare function replayInnerOperations<P extends PluginsMap>(sdk: OnchainSDK<P>, multicall: InnerOperation[], state: ReplayState): OperationPreviewError | undefined;
 //#endregion
 export { ReplayState, makeReplayState, replayInnerOperations };

package/dist/types/preview/preview/replayMulticall.d.ts

@@ -33,12 +33,12 @@ interface ReplayMulticallResult {
    * replay in facade execution order
    */
   after: ReplayState;
-  error?: OperationPreviewError;
+  warning?: OperationPreviewError;
 }
 /**
  * Replays the operation's multicall over the account's pre-resolved
  * pre-state (`options.creditAccount`) via {@link replayInnerOperations}.
  */
-declare function replayMulticall<P extends PluginsMap>(sdk: OnchainSDK<P>, operation: ReplayableOperation, options: PreviewOperationOptions<true>): Promise<ReplayMulticallResult>;
+declare function replayMulticall<P extends PluginsMap>(sdk: OnchainSDK<P>, operation: ReplayableOperation, options: PreviewOperationOptions<true>): ReplayMulticallResult;
 //#endregion
 export { ReplayMulticallResult, ReplayableOperation, replayMulticall };

package/dist/types/preview/preview/unwrapNativeCollateral.d.ts

@@ -10,9 +10,9 @@ interface UnwrapNativeCollateralResult {
    */
   assets: Asset[];
   /**
-   * Error set when the transaction value is malformed.
+   * Warning set when the transaction value is malformed.
    */
-  error?: OperationPreviewError;
+  warning?: OperationPreviewError;
 }
 /**
  * Represents the transaction's attached native value as a `NATIVE_ADDRESS`
@@ -26,14 +26,13 @@ interface UnwrapNativeCollateralResult {
  *
  * When `nativeAmount` is positive but the WETH collateral is missing or
  * smaller than it, the transaction is malformed: the collateral is returned
- * as-is (no unwrapping) together with an `ERROR_INVALID_TRANSACTION_VALUE`
- * error.
+ * as-is (no unwrapping) together with an `invalidTransactionValue` warning.
  *
  * @param collateral - Collateral assets as declared by the multicall.
  * @param nativeAmount - Transaction `msg.value`.
  * @param wethToken - Wrapped native token address.
  * @returns Collateral with the native amount unwrapped from the WETH entry,
- * plus the error on a malformed transaction value.
+ * plus the warning on a malformed transaction value.
  */
 declare function unwrapNativeCollateral(collateral: Asset[], nativeAmount: bigint, wethToken: Address): UnwrapNativeCollateralResult;
 //#endregion

package/dist/types/preview/simulate/errors.d.ts

@@ -1,4 +1,6 @@
-import { BaseError, Hex } from "viem";
+import { IGearboxError } from "../../model/errors.js";
+import "../../model/index.js";
+import { Hex } from "viem";
 //#region src/preview/simulate/errors.d.ts
 /** Which simulation flow produced a failure. */
 type SimulationFlowSource = "multicall" | "unknown";
@@ -8,14 +10,16 @@ interface SimulationFlowFailure {
   detail: SimulationError;
 }
 /**
- * Error returned by the pool simulation when it fails. It wraps the flow's
- * decoded revert reason (see {@link failures}).
+ * Refusal answered when the pool simulation fails. It wraps each flow's
+ * decoded revert reason (see {@link failures}). A plain returned object per
+ * the SDK's refusal vocabulary — not a thrown `Error`.
  */
-declare class PreviewSimulationError extends BaseError {
-  name: string;
-  /** Per-flow decoded failures behind this error. */
-  readonly failures: SimulationFlowFailure[];
-  constructor(failures: SimulationFlowFailure[]);
+interface PreviewSimulationError extends IGearboxError {
+  code: "previewSimulationFailed";
+  /** Per-flow decoded failures behind this refusal. */
+  failures: SimulationFlowFailure[];
+  /** First flow failure that was itself an `Error`, kept for debugging. */
+  cause?: Error;
 }
 /**
  * Normalises an unknown rejection reason into a {@link PreviewSimulationError}.

package/dist/types/preview/simulate/index.d.ts

@@ -1,7 +1,7 @@
-import { PreviewSimulationError, SimulationError, SimulationFlowFailure, SimulationFlowSource } from "./errors.js";
+import { PreviewSimulationError, SimulationError, SimulationFlowFailure, SimulationFlowSource, asPreviewSimulationError } from "./errors.js";
 import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulateOperation } from "./simulateOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
 import { simulateRWAOperation } from "./simulateRWAOperation.js";
-export { type PoolOperationSimulationResult, PreviewSimulationError, type SimulationError, type SimulationFlowFailure, type SimulationFlowSource, type SimulationInput, simulateFacadeOperation, simulateOperation, simulatePoolOperation, simulateRWAOperation };
+export { type PoolOperationSimulationResult, type PreviewSimulationError, type SimulationError, type SimulationFlowFailure, type SimulationFlowSource, type SimulationInput, asPreviewSimulationError, simulateFacadeOperation, simulateOperation, simulatePoolOperation, simulateRWAOperation };

package/dist/types/preview/simulate/simulateOperation.d.ts

@@ -1,9 +1,12 @@
+import { SDKReturn } from "../../model/result.js";
+import "../../model/index.js";
 import { PreviewOperationOptions } from "../types.js";
+import { PreviewSimulationError } from "./errors.js";
 import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 //#region src/preview/simulate/simulateOperation.d.ts
 /**
  * Simulates a parsed pool or credit account operation
  */
-declare function simulateOperation(input: SimulationInput, options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;
+declare function simulateOperation(input: SimulationInput, options?: PreviewOperationOptions): Promise<SDKReturn<PoolOperationSimulationResult, PreviewSimulationError>>;
 //#endregion
 export { simulateOperation };

package/dist/types/preview/simulate/simulatePoolOperation.d.ts

@@ -1,8 +1,28 @@
+import { SDKReturn } from "../../model/result.js";
+import "../../model/index.js";
 import { PoolOperation } from "../parse/types-pools.js";
 import { PreviewOperationOptions } from "../types.js";
 import "../parse/index.js";
+import { PreviewSimulationError } from "./errors.js";
 import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
+import { ContractFunctionParameters } from "viem";
 //#region src/preview/simulate/simulatePoolOperation.d.ts
+/**
+ * Builds the preview read that converts the operation's known amount into its
+ * counterpart. Direct operations read the pool's ERC4626 preview; zapper-routed
+ * operations (only ever `Deposit`/`Redeem`) read the zapper's
+ * `previewDeposit`/`previewRedeem`, which account for the zapper's own
+ * conversion in addition to the pool's.
+ */
+declare function previewContract(operation: PoolOperation): ContractFunctionParameters;
+/**
+ * Maps a pool operation and its preview result to the amounts of tokens going
+ * in (user -> pool) and out (pool -> user). `previewAmount` is the counterpart
+ * amount returned by the matching preview read (shares for deposit/withdraw,
+ * assets for mint/redeem, and the zapper's converted amount for zapper-routed
+ * deposit/redeem).
+ */
+declare function amountsInOut(operation: PoolOperation, previewAmount: bigint): PoolOperationSimulationResult;
 /**
  * Simulates a pool deposit/mint/withdraw/redeem (direct or zapper-routed) and
  * returns the resulting token amounts going in and out. Throws a
@@ -17,6 +37,6 @@ import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
  * It does not execute the calldata, so it ignores balance/allowance
  * prerequisites (preview reads succeed regardless).
  */
-declare function simulatePoolOperation(input: SimulationInput<PoolOperation>, options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;
+declare function simulatePoolOperation(input: SimulationInput<PoolOperation>, options?: PreviewOperationOptions): Promise<SDKReturn<PoolOperationSimulationResult, PreviewSimulationError>>;
 //#endregion
-export { simulatePoolOperation };
+export { amountsInOut, previewContract, simulatePoolOperation };

package/dist/types/preview/simulate/types.d.ts

@@ -26,13 +26,21 @@ interface SimulationInput<Op extends Operation = Operation> {
  */
 interface PoolOperationSimulationResult {
   /**
-   * Amount of tokens going from the user to the pool (underlying or zapper
-   * input token for deposit/mint, pool shares for withdraw/redeem).
+   * User -> pool.
+   *
+   * Deposit/mint: underlying (or zapper input); `withdrawFee` does not apply.
+   *
+   * Withdraw/redeem: shares burned. On withdraw, `previewWithdraw` inflates
+   * that burn for `withdrawFee`; on redeem, the shares from calldata.
    **/
   amountIn: bigint;
   /**
-   * Amount of tokens going from the pool to the user (pool shares or zapper
-   * output token for deposit/mint, underlying for withdraw/redeem).
+   * Pool -> user.
+   *
+   * Deposit/mint: shares minted (or zapper output); `withdrawFee` does not apply.
+   *
+   * Withdraw/redeem: underlying paid out. On withdraw, the requested amount;
+   * on redeem, `previewRedeem` after `withdrawFee`.
    **/
   amountOut: bigint;
 }

package/dist/types/preview/trace/extractAdapterCallTraces.d.ts

@@ -1,4 +1,4 @@
-import { CallTrace } from "../../common-utils/utils/trace.js";
+import { CallTrace } from "../../onchain/utils/trace.js";
 //#region src/preview/trace/extractAdapterCallTraces.d.ts
 /**
  * Extracts the user multicall's adapter-level call traces from a single facade

package/dist/types/preview/trace/findFacadeCalls.d.ts

@@ -1,4 +1,4 @@
-import { CallTrace } from "../../common-utils/utils/trace.js";
+import { CallTrace } from "../../onchain/utils/trace.js";
 import { ChainContractsRegister } from "../../onchain/base/ChainContractsRegister.js";
 import "../../onchain/index.js";
 import { FacadeParsedCall } from "./types.js";

package/dist/types/preview/trace/types.d.ts

@@ -1,5 +1,5 @@
 import { ParsedCallV2 } from "../../onchain/base/types.js";
-import { CallTrace } from "../../common-utils/utils/trace.js";
+import { CallTrace } from "../../onchain/utils/trace.js";
 import "../../onchain/index.js";
 import { Address } from "viem";
 //#region src/preview/trace/types.d.ts

package/dist/types/preview/validate/checkOperation.d.ts

@@ -0,0 +1,71 @@
+import { Bps } from "../../model/primitives.js";
+import { AccountHoldings, AccountMetrics, AccountProjection, OperationPreview } from "../../model/previews.js";
+import "../../model/index.js";
+import { AddressMap } from "../../onchain/utils/AddressMap.js";
+import { CreditSuite } from "../../onchain/market/credit/CreditSuite.js";
+import { OnchainSDK } from "../../onchain/OnchainSDK.js";
+import { PreviewIssue } from "../../onchain/validation/refusal.js";
+import "../../onchain/index.js";
+//#region src/preview/validate/checkOperation.d.ts
+/** Omitting a bar switches its check off — there is no single right one. */
+interface CheckOperationOptions {
+  /** Lowest acceptable health factor at main prices, in bps. */
+  minHealthFactor?: Bps;
+  /** Lowest acceptable health factor at safe prices, in bps. */
+  minSafeHealthFactor?: Bps;
+  /**
+   * Balances the operation is funded from, by token. Given, the wallet's side
+   * is checked offline; omitted, funding is left to `checkPrerequisites`.
+   */
+  balances?: AddressMap<bigint>;
+  /**
+   * The factor the account stands at now. Given, an operation that raises it
+   * passes even from under the bar — the top-ups that rescue a position would
+   * otherwise be refused by the very check meant to protect it.
+   */
+  currentHealthFactor?: Bps;
+}
+/**
+ * Whether a parsed operation may be signed at all — the protocol state that
+ * `checkPrerequisites` leaves out, since that one covers only what the sender
+ * can fix themselves.
+ *
+ * Synchronous: the preview carries the numbers and the market is attached.
+ * Reports the most fundamental issue it finds and stops there, which is the one
+ * a caller acts on.
+ */
+declare function checkOperation(input: {
+  sdk: OnchainSDK;
+  preview: OperationPreview;
+}, options?: CheckOperationOptions): PreviewIssue | null;
+/** What the market itself refuses, whatever the operation does. */
+declare function marketIssues(suite: CreditSuite): PreviewIssue | null;
+/**
+ * A bar that reads nothing but the projected account, so a parsed transaction
+ * and a simulated one are held to it by the same code.
+ *
+ * These stay separate functions rather than one block because the order the
+ * checks run in is the answer: `checkOperation` interleaves the checks that
+ * need an operation's *delta* between them, and the caller acts on the first
+ * issue reported.
+ */
+declare function quotaCountIssue(suite: CreditSuite, account: Pick<AccountProjection, "quotas">): PreviewIssue | null;
+/**
+ * An account's factors, in whichever branch of a routed leg the caller means to
+ * be held to: `prepare` reports the outcome the router expects, `preview` the
+ * floor its calldata guarantees. The bar is indifferent — it weighs the numbers
+ * it is handed — and passing them one by one is what makes the choice visible
+ * where it is made.
+ */
+interface WeighedFactors extends Pick<AccountHoldings, "totalDebt">, Pick<AccountMetrics, "healthFactor" | "safeHealthFactor"> {}
+/**
+ * The account against whichever bars the caller holds it to.
+ *
+ * A loan-free account is nothing to weigh: the health factor reports its
+ * zero-debt sentinel and no bar applies.
+ *
+ * {@inheritDoc quotaCountIssue}
+ */
+declare function collateralIssue(account: WeighedFactors, options: CheckOperationOptions): PreviewIssue | null;
+//#endregion
+export { CheckOperationOptions, WeighedFactors, checkOperation, collateralIssue, marketIssues, quotaCountIssue };

package/dist/types/preview/validate/checkSimulation.d.ts

@@ -0,0 +1,32 @@
+import { OnchainSDK } from "../../onchain/OnchainSDK.js";
+import { PreviewIssue } from "../../onchain/validation/refusal.js";
+import { OperationState } from "../../onchain/accounts/intents/types.js";
+import "../../onchain/index.js";
+import { CheckOperationOptions } from "./checkOperation.js";
+//#region src/preview/validate/checkSimulation.d.ts
+/**
+ * Whether a simulated operation clears the caller's own bars.
+ *
+ * The engine holds an account to the facade's `1.0`, because its guards answer
+ * "would this revert". A form is wiser to ask for more, and the engine's own
+ * note says so — a caller wanting the stricter bar applies it itself. This is
+ * that second opinion, over the numbers the engine already reported.
+ *
+ * Three of the checks below the engine does not make at all: both health-factor
+ * bars are its own `1.0`, and the quota count it never weighs. The other two run
+ * against the same numbers the engine used, and are here so that a change in the
+ * engine cannot pass silently.
+ *
+ * What is deliberately absent: the forbidden-token, quota-limit and funding
+ * checks all need the *delta* an operation applies, and `OperationState` reports
+ * only the state after it. Weighing them against absolutes would refuse a
+ * forbidden token the account merely holds, or a quota the operation never
+ * touched. The engine performed all three during the walk, so a simulation that
+ * came back `ok` has already passed them.
+ */
+declare function checkSimulation(input: {
+  sdk: OnchainSDK;
+  state: OperationState;
+}, options?: CheckOperationOptions): PreviewIssue | null;
+//#endregion
+export { checkSimulation };

package/dist/types/preview/validate/index.d.ts

@@ -0,0 +1,3 @@
+import { CheckOperationOptions, WeighedFactors, checkOperation, collateralIssue, marketIssues, quotaCountIssue } from "./checkOperation.js";
+import { checkSimulation } from "./checkSimulation.js";
+export { CheckOperationOptions, WeighedFactors, checkOperation, checkSimulation, collateralIssue, marketIssues, quotaCountIssue };

package/dist/types/rewards/errors.d.ts

@@ -0,0 +1,18 @@
+import { ChainId } from "../model/primitives.js";
+import "../model/index.js";
+import { BaseError } from "viem";
+//#region src/rewards/errors.d.ts
+/**
+ * Thrown when none of Merkl's domains answered for a chain.
+ *
+ * Everything a reader needs is in the message: this error travels to consumers
+ * inside a chain's {@link ChainFailed} metadata, where it is typed `unknown`
+ * and may be serialised by something that turns an arbitrary object into `{}`.
+ */
+declare class MerklRequestFailedError extends BaseError {
+  name: string;
+  readonly chainId: ChainId;
+  constructor(chainId: ChainId, path: string, attempts: ReadonlyArray<[domain: string, cause: unknown]>);
+}
+//#endregion
+export { MerklRequestFailedError };

package/dist/types/rewards/index.d.ts

@@ -1,7 +1,4 @@
-import { Apy, ApyDetails, DebtReward, ExternalApy, ExtraCollateralAPY, ExtraCollateralPointsInfo, FarmInfo, GearAPY, GearAPYDetails, PointsInfo, PointsReward, PoolExtraApy, PoolOutputDetails, PoolPointsInfo, TokenOutputDetails } from "./apy/output-details.js";
-import { DataResult, Output } from "./apy/output.js";
-import "./apy/index.js";
-import { GearboxExtraMerkleLmReward, GearboxLmReward, GetLmRewardsMerkleProps, PoolData, RewardAmountAPI } from "./rewards/api.js";
-import { GetPointsByPoolProps, GetTotalTokensOnProtocolProps, PoolPointsAPI, PoolPointsBase, getKeyForPoolPointsInfo } from "./rewards/extra-apy.js";
-import "./rewards/index.js";
-export { Apy, ApyDetails, DataResult, DebtReward, ExternalApy, ExtraCollateralAPY, ExtraCollateralPointsInfo, FarmInfo, GearAPY, GearAPYDetails, GearboxExtraMerkleLmReward, GearboxLmReward, GetLmRewardsMerkleProps, GetPointsByPoolProps, GetTotalTokensOnProtocolProps, Output, PointsInfo, PointsReward, PoolData, PoolExtraApy, PoolOutputDetails, PoolPointsAPI, PoolPointsBase, PoolPointsInfo, RewardAmountAPI, TokenOutputDetails, getKeyForPoolPointsInfo };
+import { MerklRequestFailedError } from "./errors.js";
+import { MerklReward, MerklRewardsSdk, toMerklRewards } from "./toMerklRewards.js";
+import { GetMerklRewardsMultichainProps, getMerklRewardsMultichain } from "./multichain.js";
+export { GetMerklRewardsMultichainProps, MerklRequestFailedError, MerklReward, MerklRewardsSdk, getMerklRewardsMultichain, toMerklRewards };

package/dist/types/rewards/merkl-api.d.ts

@@ -0,0 +1,64 @@
+import { ChainId } from "../model/primitives.js";
+import "../model/index.js";
+import { Address } from "viem";
+//#region src/rewards/merkl-api.d.ts
+interface MerkleXYZUserRewardsV4 {
+  chain: MerkleXYZChain;
+  rewards: Array<{
+    root: Address;
+    recipient: Address;
+    amount: string;
+    claimed: string;
+    pending: string;
+    proofs: Array<Address>;
+    token: {
+      address: Address;
+      chainId: number;
+      symbol: string;
+      decimals: number;
+      /**
+       * USD price of one whole token. Optional because Merkl omits the key
+       * outright for the tokens it does not price — points and the like —
+       * rather than sending a null.
+       */
+      price?: number;
+    };
+    breakdowns: Array<{
+      reason: string;
+      amount: string;
+      claimed: string;
+      pending: string;
+      campaignId: Address;
+    }>;
+  }>;
+}
+type MerkleXYZUserRewardsV4Response = Array<MerkleXYZUserRewardsV4>;
+interface MerkleXYZChain {
+  id: number;
+  name: string;
+  icon: string;
+}
+/**
+ * Merkl's own host and the Angle mirror, tried in this order.
+ */
+declare const MERKL_DOMAINS: readonly ["https://api.merkl.xyz", "https://api-merkl.angle.money"];
+declare const MERKL_API_KEY_HEADER = "X-API-Key";
+interface FetchMerklUserRewardsProps {
+  chainId: ChainId;
+  /** Checksummed by the caller — Merkl keys its answer on the exact string. */
+  user: Address;
+  /** Raises Merkl's rate limit; the keyless path answers too. */
+  apiKey?: string;
+}
+/**
+ * The wallet's raw Merkl rewards on one chain.
+ *
+ * Rejects with {@link MerklRequestFailedError} when neither domain answers, so
+ * a caller can tell an unreachable Merkl from a wallet with nothing to claim.
+ * A non-2xx counts as no answer and moves to the next domain: it carries no
+ * rewards either way, and treating it as success would report emptiness that
+ * was never established.
+ */
+declare function fetchMerklUserRewards({ chainId, user, apiKey }: FetchMerklUserRewardsProps): Promise<MerkleXYZUserRewardsV4Response>;
+//#endregion
+export { FetchMerklUserRewardsProps, MERKL_API_KEY_HEADER, MERKL_DOMAINS, MerkleXYZUserRewardsV4, MerkleXYZUserRewardsV4Response, fetchMerklUserRewards };

package/dist/types/rewards/multichain.d.ts

@@ -0,0 +1,33 @@
+import { ChainId } from "../model/primitives.js";
+import { DataResponse } from "../model/response.js";
+import "../model/index.js";
+import { PluginsMap } from "../onchain/plugins/types.js";
+import { MultichainSDK } from "../onchain/MultichainSDK.js";
+import "../onchain/index.js";
+import { MerklReward } from "./toMerklRewards.js";
+import { Address } from "viem";
+//#region src/rewards/multichain.d.ts
+interface GetMerklRewardsMultichainProps<Plugins extends PluginsMap = {}> {
+  /** Handle whose chains are asked. */
+  sdk: MultichainSDK<Plugins>;
+  /** Wallet whose claimable rewards to list. */
+  wallet: Address;
+  /**
+   * Chains to ask, defaulting to every chain the handle carries.
+   **/
+  chainIds?: ChainId[];
+  /** Raises Merkl's rate limit; the keyless path answers too. */
+  apiKey?: string;
+}
+/**
+ * Every claimable Merkl reward a wallet holds, across the chains the handle
+ * carries.
+ *
+ * Answers the read model's own envelope, so a chain that could not be reached
+ * is `status: "error"` in `meta.chains` while a chain with nothing to claim is
+ * a `"success"` that contributed no rows. That distinction is the point: the
+ * single-chain read this replaces resolved empty either way.
+ **/
+declare function getMerklRewardsMultichain<const Plugins extends PluginsMap = {}>({ sdk, wallet, chainIds, apiKey }: GetMerklRewardsMultichainProps<Plugins>): Promise<DataResponse<MerklReward[]>>;
+//#endregion
+export { GetMerklRewardsMultichainProps, getMerklRewardsMultichain };

package/dist/types/rewards/toMerklRewards.d.ts

@@ -0,0 +1,42 @@
+import { ChainId, Token, TokenAmount } from "../model/primitives.js";
+import "../model/index.js";
+import { OnchainSDK } from "../onchain/OnchainSDK.js";
+import "../onchain/index.js";
+import { MerkleXYZUserRewardsV4Response } from "./merkl-api.js";
+import { Address } from "viem";
+//#region src/rewards/toMerklRewards.d.ts
+/**
+ * One claimable Merkl liquidity-mining reward, denominated and priced.
+ *
+ * Both tokens arrive resolved, so a consumer neither looks one up nor
+ * reassembles one out of the loose fields Merkl sends.
+ */
+interface MerklReward {
+  readonly chainId: ChainId;
+  /** Market pool whose depositors the campaign rewards. */
+  readonly pool: Address;
+  /** That pool's share token — what the campaign is keyed on. */
+  readonly poolToken: Token;
+  /**
+   * The incentive token being handed out, how much of it is claimable
+   * (distributed minus already claimed, always > 0) and what that is worth.
+   *
+   * Priced by Merkl, not by the market oracles: a campaign's incentive token
+   * is rarely collateral in the pool it incentivises, so the oracles usually
+   * do not know it — GEAR, which most Gearbox campaigns pay in, among them.
+   * `valueUsd` is `null` for a token Merkl does not price either.
+   */
+  readonly amount: TokenAmount;
+}
+/**
+ * What the mapping needs off a chain's SDK: which chain the rows belong to,
+ * the pools a campaign can be keyed on, and the registry that names their
+ * tokens. Nothing else, and nothing asynchronous.
+ */
+type MerklRewardsSdk = Pick<OnchainSDK, "chainId" | "marketRegister" | "tokensMeta">;
+/**
+ * Merkl's answer for one chain, turned into rows of the read model.
+ */
+declare function toMerklRewards(sdk: MerklRewardsSdk, response: MerkleXYZUserRewardsV4Response): MerklReward[];
+//#endregion
+export { MerklReward, MerklRewardsSdk, toMerklRewards };

package/dist/types/sdk/AbstractNamespace.d.ts

@@ -2,9 +2,9 @@ import { ILogger } from "../onchain/types/logger.js";
 import { ChainId } from "../model/primitives.js";
 import { DataResponse } from "../model/response.js";
 import "../model/index.js";
-import { EnsureFreshChains, NamespaceOptions } from "./types.js";
 import { EntityMerger, ListMerger } from "./utils/types.js";
 import "./utils/index.js";
+import { EnsureFreshChains, NamespaceOptions } from "./types.js";
 //#region src/sdk/AbstractNamespace.d.ts
 /**
  * One read of a combined namespace: the same query against each source, plus