@gearbox-protocol/sdk 16.0.0-next.4 → 16.0.0-next.40

package/dist/types/model/previews.d.ts

@@ -1,10 +1,11 @@
-import { Bps, ChainId, Leverage, TokenAmount } from "./primitives.js";
+import { Bps, ChainId, Leverage, Timestamp, Token, TokenAmount, UnderlyingToken } from "./primitives.js";
+import { Curator } from "./curators.js";
 import { DelayedIntent } from "./delayed-intents.js";
 import { BorrowRateBreakdown } from "./positions.js";
 import { Address, Hex } from "viem";
 //#region src/model/previews.d.ts
 /**
- * ERC4626 pool operation kind, as surfaced on a {@link PoolOperationPreview}.
+ * ERC4626 pool operation kind, as surfaced on a {@link PoolPositionOperationPreview}.
  **/
 type PoolOperationType = "Deposit" | "Mint" | "Withdraw" | "Redeem";
 /**
@@ -64,9 +65,10 @@ declare const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
  **/
 declare const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
 /**
- * Out-of-bracket RWA wrap/unwrap calldata cannot be decoded
+ * An out-of-bracket adapter call that is allowed there (e.g. RWA wrap/unwrap)
+ * could not be decoded or replayed
  **/
-declare const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
+declare const ERROR_UNSUPPORTED_OUT_OF_BRACKET_CALL = 1005;
 /**
  * `msg.value` does not fit into the declared WETH collateral
  * Transactions can have arbitrary value, but the ones that we create
@@ -95,7 +97,12 @@ interface OperationPreviewError {
    */
   message: string;
 }
-interface PoolOperationPreview {
+/**
+ * What a pool transaction that already exists would do — the counterpart of
+ * `prepare.deposit`, `prepare.withdraw` and `prepare.redeem`, read off calldata
+ * rather than planned into it.
+ **/
+interface PoolPositionOperationPreview {
   operation: PoolOperationType;
   /**
    * Pool address
@@ -105,6 +112,13 @@ interface PoolOperationPreview {
    * Human-readable pool name
    */
   name: string;
+  /**
+   * Pool underlying token.
+   *
+   * For RWA markets this is the unwrapped asset, e.g. USDC rather than
+   * dcUSDC (the pool's on-chain underlying). Same as {@link PoolPosition.underlyingToken}.
+   */
+  underlyingToken: UnderlyingToken;
   /**
    * Token that goes from user to pool
    * In case of deposit, underlying for direct deposit, zapper input for zapper-routed deposit
@@ -136,100 +150,119 @@ interface PoolOperationPreview {
    */
   error?: OperationPreviewError;
 }
-interface OpenCreditAccountPreview {
-  operation: "OpenCreditAccount" | "RWAOpenCreditAccount";
-  /**
-   * Health factor in basis points: below `10000` the account is liquidatable.
-   *
-   * @example `12500` for a health factor of 1.25
-   **/
-  healthFactor: Bps;
-  /**
-   * Cost of the debt, broken down by source.
-   **/
-  borrowRate: BorrowRateBreakdown;
-  /**
-   * Estimated milliseconds until the health factor decays to `10000` under
-   * the current borrow rate, or `null` when the debt carries no rate (or the
-   * account is already liquidatable).
-   **/
-  timeToLiquidation: bigint | null;
-  /**
-   * Price of the single non-underlying collateral at which the account
-   * becomes liquidatable, in the oracle's 8-decimal fixed point, or `null`
-   * when the account holds zero or several non-underlying assets.
-   **/
-  liquidationPrice: bigint | null;
-  /**
-   * Total-value leverage: `totalValue / (totalValue − totalDebt)`. `1` =
-   * unleveraged; `0` if underwater.
-   **/
-  leverage: Leverage;
+/**
+ * The market a credit operation acts on, reported the same way by every half of
+ * the SDK: the calldata previews, the intents engine's projections, the
+ * open-strategy walk and the liquidatable-account rows all carry it, so a screen
+ * naming the market needs nothing beside the result it already holds.
+ **/
+interface CreditOperationMarket {
   /**
-   * Credit manager the account is opened in
+   * Credit manager the account belongs to. Carried on the result itself so a
+   * caller weighing one — `checkSimulation` among them — needs nothing beside
+   * it to find the market.
    */
   creditManager: Address;
   /**
-   * Human-readable credit manager name
+   * Human-readable strategy name, e.g. `"wstETH / WETH"`. Same as
+   * {@link StrategyPosition.name}
    */
   name: string;
   /**
-   * Target token of strategy: the first quoted token, with its balance taken
-   * from `assets`. Undefined when nothing is quoted.
-   */
-  target?: TokenAmount;
-  /**
-   * Tokens that were added as collateral during account opening.
+   * Pool underlying token.
    *
-   * When the transaction has native value attached, it is represented as a
-   * `NATIVE_ADDRESS` entry, with the wrapped native token amount reduced
-   * accordingly (omitted entirely when it reaches zero).
+   * For RWA markets this is the unwrapped asset, e.g. USDC rather than
+   * dcUSDC (the pool's on-chain underlying). Same as
+   * {@link StrategyPosition.underlyingToken}.
    */
-  collateral: TokenAmount[];
+  underlyingToken: UnderlyingToken;
   /**
-   * Sum of collateral tokens in underlying
+   * Curator of the market {@link creditManager} belongs to, in the same shape
+   * {@link StrategyOpportunity} reports it: the market configurator's address,
+   * plus the display name and the page a screen labels it with when the
+   * configurator is a known one.
    */
-  collateralValue: bigint;
+  curator: Curator;
   /**
-   * Total account value after opening: collateral plus borrowed amount, in
-   * underlying.
+   * What a liquidation takes off the account, in basis points: the premium the
+   * liquidator keeps plus the protocol's own fee.
+   *
+   * Not the credit manager's `liquidationDiscount`, which is the complement of
+   * the premium alone (`100% - liquidationPremium`) and says what share of the
+   * collateral repays the debt. This is the figure a position screen labels
+   * "Liquidation Discount": `liquidationPremium + feeLiquidation`.
    */
-  totalValue: bigint;
+  liquidationDiscount: Bps;
+}
+/**
+ * What an account is worth and what it is made of, once an operation has run.
+ *
+ * The measured half of a {@link AccountProjection}: read off the balances the
+ * walk arrived at, without a formula between them and the answer.
+ **/
+interface AccountHoldings {
   /**
-   * Borrowed amount in underlying
-   */
-  debt: bigint;
+   * Everything the account holds, denominated in the market's underlying.
+   **/
+  totalValue: TokenAmount;
   /**
-   * WARNING: unlike every other `TokenAmount` in this model, `value` is
-   * denominated in the market underlying, NOT in `token`. `token` only
-   * identifies which collateral the quota applies to; `valueUsd` prices the
-   * underlying amount.
-   *
-   * Desired quotas
-   */
-  quotas: TokenAmount[];
+   * What it would take to settle the loan: principal plus accrued interest and
+   * fees, in the market's underlying.
+   **/
+  totalDebt: TokenAmount;
   /**
-   * Minimum amount of assets on credit account after it's opened,
-   * as estimated by router
-   */
+   * Own funds in the position: `totalValue` less `totalDebt`, in the market's
+   * underlying. The read model leaves a strategy caller to subtract these two
+   * itself; a projection reports the figure so an "own funds" row reads the
+   * same on every screen that shows one.
+   **/
+  netValue: TokenAmount;
+  /**
+   * What the account holds, token by token.
+   **/
   assets: TokenAmount[];
   /**
-   * Set when preview encountered non-fatal errors, all fields are
-   * still computed best-effort, but derived fields (`assets`, `target`,
-   * `collateralValue`) may be unreliable in that case.
-   */
-  error?: OperationPreviewError;
+   * Quota bought for each collateral, denominated in the market's underlying
+   * rather than in the collateral token — the same convention as
+   * {@link PositionCollateral.quota}. A token the account leaves unquoted is
+   * absent rather than present at zero.
+   **/
+  quotas: TokenAmount[];
 }
-interface AdjustCreditAccountPreview {
-  operation: "AdjustCreditAccount";
+/**
+ * The risk and cost of an account, derived from what it holds.
+ *
+ * The computed half of a {@link AccountProjection}, and the reason it is a type
+ * of its own: every one of these is a formula over the same
+ * {@link AccountSnapshot}, so both halves of the SDK get them from one place —
+ * `sdk.positions.metrics` — and cannot drift into two answers for one account.
+ **/
+interface AccountMetrics {
   /**
    * Health factor in basis points: below `10000` the account is liquidatable.
    *
    * @example `12500` for a health factor of 1.25
    **/
   healthFactor: Bps;
+  /**
+   * The same factor with collateral valued at safe prices — the lower of each
+   * token's main and reserve oracle feeds, which is what the credit manager
+   * switches to for a call that hands funds over.
+   *
+   * Always reported, whether or not the operation in question hands anything
+   * over: which of the two factors decides a transaction is a property of the
+   * call the caller ends up sending, and a screen showing the account is
+   * entitled to both.
+   *
+   * @example `11800` where `healthFactor` is `12500`
+   **/
+  safeHealthFactor: Bps;
   /**
    * Cost of the debt, broken down by source.
+   *
+   * Half of the breakdown rests on the debt and the quotas alone (`base`,
+   * `totalOnDebt`) and half on the position's value (`total`, `quotas[].rate`),
+   * which is why it counts as a {@link RoutedField}.
    **/
   borrowRate: BorrowRateBreakdown;
   /**
@@ -249,18 +282,116 @@ interface AdjustCreditAccountPreview {
    * unleveraged; `0` if underwater.
    **/
   leverage: Leverage;
+}
+/**
+ * A credit account as an operation leaves it, answered by both halves of the
+ * SDK: `prepare`, which walks a request forward into the calls that realise it,
+ * and `preview`, which decodes calls that already exist and replays them back.
+ *
+ * Both answer in this same vocabulary, and from the same builder
+ * (`sdk.positions.projection`), so the two descriptions of one operation can be
+ * compared field by field — which is what
+ * `previewMatchesPrepare.test.ts` does.
+ *
+ * This shape is the expected branch of a routed leg, which is what `prepare`
+ * reports; `preview` sees only the floor and answers with an
+ * {@link EstimatedProjection}, the same fields with the routed ones marked
+ * `est`. Where nothing routes the two coincide exactly.
+ *
+ * `totalDebt`, `totalValue`, `leverage` and `healthFactor` mean here exactly
+ * what they mean on a {@link StrategyPosition}, down to the token an amount
+ * names — an RWA market reports USDC, not the dcUSDC wrapper the pool holds.
+ **/
+interface AccountProjection extends CreditOperationMarket, AccountHoldings, AccountMetrics {}
+/**
+ * The fields of an {@link AccountProjection} a routed leg's outcome decides.
+ *
+ * A swap is quoted twice: the amount the pathfinder expects to return, and the
+ * floor it is willing to guarantee once slippage is allowed for. `prepare` has
+ * both and reports the expected one — that is where the position lands.
+ * `preview` reads a transaction that already exists, and calldata carries only
+ * the floor, so its answer is the worst case the same operation can settle at.
+ *
+ * Everything not listed here is the same number on either branch: the debt and
+ * the quotas are named by the calls themselves.
+ *
+ * The borrow rate is listed despite being half made of those two. `base` and
+ * `totalOnDebt` are branch-independent — the pool's rate at the projected
+ * utilization, and the quota rates over the debt — but `total` and the per-token
+ * `quotas[].rate` normalize against `totalValue`, so a floor-branch breakdown
+ * quotes the same cost against a smaller position and comes out higher. One
+ * field cannot be half prefixed, and the half that moves is the half a screen
+ * shows, so the whole breakdown carries the marker.
+ **/
+type RoutedField = "totalValue" | "netValue" | "assets" | "healthFactor" | "safeHealthFactor" | "borrowRate" | "timeToLiquidation" | "liquidationPrice" | "leverage";
+/**
+ * `x` becomes `estX`, for a projection assembled from the guaranteed floor.
+ *
+ * The prefix is not decoration: an `estHealthFactor` and a `healthFactor` are
+ * answers to different questions, and naming them alike would invite a screen
+ * to show one as the other or a test to hold them equal.
+ **/
+type Estimated<T> = { [K in keyof T as `est${Capitalize<string & K>}`]: T[K]; };
+/**
+ * A projection as `preview` can answer it: the branch-independent half under the
+ * shared names, and everything a route decides marked `est`.
+ *
+ * Same builder, same formulas, same units as an {@link AccountProjection} — only
+ * the snapshot underneath is the floor rather than the expected outcome.
+ **/
+type EstimatedProjection = Omit<AccountProjection, RoutedField> & Estimated<Pick<AccountProjection, RoutedField>>;
+/**
+ * Renames a projection's routed fields, for a caller that built one from floor
+ * balances.
+ *
+ * Lives beside the type so the two cannot drift: a field added to
+ * {@link RoutedField} fails to compile until it is renamed here too.
+ **/
+declare function asEstimated(p: AccountProjection): EstimatedProjection;
+/**
+ * What an operation moved, as opposed to where it left the account.
+ *
+ * Only `preview` reports these: it is handed both sides of the transaction and
+ * diffs them, while `prepare` is asked to reach a state and answers with the
+ * calls that get there. Split out so the two halves agree on the names for the
+ * day prepare reports deltas too.
+ **/
+interface AccountStateChange {
   /**
-   * Credit manager the account is opened in
+   * Debt after minus debt before. A repayment settles interest and fees
+   * before principal, so this is the payment itself rather than the part of
+   * it the principal happened to absorb.
    */
-  creditManager: Address;
+  totalDebtChange: TokenAmount;
   /**
-   * Human-readable credit manager name
+   * Quotas after minus quotas before. Denominated in the market's underlying
+   * like {@link AccountHoldings.quotas}, so `token` names the collateral the
+   * quota applies to rather than the amount's own unit.
    */
-  name: string;
+  quotasChange: TokenAmount[];
   /**
-   * Credit account that is being adjusted
+   * Assets after minus assets before.
+   *
+   * Unprefixed despite resting on the same floor balances as
+   * {@link EstimatedProjection.estAssets}: `prepare` reports no deltas at all,
+   * so there is no expected-branch figure of this name to be mistaken for.
    */
-  creditAccount: Address;
+  assetsChange: TokenAmount[];
+}
+/**
+ * What an account-opening transaction that already exists would do — the
+ * counterpart of `prepare.openNewStrategy`, read off calldata rather than
+ * planned into it.
+ **/
+interface OpenStrategyPositionPreview extends EstimatedProjection {
+  operation: "OpenCreditAccount" | "RWAOpenCreditAccount";
+  /**
+   * Collateral token this position is a strategy in: the first quoted token,
+   * with its balance taken from `estAssets` — so, like them, the floor the
+   * route guarantees rather than what it expects to return.
+   * Undefined when nothing is quoted.
+   */
+  targetCollateral?: TokenAmount;
   /**
    * Tokens that were added as collateral during account opening.
    *
@@ -270,52 +401,41 @@ interface AdjustCreditAccountPreview {
    */
   collateralAdded: TokenAmount[];
   /**
-   * Tokens that were withdrawn as collateral during account adjustment.
-   */
-  collateralWithdrawn: TokenAmount[];
-  /**
-   * Sum of collateral tokens in underlying
-   */
-  totalValue: bigint;
-  /**
-   * What the account owes in underlying once the operation lands: principal
-   * plus accrued interest and fees, which is the amount it would take to
-   * settle the loan — the same quantity `prepare` projects as `accountDebt`.
+   * Set when preview encountered non-fatal errors, all fields are
+   * still computed best-effort, but derived fields (`estAssets`,
+   * `targetCollateral`, `estNetValue`) may be unreliable in that case.
    */
-  debt: bigint;
+  error?: OperationPreviewError;
+}
+/**
+ * What a transaction on an existing account would do — the counterpart of the
+ * `prepare` flows that adjust one (`depositStrategy`, `withdrawStrategy`,
+ * `addCollateral`, `withdrawCollateral`, `adjustLeverage`), read off calldata
+ * rather than planned into it.
+ **/
+interface AdjustStrategyPositionPreview extends EstimatedProjection, AccountStateChange {
+  operation: "AdjustCreditAccount";
   /**
-   * Debt after minus debt before. A repayment settles interest and fees
-   * before principal, so this is the payment itself rather than the part of
-   * it the principal happened to absorb.
+   * Credit account that is being adjusted
    */
-  debtChange: bigint;
+  creditAccount: Address;
   /**
-   * WARNING: unlike every other `TokenAmount` in this model, `value` is
-   * denominated in the market underlying, NOT in `token`. `token` only
-   * identifies which collateral the quota applies to; `valueUsd` prices the
-   * underlying amount.
-   *
-   * Desired quotas
+   * Collateral token this position is a strategy in. Same as
+   * {@link StrategyPosition.targetCollateral}
    */
-  quotas: TokenAmount[];
+  targetCollateral: Token | null;
   /**
-   * WARNING: unlike every other `TokenAmount` in this model, `value` is
-   * denominated in the market underlying, NOT in `token`. `token` only
-   * identifies which collateral the quota applies to; `valueUsd` prices the
-   * underlying amount.
+   * Tokens that were added as collateral during account opening.
    *
-   * Quotas after minus quotas before
-   */
-  quotasChange: TokenAmount[];
-  /**
-   * Minimum amount of assets on credit account after the operation,
-   * as estimated by router
+   * When the transaction has native value attached, it is represented as a
+   * `NATIVE_ADDRESS` entry, with the wrapped native token amount reduced
+   * accordingly (omitted entirely when it reaches zero).
    */
-  assets: TokenAmount[];
+  collateralAdded: TokenAmount[];
   /**
-   * Assets after minus assets before
+   * Tokens that were withdrawn as collateral during account adjustment.
    */
-  assetsChange: TokenAmount[];
+  collateralWithdrawn: TokenAmount[];
   /**
    * Intent of the delayed withdrawal this transaction claims; set when the
    * multicall claims a delayed withdrawal
@@ -323,12 +443,21 @@ interface AdjustCreditAccountPreview {
   intent?: DelayedIntent;
   /**
    * Set when preview encountered non-fatal errors, all fields are
-   * still computed best-effort, but derived fields (`assets`, `assetsChange`,
-   * `totalValue`) may be unreliable in that case.
+   * still computed best-effort, but derived fields (`estAssets`, `assetsChange`,
+   * `estTotalValue`) may be unreliable in that case.
    */
   error?: OperationPreviewError;
 }
-interface CloseCreditAccountPreview {
+/**
+ * What an exit transaction that already exists would do — the counterpart of
+ * `prepare.withdrawStrategy` asked for everything, read off calldata rather
+ * than planned into it.
+ *
+ * Carries no {@link AccountProjection}: the account it describes ends up empty,
+ * so there is no position left to weigh — what a caller wants to know is the
+ * payout. The market it happened in is still named, as everywhere else.
+ **/
+interface ExitStrategyPositionPreview extends CreditOperationMarket {
   operation: "CloseCreditAccount";
   /**
    * True when the account is closed permanently (facade `closeCreditAccount`
@@ -336,18 +465,15 @@ interface CloseCreditAccountPreview {
    * (plain multicall).
    */
   permanent: boolean;
-  /**
-   * Credit manager the account belongs to
-   */
-  creditManager: Address;
-  /**
-   * Human-readable credit manager name
-   */
-  name: string;
   /**
    * Credit account that is being closed
    */
   creditAccount: Address;
+  /**
+   * Collateral token this position is a strategy in. Same as
+   * {@link StrategyPosition.targetCollateral}
+   */
+  targetCollateral: Token | null;
   /**
    * Token withdrawn to the user and its minimal guaranteed amount, from the
    * multicall replay (all collateral is swapped into the received token
@@ -368,7 +494,15 @@ interface CloseCreditAccountPreview {
    */
   error?: OperationPreviewError;
 }
-interface RepayCreditAccountPreview {
+/**
+ * What a settling repayment that already exists would do — the counterpart of
+ * `prepare.repayStrategy` asked for the whole debt, read off calldata rather
+ * than planned into it.
+ *
+ * Carries no {@link AccountProjection} for the same reason the exit does not:
+ * the loan ends here, so the risk metrics have nothing left to describe.
+ **/
+interface RepayStrategyPositionPreview extends CreditOperationMarket {
   operation: "RepayCreditAccount";
   /**
    * True when the account is closed permanently (facade `closeCreditAccount`
@@ -376,18 +510,15 @@ interface RepayCreditAccountPreview {
    * (plain multicall).
    */
   permanent: boolean;
-  /**
-   * Credit manager the account belongs to
-   */
-  creditManager: Address;
-  /**
-   * Human-readable credit manager name
-   */
-  name: string;
   /**
    * Credit account that is being repaid
    */
   creditAccount: Address;
+  /**
+   * Collateral token this position is a strategy in. Same as
+   * {@link StrategyPosition.targetCollateral}
+   */
+  targetCollateral: Token | null;
   /**
    * Tokens added from the wallet to cover the debt (`addCollateral` calls).
    *
@@ -402,9 +533,13 @@ interface RepayCreditAccountPreview {
    */
   collateralWithdrawn: TokenAmount[];
   /**
-   * Total debt repaid: principal + accrued interest + fees, in underlying
+   * Total debt repaid: principal + accrued interest + fees, in underlying.
+   *
+   * The same quantity a {@link AdjustStrategyPositionPreview} reports as
+   * `totalDebtChange`, with the sign a repayment screen reads: positive for
+   * what the wallet parted with.
    */
-  debtRepaid: bigint;
+  debtRepaid: TokenAmount;
   /**
    * Intent of the delayed withdrawal this transaction claims; set when the
    * multicall claims a delayed withdrawal
@@ -422,49 +557,52 @@ interface RepayCreditAccountPreview {
  * account: what the transaction does in the same block, before any delayed
  * withdrawal is claimed.
  */
-type InstantOperationPreview = AdjustCreditAccountPreview | CloseCreditAccountPreview | RepayCreditAccountPreview;
+type InstantStrategyPositionOperationPreview = AdjustStrategyPositionPreview | ExitStrategyPositionPreview | RepayStrategyPositionPreview;
 /**
  * Preview of a multicall that requests a delayed withdrawal (e.g. Securitize
  * redemption): the source token is spent now and a withdrawal phantom token is received;
  * the actual claim token materializes later, when the withdrawal is claimed and
  * the recorded (if any) is resumed
  */
-interface DelayedCreditAccountOperationPreview {
+interface DelayedStrategyPositionOperationPreview extends CreditOperationMarket {
   operation: "DelayedCreditAccountOperation";
   /**
    * Credit account the operation is performed on
    */
   creditAccount: Address;
   /**
-   * Credit manager the account belongs to
+   * Collateral token this position is a strategy in. Same as
+   * {@link StrategyPosition.targetCollateral}
    */
-  creditManager: Address;
-  /**
-   * Human-readable credit manager name
-   */
-  name: string;
+  targetCollateral: Token | null;
   /**
    * Decoded from the withdrawal request's extraData; undefined when the
    * request carries no intent (e.g. Mellow)
    */
   intent?: DelayedIntent;
+  /**
+   * Estimated unix timestamp (seconds) when the delayed outputs become
+   * claimable: `now + withdrawalLength` of phantom token.
+   * Undefined when the compressor has no information about the asset.
+   */
+  estClaimableAt?: Timestamp;
   /**
    * What this transaction does right now: the delayed withdrawal is
    * represented by the phantom token among the account's assets
    */
-  instantPreview: InstantOperationPreview;
+  instantPreview: InstantStrategyPositionOperationPreview;
   /**
    * Best-effort state after the withdrawal is claimed and the intent is
    * resumed; claim-only (phantom burned, claim token received) when
    * `intent` is undefined
    */
-  delayedPreview: InstantOperationPreview;
+  delayedPreview: InstantStrategyPositionOperationPreview;
 }
 /**
  * Result of previewing a raw operation calldata: currently pool operations and
  * credit account opening, adjustment, closure, repayment and delayed
  * withdrawal operations are supported.
  */
-type OperationPreview = PoolOperationPreview | OpenCreditAccountPreview | AdjustCreditAccountPreview | CloseCreditAccountPreview | RepayCreditAccountPreview | DelayedCreditAccountOperationPreview;
+type OperationPreview = PoolPositionOperationPreview | OpenStrategyPositionPreview | AdjustStrategyPositionPreview | ExitStrategyPositionPreview | RepayStrategyPositionPreview | DelayedStrategyPositionOperationPreview;
 //#endregion
-export { AdjustCreditAccountPreview, CloseCreditAccountPreview, DelayedCreditAccountOperationPreview, ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP, ERROR_UNPRICEABLE_TOKEN, InstantOperationPreview, OpenCreditAccountPreview, OperationPreview, OperationPreviewError, PoolOperationPreview, PoolOperationType, PreviewOperationInput, PreviewOperationOptions, RepayCreditAccountPreview };
+export { AccountHoldings, AccountMetrics, AccountProjection, AccountStateChange, AdjustStrategyPositionPreview, CreditOperationMarket, DelayedStrategyPositionOperationPreview, ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPRICEABLE_TOKEN, ERROR_UNSUPPORTED_OUT_OF_BRACKET_CALL, Estimated, EstimatedProjection, ExitStrategyPositionPreview, InstantStrategyPositionOperationPreview, OpenStrategyPositionPreview, OperationPreview, OperationPreviewError, PoolOperationType, PoolPositionOperationPreview, PreviewOperationInput, PreviewOperationOptions, RepayStrategyPositionPreview, RoutedField, asEstimated };

package/dist/types/model/primitives.d.ts

@@ -156,6 +156,22 @@ interface Token {
    **/
   assetType?: AssetType;
 }
+/**
+ * A market's underlying as the shared read model describes it.
+ *
+ * For an RWA market this is the token the wrapper holds (e.g. USDC) rather
+ * than the wrapper itself (e.g. dcUSDC). The wrapper converts one-for-one, so
+ * amounts denominated in it stay exact; {@link wrappedAddress} names the
+ * wrapper when there is one.
+ **/
+interface UnderlyingToken extends Token {
+  /**
+   * Address of the compliance wrapper the pool actually holds (e.g. dcUSDC)
+   * when the market underlying is an RWA wrapper, or `null` when the
+   * underlying is the token itself.
+   **/
+  wrappedAddress: Address | null;
+}
 /**
  * An {@link Amount} that names its own token.
  **/
@@ -186,4 +202,4 @@ interface TxCall {
   value?: bigint;
 }
 //#endregion
-export { Amount, Asset, AssetType, Bps, ChainId, Leverage, Timestamp, Token, TokenAmount, TxCall };
+export { Amount, Asset, AssetType, Bps, ChainId, Leverage, Timestamp, Token, TokenAmount, TxCall, UnderlyingToken };

package/dist/types/model/primitives.schema.d.ts

@@ -47,6 +47,18 @@ declare const tokenSchema: z.ZodObject<{
   decimals: z.ZodNumber;
   assetType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>>;
 }, z.core.$strip>;
+/**
+ * {@link UnderlyingToken}
+ **/
+declare const underlyingTokenSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  address: z.ZodCodec<z.ZodString, z.ZodCustom<`0x${string}`, `0x${string}`>>;
+  symbol: z.ZodString;
+  name: z.ZodString;
+  decimals: z.ZodNumber;
+  assetType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>>;
+  wrappedAddress: z.ZodNullable<z.ZodCodec<z.ZodString, z.ZodCustom<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
 /**
  * {@link TokenAmount}
  **/
@@ -71,4 +83,4 @@ declare const txCallSchema: z.ZodObject<{
   value: z.ZodOptional<z.ZodCodec<z.ZodUnion<[z.ZodString, z.ZodBigInt]>, z.ZodBigInt>>;
 }, z.core.$strip>;
 //#endregion
-export { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema };
+export { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema, underlyingTokenSchema };