@gearbox-protocol/sdk 16.0.0-next.9 → 16.1.0

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

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

@@ -1,13 +1,15 @@
 import { NetworkType } from "../onchain/chain/chains.js";
 import "../onchain/index.js";
-import { GearboxSDKOptions, Mode, NoticesByMode, OffchainByMode, OnchainByMode } from "./types.js";
-import { LiquidationsByMode } from "./liquidations/types.js";
+import { IAnalyticsByMode } from "./analytics/types.js";
+import { ILiquidationsByMode } from "./liquidations/types.js";
+import { IOpportunities } from "./opportunities/types.js";
+import { IPositions } from "./positions/types.js";
+import { IPreviewByMode } from "./preview/types.js";
+import { GearboxSDKOptions, IGearboxSDK, INoticesByMode, Mode, OffchainByMode, OnchainByMode } from "./types.js";
+import "./analytics/index.js";
 import "./liquidations/index.js";
-import { Opportunities } from "./opportunities/types.js";
 import "./opportunities/index.js";
-import { Positions } from "./positions/types.js";
 import "./positions/index.js";
-import { PreviewByMode } from "./preview/types.js";
 import "./preview/index.js";
 //#region src/sdk/GearboxSDK.d.ts
 /**
@@ -34,7 +36,7 @@ declare const DEFAULT_MAX_STATE_AGE = 30;
  *
  * @typeParam M - Mode the instance was built in.
  **/
-declare class GearboxSDK<const M extends Mode = Mode> {
+declare class GearboxSDK<const M extends Mode = Mode> implements IGearboxSDK<M> {
   #private;
   /**
    * Sources this instance reads from.
@@ -44,33 +46,35 @@ declare class GearboxSDK<const M extends Mode = Mode> {
    * Chains this instance covers, which every read is scoped to.
    **/
   readonly networks: readonly NetworkType[];
+  /** Protocol-wide analytics. Undefined in `onchain` mode. */
+  readonly analytics: IAnalyticsByMode[M];
   /**
    * Namespace for pool and strategy opportunities.
    **/
-  readonly opportunities: Opportunities<M>;
+  readonly opportunities: IOpportunities<M>;
   /**
    * Namespace for the positions a wallet holds.
    **/
-  readonly positions: Positions<M>;
+  readonly positions: IPositions<M>;
   /**
    * Namespace for liquidatable credit accounts and delayed-withdrawal
    * positions a liquidator holds. Onchain-only, hence gated by mode like
    * every other chain read: absent in `offchain` mode.
    **/
-  readonly liquidations: LiquidationsByMode[M];
+  readonly liquidations: ILiquidationsByMode[M];
   /**
    * Namespace for on-chain previews of raw operation calldata. Onchain-only,
    * hence gated by mode like every other chain read: absent in `offchain`
    * mode.
    **/
-  readonly preview: PreviewByMode[M];
+  readonly preview: IPreviewByMode[M];
   /**
    * The banners the backend attaches to a pool opportunity or a strategy
    * position, see {@link Notice}. Top-level because the subject is either
    * kind of entity, so neither namespace owns it. Backend-only, hence gated
    * by mode like every other backend read: absent in `onchain` mode.
    **/
-  readonly notices: NoticesByMode[M];
+  readonly notices: INoticesByMode[M];
   constructor(options: GearboxSDKOptions<M>);
   /**
    * Attaches the on-chain SDK when this instance owns one; a no-op in `offchain`

package/dist/types/sdk/analytics/AnalyticsNamespace.d.ts

@@ -0,0 +1,17 @@
+import { ChartBundle, ChartRange, ProtocolChartMetric } from "../../model/charts.js";
+import { ChainScopedFilter } from "../../model/filters.js";
+import { DataResponse } from "../../model/response.js";
+import { GearboxAPI } from "../../offchain/GearboxAPI.js";
+import "../../offchain/index.js";
+import { IAnalytics } from "./types.js";
+//#region src/sdk/analytics/AnalyticsNamespace.d.ts
+/** Backend-only protocol analytics exposed by {@link GearboxSDK}. */
+declare class AnalyticsNamespace implements IAnalytics {
+  #private;
+  readonly positions: GearboxAPI["analytics"]["positions"];
+  constructor(backend: GearboxAPI);
+  /** {@inheritDoc IAnalytics.charts} */
+  charts<const Metrics extends readonly ProtocolChartMetric[]>(metrics: Metrics, range: ChartRange, filter?: ChainScopedFilter): Promise<DataResponse<ChartBundle<Metrics>>>;
+}
+//#endregion
+export { AnalyticsNamespace };

package/dist/types/sdk/analytics/index.d.ts

@@ -0,0 +1,3 @@
+import { IAnalytics, IAnalyticsByMode } from "./types.js";
+import { AnalyticsNamespace } from "./AnalyticsNamespace.js";
+export { AnalyticsNamespace, IAnalytics, IAnalyticsByMode };

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

@@ -0,0 +1,31 @@
+import { ChartBundle, ChartRange, ProtocolChartMetric } from "../../model/charts.js";
+import { ChainScopedFilter } from "../../model/filters.js";
+import { DataResponse } from "../../model/response.js";
+import { IOffchainAnalyticsPositions } from "../../offchain/analytics/types.js";
+import "../../offchain/index.js";
+//#region src/sdk/analytics/types.d.ts
+/** Backend-only protocol analytics, grouped by subject. */
+interface IAnalytics {
+  readonly positions: IOffchainAnalyticsPositions;
+  /**
+   * Charts of the protocol as a whole: one series per metric named, onto the
+   * one grid that lets them be compared at an index.
+   *
+   * ```ts
+   * const { data } = await sdk.analytics.charts(["tvlUsd"], "1m");
+   * ```
+   *
+   * The series sums the chains the read covers, which are this instance's own
+   * narrowed by `filter` — so an SDK built for one chain charts that chain,
+   * not the protocol.
+   **/
+  charts<const Metrics extends readonly ProtocolChartMetric[]>(metrics: Metrics, range: ChartRange, filter?: ChainScopedFilter): Promise<DataResponse<ChartBundle<Metrics>>>;
+}
+/** `sdk.analytics` per mode: absent when the SDK has no backend source. */
+interface IAnalyticsByMode {
+  onchain: undefined;
+  offchain: IAnalytics;
+  both: IAnalytics;
+}
+//#endregion
+export { IAnalytics, IAnalyticsByMode };

package/dist/types/sdk/execute/ExecuteApi.d.ts

@@ -1,108 +1,19 @@
-import { ChainId } from "../../model/primitives.js";
-import "../../model/index.js";
-import { Asset } from "../../onchain/base/types.js";
-import { SecuritizeRegisterMessage } from "../../onchain/market/rwa/securitize/types.js";
 import { RawTx } from "../../onchain/types/transactions.js";
 import "../../onchain/index.js";
-import { LpSimulate, OpenStrategySimulate, StrategySimulate } from "../prepare/types.js";
 import { ChainOf } from "../prepare/PrepareApi.js";
 import "../prepare/index.js";
-import { Address } from "viem";
+import { IOpportunitiesExecute, PrepareRequest } from "./types.js";
 //#region src/sdk/execute/ExecuteApi.d.ts
 /**
- * A pool deposit, withdrawal or redemption, as
- * {@link OpportunitiesPrepare.deposit} / {@link OpportunitiesPrepare.withdraw}
- * / {@link OpportunitiesPrepare.redeem} priced it. The simulation carries the
- * tokens on both sides and the zapper, so nothing else is needed to encode
- * the call.
+ * {@inheritDoc IOpportunitiesExecute}
  **/
-interface PoolPrepareRequest {
-  kind: "pool";
-  chainId: ChainId;
-  pool: Address;
-  wallet: Address;
-  op: "deposit" | "withdraw" | "redeem";
-  sim: Extract<LpSimulate, {
-    ok: true;
-  }>;
-}
-/**
- * Opening a new position, from a viable
- * {@link OpportunitiesPrepare.openNewStrategy} result. The preview values
- * collateral in underlying only, so the wallet's actual collateral assets and
- * the native value to attach come from the caller.
- **/
-interface OpenPrepareRequest {
-  kind: "open";
-  chainId: ChainId;
-  creditManager: Address;
-  wallet: Address;
-  sim: Extract<OpenStrategySimulate, {
-    ok: true;
-  }>;
-  /** What leaves the wallet, token by token. */
-  collateral: Asset[];
-  /** Native value to attach when paying a wrapped-native market in the coin. */
-  ethAmount: bigint;
-  /**
-   * Token the position ends up in. RWA markets resolve their open
-   * requirements against it; omitting it skips the RWA check entirely.
-   **/
-  targetToken?: Address;
-  /**
-   * EIP-712 registration signatures the wallet already signed this session,
-   * attached as `signaturesToCache` when the market is RWA-gated.
-   **/
-  signaturesToCache?: SecuritizeRegisterMessage[];
-}
-/**
- * Any of the five operations on an existing account, from a viable
- * {@link StrategySimulate}: the facade multicall is the simulation's `calls`.
- **/
-interface AccountPrepareRequest {
-  kind: "account";
-  chainId: ChainId;
-  creditAccount: Address;
-  wallet: Address;
-  sim: Extract<StrategySimulate, {
-    ok: true;
-  }>;
-}
-/**
- * What {@link OpportunitiesExecute.buildTx} turns into a transaction: a
- * `prepare` result plus the few facts about the wallet the simulation does not
- * carry.
- **/
-type PrepareRequest = PoolPrepareRequest | OpenPrepareRequest | AccountPrepareRequest;
-/**
- * The write side of the opportunities namespace: turns what `prepare`
- * answered into the transaction to sign. Sending, and whatever the wallet has
- * to do first (allowances, permits, RWA signatures), stays with the caller —
- * `checkPrerequisites` reports the former on the built transaction.
- **/
-interface OpportunitiesExecute {
-  /**
-   * The transaction to sign, from a `prepare` result. No second round of math:
-   * `account` requests submit the simulation's own multicall, `open` requests
-   * hand the preview's router path and quotas to `openCA`, `pool` requests
-   * encode the deposit / redeem the simulation priced.
-   *
-   * @throws on a simulation that is not `ok`; when a `pool` request names a
-   * route the pool has no metadata for, or one the pool does not accept a
-   * transaction for (RWA on-demand deposits)
-   **/
-  buildTx(request: PrepareRequest): Promise<RawTx>;
-}
-/**
- * {@inheritDoc OpportunitiesExecute}
- **/
-declare class ExecuteApi implements OpportunitiesExecute {
+declare class ExecuteApi implements IOpportunitiesExecute {
   #private;
   constructor(chainOf: ChainOf);
   /**
-   * {@inheritDoc OpportunitiesExecute.buildTx}
+   * {@inheritDoc IOpportunitiesExecute.buildTx}
    **/
   buildTx(request: PrepareRequest): Promise<RawTx>;
 }
 //#endregion
-export { AccountPrepareRequest, ExecuteApi, OpenPrepareRequest, OpportunitiesExecute, PoolPrepareRequest, PrepareRequest };
+export { ExecuteApi };

package/dist/types/sdk/execute/index.d.ts

@@ -1,2 +1,3 @@
-import { AccountPrepareRequest, ExecuteApi, OpenPrepareRequest, OpportunitiesExecute, PoolPrepareRequest, PrepareRequest } from "./ExecuteApi.js";
-export { AccountPrepareRequest, ExecuteApi, OpenPrepareRequest, OpportunitiesExecute, PoolPrepareRequest, PrepareRequest };
+import { AccountPrepareRequest, IOpportunitiesExecute, OpenPrepareRequest, PoolPrepareRequest, PrepareRequest } from "./types.js";
+import { ExecuteApi } from "./ExecuteApi.js";
+export { AccountPrepareRequest, ExecuteApi, IOpportunitiesExecute, OpenPrepareRequest, PoolPrepareRequest, PrepareRequest };

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

@@ -0,0 +1,91 @@
+import { ChainId } from "../../model/primitives.js";
+import { SDKResult } from "../../model/result.js";
+import "../../model/index.js";
+import { Asset } from "../../onchain/base/types.js";
+import { SecuritizeRegisterMessage } from "../../onchain/market/rwa/securitize/types.js";
+import { RawTx } from "../../onchain/types/transactions.js";
+import "../../onchain/index.js";
+import { LpResult, OpenStrategyResult, StrategyResult } from "../prepare/types.js";
+import "../prepare/index.js";
+import { Address } from "viem";
+//#region src/sdk/execute/types.d.ts
+/**
+ * A pool deposit, withdrawal or redemption, as
+ * {@link IOpportunitiesPrepare.deposit} / {@link IOpportunitiesPrepare.withdraw}
+ * / {@link IOpportunitiesPrepare.redeem} priced it. The prepared state carries
+ * the tokens on both sides and the zapper, so nothing else is needed to encode
+ * the call.
+ **/
+interface PoolPrepareRequest {
+  kind: "pool";
+  chainId: ChainId;
+  pool: Address;
+  wallet: Address;
+  op: "deposit" | "withdraw" | "redeem";
+  sim: SDKResult<LpResult>;
+}
+/**
+ * Opening a new position, from a viable
+ * {@link IOpportunitiesPrepare.openNewStrategy} result. The prepared state
+ * values collateral in underlying only, so the wallet's actual collateral
+ * assets and the native value to attach come from the caller.
+ **/
+interface OpenPrepareRequest {
+  kind: "open";
+  chainId: ChainId;
+  creditManager: Address;
+  wallet: Address;
+  sim: SDKResult<OpenStrategyResult>;
+  /** What leaves the wallet, token by token. */
+  collateral: Asset[];
+  /** Native value to attach when paying a wrapped-native market in the coin. */
+  ethAmount: bigint;
+  /**
+   * Token the position ends up in. RWA markets resolve their open
+   * requirements against it; omitting it skips the RWA check entirely.
+   **/
+  targetToken?: Address;
+  /**
+   * EIP-712 registration signatures the wallet already signed this session,
+   * attached as `signaturesToCache` when the market is RWA-gated.
+   **/
+  signaturesToCache?: SecuritizeRegisterMessage[];
+}
+/**
+ * Any of the five operations on an existing account, from a viable
+ * {@link StrategyResult}: the facade multicall is the result's `calls`.
+ **/
+interface AccountPrepareRequest {
+  kind: "account";
+  chainId: ChainId;
+  creditAccount: Address;
+  wallet: Address;
+  sim: SDKResult<StrategyResult>;
+}
+/**
+ * What {@link IOpportunitiesExecute.buildTx} turns into a transaction: a
+ * `prepare` result plus the few facts about the wallet the preparation does not
+ * carry.
+ **/
+type PrepareRequest = PoolPrepareRequest | OpenPrepareRequest | AccountPrepareRequest;
+/**
+ * The write side of the opportunities namespace: turns what `prepare`
+ * answered into the transaction to sign. Sending, and whatever the wallet has
+ * to do first (allowances, permits, RWA signatures), stays with the caller —
+ * `checkPrerequisites` reports the former on the built transaction.
+ **/
+interface IOpportunitiesExecute {
+  /**
+   * The transaction to sign, from a `prepare` result. No second round of math:
+   * `account` requests submit the result's own multicall, `open` requests hand
+   * the state's router path and quotas to `openCA`, `pool` requests encode the
+   * deposit / redeem the result priced.
+   *
+   * @throws on a refused `prepare` result; when a `pool` request names a route
+   * the pool has no metadata for, or one the pool does not accept a transaction
+   * for (RWA on-demand deposits)
+   **/
+  buildTx(request: PrepareRequest): Promise<RawTx>;
+}
+//#endregion
+export { AccountPrepareRequest, IOpportunitiesExecute, OpenPrepareRequest, PoolPrepareRequest, PrepareRequest };