@uniswap/client-trading 0.6.1 → 0.8.0

package/dist/trading/v1/api_pb.d.ts

@@ -713,6 +713,105 @@ export declare enum MarginVenue {
      */
     AAVE_V4 = 2
 }
+/**
+ * Echoed on the response so a client can tell which action was priced without
+ * re-deriving it from the request. Mirrors the request's oneof exactly.
+ * Named intent to match the error codes (INTENT_MISMATCH) and the plan step
+ * vocabulary, so one word is used end to end.
+ *
+ * @generated from enum trading.v1.MarginIntent
+ */
+export declare enum MarginIntent {
+    /**
+     * @generated from enum value: MARGIN_INTENT_OPEN = 0;
+     */
+    OPEN = 0,
+    /**
+     * @generated from enum value: MARGIN_INTENT_CLOSE = 1;
+     */
+    CLOSE = 1,
+    /**
+     * @generated from enum value: MARGIN_INTENT_INCREASE_LEVERAGE = 2;
+     */
+    INCREASE_LEVERAGE = 2,
+    /**
+     * @generated from enum value: MARGIN_INTENT_DECREASE_LEVERAGE = 3;
+     */
+    DECREASE_LEVERAGE = 3,
+    /**
+     * @generated from enum value: MARGIN_INTENT_ADD_EQUITY = 4;
+     */
+    ADD_EQUITY = 4,
+    /**
+     * @generated from enum value: MARGIN_INTENT_WITHDRAW_EQUITY = 5;
+     */
+    WITHDRAW_EQUITY = 5,
+    /**
+     * @generated from enum value: MARGIN_INTENT_ADD_EQUITY_AND_INCREASE_LEVERAGE = 6;
+     */
+    ADD_EQUITY_AND_INCREASE_LEVERAGE = 6,
+    /**
+     * @generated from enum value: MARGIN_INTENT_ADD_EQUITY_AND_DECREASE_LEVERAGE = 7;
+     */
+    ADD_EQUITY_AND_DECREASE_LEVERAGE = 7,
+    /**
+     * @generated from enum value: MARGIN_INTENT_WITHDRAW_EQUITY_AND_INCREASE_LEVERAGE = 8;
+     */
+    WITHDRAW_EQUITY_AND_INCREASE_LEVERAGE = 8,
+    /**
+     * @generated from enum value: MARGIN_INTENT_WITHDRAW_EQUITY_AND_DECREASE_LEVERAGE = 9;
+     */
+    WITHDRAW_EQUITY_AND_DECREASE_LEVERAGE = 9
+}
+/**
+ * One on-chain call inside the router's execute([...actions]) stream. The
+ * quote decomposes an action into these; the plan stamps them into calldata.
+ *
+ * @generated from enum trading.v1.MarginOperationType
+ */
+export declare enum MarginOperationType {
+    /**
+     * @generated from enum value: INCREASE_POSITION = 0;
+     */
+    INCREASE_POSITION = 0,
+    /**
+     * @generated from enum value: DECREASE_POSITION = 1;
+     */
+    DECREASE_POSITION = 1,
+    /**
+     * @generated from enum value: ADD_COLLATERAL = 2;
+     */
+    ADD_COLLATERAL = 2,
+    /**
+     * @generated from enum value: WITHDRAW = 3;
+     */
+    WITHDRAW = 3,
+    /**
+     * @generated from enum value: SWEEP = 4;
+     */
+    SWEEP = 4
+}
+/**
+ * @generated from enum trading.v1.MarginPositionStatus
+ */
+export declare enum MarginPositionStatus {
+    /**
+     * @generated from enum value: ACTIVE = 0;
+     */
+    ACTIVE = 0,
+    /**
+     * @generated from enum value: COMPLETED = 1;
+     */
+    COMPLETED = 1,
+    /**
+     * @generated from enum value: LIQUIDATED = 2;
+     */
+    LIQUIDATED = 2,
+    /**
+     * @generated from enum value: PARTIALLY_LIQUIDATED = 3;
+     */
+    PARTIALLY_LIQUIDATED = 3
+}
 /**
  * @generated from message trading.v1.Encode7702Request
  */
@@ -7939,3 +8038,969 @@ export declare class MarginMarketsResponse extends Message<MarginMarketsResponse
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginMarketsResponse;
     static equals(a: MarginMarketsResponse | PlainMessage<MarginMarketsResponse> | undefined, b: MarginMarketsResponse | PlainMessage<MarginMarketsResponse> | undefined): boolean;
 }
+/**
+ * increaseLeverage, decreaseLeverage. Equity is held, so no amount.
+ *
+ * @generated from message trading.v1.MarginLeverageAction
+ */
+export declare class MarginLeverageAction extends Message<MarginLeverageAction> {
+    /**
+     * @generated from field: string position_id = 1;
+     */
+    positionId: string;
+    /**
+     * Decimal string ("3", "2.55"), never a float.
+     *
+     * @generated from field: string leverage_target = 2;
+     */
+    leverageTarget: string;
+    constructor(data?: PartialMessage<MarginLeverageAction>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginLeverageAction";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginLeverageAction;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginLeverageAction;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginLeverageAction;
+    static equals(a: MarginLeverageAction | PlainMessage<MarginLeverageAction> | undefined, b: MarginLeverageAction | PlainMessage<MarginLeverageAction> | undefined): boolean;
+}
+/**
+ * The four composites. Both axes move, so both magnitudes are carried.
+ *
+ * @generated from message trading.v1.MarginEquityLeverageAction
+ */
+export declare class MarginEquityLeverageAction extends Message<MarginEquityLeverageAction> {
+    /**
+     * @generated from field: string position_id = 1;
+     */
+    positionId: string;
+    /**
+     * @generated from field: string leverage_target = 2;
+     */
+    leverageTarget: string;
+    /**
+     * @generated from field: string amount = 3;
+     */
+    amount: string;
+    constructor(data?: PartialMessage<MarginEquityLeverageAction>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginEquityLeverageAction";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginEquityLeverageAction;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginEquityLeverageAction;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginEquityLeverageAction;
+    static equals(a: MarginEquityLeverageAction | PlainMessage<MarginEquityLeverageAction> | undefined, b: MarginEquityLeverageAction | PlainMessage<MarginEquityLeverageAction> | undefined): boolean;
+}
+/**
+ * addEquity, withdrawEquity. Size is held and leverage follows, so no target.
+ *
+ * `amount` is denominated in wallet_token on addEquity, and in the COLLATERAL
+ * token on withdrawEquity. That asymmetry is deliberate, and it is the one
+ * place the "amount is always wallet_token" rule breaks.
+ *
+ * A withdrawal's safety is a property of the position, not of the price its
+ * proceeds fetch: how much collateral can leave before health hits the floor
+ * is answerable from the position alone. Denominating in wallet_token would
+ * make that check depend on a swap quote, so whether a withdrawal is allowed
+ * would move with the funding route. It also matches the on-chain primitive,
+ * which takes a collateral amount, and the max-withdrawable guard, which is
+ * computed in collateral terms.
+ *
+ * @generated from message trading.v1.MarginEquityAction
+ */
+export declare class MarginEquityAction extends Message<MarginEquityAction> {
+    /**
+     * @generated from field: string position_id = 1;
+     */
+    positionId: string;
+    /**
+     * @generated from field: string amount = 2;
+     */
+    amount: string;
+    constructor(data?: PartialMessage<MarginEquityAction>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginEquityAction";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginEquityAction;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginEquityAction;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginEquityAction;
+    static equals(a: MarginEquityAction | PlainMessage<MarginEquityAction> | undefined, b: MarginEquityAction | PlainMessage<MarginEquityAction> | undefined): boolean;
+}
+/**
+ * close. The whole position, so structurally neither a target nor an amount.
+ *
+ * @generated from message trading.v1.MarginPositionAction
+ */
+export declare class MarginPositionAction extends Message<MarginPositionAction> {
+    /**
+     * @generated from field: string position_id = 1;
+     */
+    positionId: string;
+    constructor(data?: PartialMessage<MarginPositionAction>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginPositionAction";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginPositionAction;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginPositionAction;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginPositionAction;
+    static equals(a: MarginPositionAction | PlainMessage<MarginPositionAction> | undefined, b: MarginPositionAction | PlainMessage<MarginPositionAction> | undefined): boolean;
+}
+/**
+ * open. No position_id: the server allocates one at plan create.
+ *
+ * @generated from message trading.v1.MarginOpenAction
+ */
+export declare class MarginOpenAction extends Message<MarginOpenAction> {
+    /**
+     * @generated from field: string leverage_target = 1;
+     */
+    leverageTarget: string;
+    /**
+     * The LENDING allowlist, distinct from `swap_config.protocols` (the AMM
+     * allowlist for the wallet-side swap).
+     *
+     * @generated from field: repeated trading.v1.MarginVenue venues = 2;
+     */
+    venues: MarginVenue[];
+    /**
+     * @generated from field: string amount = 3;
+     */
+    amount: string;
+    constructor(data?: PartialMessage<MarginOpenAction>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginOpenAction";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginOpenAction;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginOpenAction;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginOpenAction;
+    static equals(a: MarginOpenAction | PlainMessage<MarginOpenAction> | undefined, b: MarginOpenAction | PlainMessage<MarginOpenAction> | undefined): boolean;
+}
+/**
+ * EXECUTION POLICY for the wallet-side swap, and nothing else. It names no
+ * token, no chain, no amount and no trade type: identity lives at the top level
+ * in wallet_token / wallet_chain_id, the magnitude lives in the action key, and
+ * exact-in vs exact-out follows from whether that key pays in or pays out.
+ *
+ * Kept separate from wallet_token because the two have different lifetimes.
+ * wallet_token is always meaningful; this block can be moot, since paying in
+ * the collateral token needs no funding swap at all, and whether one is needed
+ * is a routing outcome not knowable at request time.
+ *
+ * @generated from message trading.v1.MarginSwapConfig
+ */
+export declare class MarginSwapConfig extends Message<MarginSwapConfig> {
+    /**
+     * @generated from field: optional double slippage_tolerance = 1;
+     */
+    slippageTolerance?: number;
+    /**
+     * @generated from field: optional trading.v1.AutoSlippage auto_slippage = 2;
+     */
+    autoSlippage?: AutoSlippage;
+    /**
+     * @generated from field: repeated trading.v1.Protocols protocols = 3;
+     */
+    protocols: Protocols[];
+    constructor(data?: PartialMessage<MarginSwapConfig>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginSwapConfig";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginSwapConfig;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginSwapConfig;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginSwapConfig;
+    static equals(a: MarginSwapConfig | PlainMessage<MarginSwapConfig> | undefined, b: MarginSwapConfig | PlainMessage<MarginSwapConfig> | undefined): boolean;
+}
+/**
+ * @generated from message trading.v1.MarginQuoteRequest
+ */
+export declare class MarginQuoteRequest extends Message<MarginQuoteRequest> {
+    /**
+     * The chain the POSITION lives on. Named rather than left as a bare chain_id
+     * because two chains are in play: with one of them unqualified, a client
+     * reasonably reads it as "the" chain, sets it to the chain it is paying from,
+     * and silently gets a cross-chain funding flow it never asked for. Both are
+     * named so both have to be stated.
+     *
+     * @generated from field: int32 position_chain_id = 1;
+     */
+    positionChainId: number;
+    /**
+     * @generated from field: string exposure_token = 2;
+     */
+    exposureToken: string;
+    /**
+     * @generated from field: string counter_token = 3;
+     */
+    counterToken: string;
+    /**
+     * @generated from field: trading.v1.MarginDirection direction = 4;
+     */
+    direction: MarginDirection;
+    /**
+     * @generated from field: string swapper = 5;
+     */
+    swapper: string;
+    /**
+     * The LEVERAGE leg: the flash-accounted, debt-funded swap inside the router.
+     * Independent of swap_config; neither defaults from the other. Always an
+     * explicit percentage, because it derives max_debt_in / max_collateral_in,
+     * which stamp into calldata as the MEV backstop, and a routing heuristic must
+     * not size a binding fund-safety bound. That is why there is no
+     * auto_slippage here and there is one inside swap_config.
+     *
+     * @generated from field: optional double slippage_tolerance = 6;
+     */
+    slippageTolerance?: number;
+    /**
+     * Required iff the action has a wallet-side swap, forbidden otherwise; never
+     * genuinely optional. Enforced structurally in Joi (with/without per key).
+     *
+     * @generated from field: optional trading.v1.MarginSwapConfig swap_config = 8;
+     */
+    swapConfig?: MarginSwapConfig;
+    /**
+     * The token crossing the wallet boundary, and where it sits. Deliberately NOT
+     * named token_in: `withdraw_equity*` and `close` pay OUT, so an "in" name
+     * would be wrong on four of the ten keys. Flow direction is read off the
+     * action key and never restated here. `amount` in the action key is
+     * denominated in this token. Governed by the same per-key rules as
+     * swap_config.
+     *
+     * @generated from field: optional string wallet_token = 9;
+     */
+    walletToken?: string;
+    /**
+     * Differs from position_chain_id => cross-chain funding (pay-in only).
+     *
+     * @generated from field: optional int32 wallet_chain_id = 10;
+     */
+    walletChainId?: number;
+    /**
+     * @generated from oneof trading.v1.MarginQuoteRequest.action
+     */
+    action: {
+        /**
+         * @generated from field: trading.v1.MarginOpenAction open = 20;
+         */
+        value: MarginOpenAction;
+        case: "open";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginPositionAction close = 21;
+         */
+        value: MarginPositionAction;
+        case: "close";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginLeverageAction increase_leverage = 22;
+         */
+        value: MarginLeverageAction;
+        case: "increaseLeverage";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginLeverageAction decrease_leverage = 23;
+         */
+        value: MarginLeverageAction;
+        case: "decreaseLeverage";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginEquityAction add_equity = 24;
+         */
+        value: MarginEquityAction;
+        case: "addEquity";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginEquityAction withdraw_equity = 25;
+         */
+        value: MarginEquityAction;
+        case: "withdrawEquity";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginEquityLeverageAction add_equity_and_increase_leverage = 26;
+         */
+        value: MarginEquityLeverageAction;
+        case: "addEquityAndIncreaseLeverage";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginEquityLeverageAction add_equity_and_decrease_leverage = 27;
+         */
+        value: MarginEquityLeverageAction;
+        case: "addEquityAndDecreaseLeverage";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginEquityLeverageAction withdraw_equity_and_increase_leverage = 28;
+         */
+        value: MarginEquityLeverageAction;
+        case: "withdrawEquityAndIncreaseLeverage";
+    } | {
+        /**
+         * @generated from field: trading.v1.MarginEquityLeverageAction withdraw_equity_and_decrease_leverage = 29;
+         */
+        value: MarginEquityLeverageAction;
+        case: "withdrawEquityAndDecreaseLeverage";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    constructor(data?: PartialMessage<MarginQuoteRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginQuoteRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginQuoteRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginQuoteRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginQuoteRequest;
+    static equals(a: MarginQuoteRequest | PlainMessage<MarginQuoteRequest> | undefined, b: MarginQuoteRequest | PlainMessage<MarginQuoteRequest> | undefined): boolean;
+}
+/**
+ * The confirmed bounds for one operation. Which fields are set follows from
+ * `type`; they are the numbers that stamp into calldata, so they are in native
+ * token decimals (LTV and leverage are WAD).
+ *
+ * @generated from message trading.v1.MarginOperation
+ */
+export declare class MarginOperation extends Message<MarginOperation> {
+    /**
+     * @generated from field: trading.v1.MarginOperationType type = 1;
+     */
+    type: MarginOperationType;
+    /**
+     * INCREASE_POSITION: exact-out buy, collateral asset.
+     *
+     * @generated from field: optional string collateral_to_buy = 2;
+     */
+    collateralToBuy?: string;
+    /**
+     * INCREASE_POSITION: binding slippage cap on debt spent. Mandatory non-zero
+     * on-chain; the router refuses a zero bound outright.
+     *
+     * @generated from field: optional string max_debt_in = 3;
+     */
+    maxDebtIn?: string;
+    /**
+     * DECREASE_POSITION: debt cleared at the venue.
+     *
+     * @generated from field: optional string debt_to_repay = 4;
+     */
+    debtToRepay?: string;
+    /**
+     * DECREASE_POSITION: cap on collateral sold, round-UP slippage pad.
+     *
+     * @generated from field: optional string max_collateral_in = 5;
+     */
+    maxCollateralIn?: string;
+    /**
+     * Health assertion where one exists on-chain.
+     *
+     * @generated from field: optional string max_ltv_after = 6;
+     */
+    maxLtvAfter?: string;
+    /**
+     * ADD_COLLATERAL / WITHDRAW magnitude, in the flow-native asset.
+     *
+     * @generated from field: optional string amount = 7;
+     */
+    amount?: string;
+    /**
+     * Optional per-hop bound; 0 disables. 18-dec on the wire, X36 at encode.
+     *
+     * @generated from field: optional string min_hop_price = 8;
+     */
+    minHopPrice?: string;
+    /**
+     * This operation's quoted fill, and the PRICE_DRIFT reference at re-stamp.
+     *
+     * @generated from field: optional string effective_price = 9;
+     */
+    effectivePrice?: string;
+    constructor(data?: PartialMessage<MarginOperation>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginOperation";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginOperation;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginOperation;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginOperation;
+    static equals(a: MarginOperation | PlainMessage<MarginOperation> | undefined, b: MarginOperation | PlainMessage<MarginOperation> | undefined): boolean;
+}
+/**
+ * @generated from message trading.v1.MarginExecutionLeg
+ */
+export declare class MarginExecutionLeg extends Message<MarginExecutionLeg> {
+    /**
+     * @generated from field: trading.v1.MarginVenue venue = 1;
+     */
+    venue: MarginVenue;
+    /**
+     * Server-resolved on manage actions; absent on open until plan create
+     * allocates it.
+     *
+     * @generated from field: optional string sub_id = 2;
+     */
+    subId?: string;
+    /**
+     * Ordered. A composite action populates more than one.
+     *
+     * @generated from field: repeated trading.v1.MarginOperation operations = 3;
+     */
+    operations: MarginOperation[];
+    constructor(data?: PartialMessage<MarginExecutionLeg>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginExecutionLeg";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginExecutionLeg;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginExecutionLeg;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginExecutionLeg;
+    static equals(a: MarginExecutionLeg | PlainMessage<MarginExecutionLeg> | undefined, b: MarginExecutionLeg | PlainMessage<MarginExecutionLeg> | undefined): boolean;
+}
+/**
+ * The wallet-side swap as priced, in the same shape /quote uses for an ordinary
+ * swap, so the funding leg reads natively rather than inventing a fourth
+ * swap-quote vocabulary.
+ *
+ * Present IFF a swap was actually priced, so its presence is the signal that
+ * one happened. Absent when the action moves no equity, and absent when the
+ * caller already holds the collateral: paying in the collateral itself needs no
+ * funding swap, and a block whose input and output name the same token and the
+ * same amount describes no trade.
+ *
+ * 7 was auto_slippage: a request-side mode, never an answer. What a caller
+ * needs back is the percent it RESOLVED to, which slippage_tolerance already
+ * carries.
+ * 8 was protocols: an echo of the request that no consumer read, and as a
+ * repeated field it serializes as [] whether the caller named none or the
+ * route used none, so it could not carry its own meaning.
+ *
+ * @generated from message trading.v1.MarginFunding
+ */
+export declare class MarginFunding extends Message<MarginFunding> {
+    /**
+     * @generated from field: int32 token_in_chain_id = 1;
+     */
+    tokenInChainId: number;
+    /**
+     * @generated from field: trading.v1.QuoteInput input = 3;
+     */
+    input?: QuoteInput;
+    /**
+     * @generated from field: trading.v1.QuoteOutput output = 4;
+     */
+    output?: QuoteOutput;
+    /**
+     * The tolerance the floor was derived at, which is what POST /plan
+     * re-derives against. Present even when the request asked for auto.
+     *
+     * @generated from field: optional double slippage_tolerance = 6;
+     */
+    slippageTolerance?: number;
+    /**
+     * Cross-chain pay-in only: the guaranteed bridge floor.
+     *
+     * @generated from field: optional string min_bridge_out = 9;
+     */
+    minBridgeOut?: string;
+    /**
+     * Percent, as /quote reports it: how far this swap lands from the pool's
+     * price. Reported, never refused. This leg spends the caller's own money at
+     * the tolerance they chose, unlike the leverage leg, whose impact is
+     * multiplied by leverage and is refused past a ceiling.
+     *
+     * @generated from field: optional double price_impact = 10;
+     */
+    priceImpact?: number;
+    constructor(data?: PartialMessage<MarginFunding>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginFunding";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginFunding;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginFunding;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginFunding;
+    static equals(a: MarginFunding | PlainMessage<MarginFunding> | undefined, b: MarginFunding | PlainMessage<MarginFunding> | undefined): boolean;
+}
+/**
+ * Everything POST /plan needs, and nothing it does not. This subtree is what a
+ * client echoes back to create a plan; `display` never is.
+ *
+ * @generated from message trading.v1.MarginExecution
+ */
+export declare class MarginExecution extends Message<MarginExecution> {
+    /**
+     * @generated from field: int32 position_chain_id = 1;
+     */
+    positionChainId: number;
+    /**
+     * @generated from field: string swapper = 2;
+     */
+    swapper: string;
+    /**
+     * @generated from field: string exposure_token = 3;
+     */
+    exposureToken: string;
+    /**
+     * @generated from field: string counter_token = 4;
+     */
+    counterToken: string;
+    /**
+     * @generated from field: trading.v1.MarginDirection direction = 5;
+     */
+    direction: MarginDirection;
+    /**
+     * @generated from field: trading.v1.MarginIntent intent = 6;
+     */
+    intent: MarginIntent;
+    /**
+     * Absent on open.
+     *
+     * @generated from field: optional string position_id = 7;
+     */
+    positionId?: string;
+    /**
+     * Present iff the action names a leverage direction.
+     *
+     * @generated from field: optional string leverage_target = 8;
+     */
+    leverageTarget?: string;
+    /**
+     * The leverage leg's confirmed control, and only the tolerance. There is no
+     * AMM allowlist here: the leverage leg is v4 by construction, since route
+     * discovery keeps only v4 pools and the price is re-quoted through the v4
+     * quoter, so it could not honour one. The wallet-side swap is a real
+     * aggregator swap and carries its own in swap_config.protocols.
+     *
+     * @generated from field: optional double slippage_tolerance = 9;
+     */
+    slippageTolerance?: number;
+    /**
+     * @generated from field: optional trading.v1.MarginFunding funding = 11;
+     */
+    funding?: MarginFunding;
+    /**
+     * @generated from field: repeated trading.v1.MarginExecutionLeg legs = 12;
+     */
+    legs: MarginExecutionLeg[];
+    constructor(data?: PartialMessage<MarginExecution>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginExecution";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginExecution;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginExecution;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginExecution;
+    static equals(a: MarginExecution | PlainMessage<MarginExecution> | undefined, b: MarginExecution | PlainMessage<MarginExecution> | undefined): boolean;
+}
+/**
+ * What the confirmation modal renders. Projections of the position IF this
+ * action executes; present state lives on GET /margin/positions. Ignored by
+ * POST /plan: projections are not execution inputs.
+ *
+ * @generated from message trading.v1.MarginDisplay
+ */
+export declare class MarginDisplay extends Message<MarginDisplay> {
+    /**
+     * Exposure asset, summed across legs.
+     *
+     * @generated from field: optional string size = 1;
+     */
+    size?: string;
+    /**
+     * Position / equity, decimal string as on the request.
+     *
+     * @generated from field: optional string leverage = 2;
+     */
+    leverage?: string;
+    /**
+     * Quoted fill incl. fees, impact and slippage. Size-weighted across legs.
+     *
+     * @generated from field: optional string effective_price = 3;
+     */
+    effectivePrice?: string;
+    /**
+     * Oracle price at which LTV = LLTV. Multi-leg: the nearest leg's, because
+     * legs liquidate independently.
+     *
+     * @generated from field: optional string liquidation_price = 4;
+     */
+    liquidationPrice?: string;
+    /**
+     * collateral x LLTV / debt; liquidatable below 1. Nearest leg. The one risk
+     * number that normalizes across venues, so it is what the client bands into
+     * Healthy / Caution / Risky. The band thresholds are a product call and stay
+     * client-side.
+     *
+     * @generated from field: optional string health_factor = 6;
+     */
+    healthFactor?: string;
+    /**
+     * Annualized borrow rate on the debt, size-weighted across legs.
+     *
+     * @generated from field: optional string borrow_rate = 7;
+     */
+    borrowRate?: string;
+    /**
+     * Venue liquidation-reference price.
+     *
+     * @generated from field: optional string oracle_price = 8;
+     */
+    oraclePrice?: string;
+    /**
+     * close only.
+     *
+     * @generated from field: optional string collateral_returned = 9;
+     */
+    collateralReturned?: string;
+    /**
+     * @generated from field: optional string debt_repaid = 10;
+     */
+    debtRepaid?: string;
+    constructor(data?: PartialMessage<MarginDisplay>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginDisplay";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginDisplay;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginDisplay;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginDisplay;
+    static equals(a: MarginDisplay | PlainMessage<MarginDisplay> | undefined, b: MarginDisplay | PlainMessage<MarginDisplay> | undefined): boolean;
+}
+/**
+ * @generated from message trading.v1.MarginQuoteResponse
+ */
+export declare class MarginQuoteResponse extends Message<MarginQuoteResponse> {
+    /**
+     * @generated from field: string request_id = 1;
+     */
+    requestId: string;
+    /**
+     * @generated from field: trading.v1.MarginExecution execution = 2;
+     */
+    execution?: MarginExecution;
+    /**
+     * @generated from field: trading.v1.MarginDisplay display = 3;
+     */
+    display?: MarginDisplay;
+    /**
+     * Indicative.
+     *
+     * @generated from field: optional trading.v1.GasEstimate gas_estimate = 4;
+     */
+    gasEstimate?: GasEstimate;
+    constructor(data?: PartialMessage<MarginQuoteResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginQuoteResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginQuoteResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginQuoteResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginQuoteResponse;
+    static equals(a: MarginQuoteResponse | PlainMessage<MarginQuoteResponse> | undefined, b: MarginQuoteResponse | PlainMessage<MarginQuoteResponse> | undefined): boolean;
+}
+/**
+ * One venue's share of a position. Legs are the unit of truth: a logical
+ * position is an aggregation performed at read time, and legs liquidate
+ * independently, so the row's risk numbers are the NEAREST leg's.
+ *
+ * @generated from message trading.v1.MarginPositionLeg
+ */
+export declare class MarginPositionLeg extends Message<MarginPositionLeg> {
+    /**
+     * @generated from field: trading.v1.MarginVenue venue = 1;
+     */
+    venue: MarginVenue;
+    /**
+     * The `positionId` handle every action key echoes back. Returned whether or
+     * not a screen renders it.
+     *
+     * @generated from field: string sub_id = 2;
+     */
+    subId: string;
+    /**
+     * The MarginAccount this leg lives at, derived offchain from (owner, subId).
+     *
+     * @generated from field: string account = 3;
+     */
+    account: string;
+    /**
+     * @generated from field: string debt = 4;
+     */
+    debt: string;
+    /**
+     * Best effort, like the markets feed: absent when the venue's rate read did
+     * not return, never zero, because an unread rate and a zero rate differ.
+     *
+     * @generated from field: optional string borrow_rate = 5;
+     */
+    borrowRate?: string;
+    constructor(data?: PartialMessage<MarginPositionLeg>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginPositionLeg";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginPositionLeg;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginPositionLeg;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginPositionLeg;
+    static equals(a: MarginPositionLeg | PlainMessage<MarginPositionLeg> | undefined, b: MarginPositionLeg | PlainMessage<MarginPositionLeg> | undefined): boolean;
+}
+/**
+ * One logical position, keyed (exposure_token, counter_token, direction) — the
+ * same key the markets cursor orders on, which is why both endpoints page
+ * through `marginMarketCursor`.
+ *
+ * @generated from message trading.v1.MarginPositionRow
+ */
+export declare class MarginPositionRow extends Message<MarginPositionRow> {
+    /**
+     * @generated from field: trading.v1.MarginPositionStatus status = 1;
+     */
+    status: MarginPositionStatus;
+    /**
+     * @generated from field: trading.v1.MarginDirection direction = 2;
+     */
+    direction: MarginDirection;
+    /**
+     * @generated from field: trading.v1.MarginTokenMetadata exposure_token = 3;
+     */
+    exposureToken?: MarginTokenMetadata;
+    /**
+     * @generated from field: trading.v1.MarginTokenMetadata counter_token = 4;
+     */
+    counterToken?: MarginTokenMetadata;
+    /**
+     * @generated from field: string size = 5;
+     */
+    size: string;
+    /**
+     * @generated from field: repeated trading.v1.MarginPositionLeg legs = 6;
+     */
+    legs: MarginPositionLeg[];
+    /**
+     * COST BASIS. Needs the margin event consumer, which is not on the launch
+     * path, so every field here is absent in v1 rather than zero.
+     *
+     * @generated from field: optional string entry_price = 7;
+     */
+    entryPrice?: string;
+    /**
+     * @generated from field: optional int64 opened_at = 8;
+     */
+    openedAt?: bigint;
+    /**
+     * @generated from field: optional string accrued_interest = 9;
+     */
+    accruedInterest?: string;
+    /**
+     * @generated from field: optional string unrealized_pnl = 10;
+     */
+    unrealizedPnl?: string;
+    /**
+     * @generated from field: optional string roe = 11;
+     */
+    roe?: string;
+    /**
+     * ACTIVE only. Read on chain per request, never cached: a stale health factor
+     * is the one number a caller must not act on.
+     *
+     * @generated from field: optional string equity = 12;
+     */
+    equity?: string;
+    /**
+     * @generated from field: optional string leverage = 13;
+     */
+    leverage?: string;
+    /**
+     * @generated from field: optional string oracle_price = 14;
+     */
+    oraclePrice?: string;
+    /**
+     * Nearest leg. In TRADER terms, so a short's mark and liquidation price are
+     * both reciprocated; see `displayRiskPrices`.
+     *
+     * @generated from field: optional string liquidation_price = 15;
+     */
+    liquidationPrice?: string;
+    /**
+     * @generated from field: optional string buffer = 16;
+     */
+    buffer?: string;
+    /**
+     * @generated from field: optional string health_factor = 17;
+     */
+    healthFactor?: string;
+    /**
+     * @generated from field: optional string borrow_rate = 18;
+     */
+    borrowRate?: string;
+    /**
+     * Health-floor bounded, server-computed. There is no on-chain guard on a
+     * withdraw, so the ceiling has to come from here rather than from a quote.
+     *
+     * @generated from field: optional string max_withdrawable = 19;
+     */
+    maxWithdrawable?: string;
+    /**
+     * TERMINAL only, and likewise cost-basis derived.
+     *
+     * @generated from field: optional int64 closed_at = 20;
+     */
+    closedAt?: bigint;
+    /**
+     * @generated from field: optional string exit_price = 21;
+     */
+    exitPrice?: string;
+    /**
+     * @generated from field: optional string realized_pnl = 22;
+     */
+    realizedPnl?: string;
+    constructor(data?: PartialMessage<MarginPositionRow>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginPositionRow";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginPositionRow;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginPositionRow;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginPositionRow;
+    static equals(a: MarginPositionRow | PlainMessage<MarginPositionRow> | undefined, b: MarginPositionRow | PlainMessage<MarginPositionRow> | undefined): boolean;
+}
+/**
+ * Collateral parked at a MarginAccount whose open never completed. Derived from
+ * the chain rather than the plan store, so it survives plan-row expiry and is
+ * visible from any device.
+ *
+ * @generated from message trading.v1.MarginIncompleteOpen
+ */
+export declare class MarginIncompleteOpen extends Message<MarginIncompleteOpen> {
+    /**
+     * @generated from field: string account = 1;
+     */
+    account: string;
+    /**
+     * @generated from field: string sub_id = 2;
+     */
+    subId: string;
+    /**
+     * False when the account holds a balance but was never deployed, which is the
+     * window this surface exists for: pre-swap delivered, position not opened.
+     *
+     * @generated from field: bool deployed = 3;
+     */
+    deployed: boolean;
+    /**
+     * @generated from field: trading.v1.MarginTokenMetadata token = 4;
+     */
+    token?: MarginTokenMetadata;
+    /**
+     * @generated from field: string amount = 5;
+     */
+    amount: string;
+    constructor(data?: PartialMessage<MarginIncompleteOpen>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginIncompleteOpen";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginIncompleteOpen;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginIncompleteOpen;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginIncompleteOpen;
+    static equals(a: MarginIncompleteOpen | PlainMessage<MarginIncompleteOpen> | undefined, b: MarginIncompleteOpen | PlainMessage<MarginIncompleteOpen> | undefined): boolean;
+}
+/**
+ * The one plan-store read, and a deliberately weaker guarantee than the rest of
+ * this response: session-scoped and TTL-bound, so absent rather than wrong once
+ * a row ages out. Acceptable only because no funds are at risk in that state.
+ *
+ * @generated from message trading.v1.MarginPendingPlan
+ */
+export declare class MarginPendingPlan extends Message<MarginPendingPlan> {
+    /**
+     * @generated from field: string plan_id = 1;
+     */
+    planId: string;
+    /**
+     * @generated from field: int64 created_at = 2;
+     */
+    createdAt: bigint;
+    /**
+     * @generated from field: int32 current_step = 3;
+     */
+    currentStep: number;
+    /**
+     * @generated from field: bool cancellable = 4;
+     */
+    cancellable: boolean;
+    constructor(data?: PartialMessage<MarginPendingPlan>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginPendingPlan";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginPendingPlan;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginPendingPlan;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginPendingPlan;
+    static equals(a: MarginPendingPlan | PlainMessage<MarginPendingPlan> | undefined, b: MarginPendingPlan | PlainMessage<MarginPendingPlan> | undefined): boolean;
+}
+/**
+ * @generated from message trading.v1.MarginPositionsRequest
+ */
+export declare class MarginPositionsRequest extends Message<MarginPositionsRequest> {
+    /**
+     * @generated from field: string swapper = 1;
+     */
+    swapper: string;
+    /**
+     * @generated from field: int32 chain_id = 2;
+     */
+    chainId: number;
+    /**
+     * Selects the tab. Unset is ACTIVE; explicit presence so the server can tell
+     * "not asked" from "asked for ACTIVE".
+     *
+     * @generated from field: optional trading.v1.MarginPositionStatus status = 3;
+     */
+    status?: MarginPositionStatus;
+    /**
+     * Opaque; echo `next_cursor` back verbatim. Keyset over the row order, the
+     * same contract `GET /margin/markets` uses.
+     *
+     * @generated from field: optional string cursor = 4;
+     */
+    cursor?: string;
+    /**
+     * @generated from field: optional int32 limit = 5;
+     */
+    limit?: number;
+    constructor(data?: PartialMessage<MarginPositionsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginPositionsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginPositionsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginPositionsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginPositionsRequest;
+    static equals(a: MarginPositionsRequest | PlainMessage<MarginPositionsRequest> | undefined, b: MarginPositionsRequest | PlainMessage<MarginPositionsRequest> | undefined): boolean;
+}
+/**
+ * @generated from message trading.v1.MarginPositionsResponse
+ */
+export declare class MarginPositionsResponse extends Message<MarginPositionsResponse> {
+    /**
+     * @generated from field: string request_id = 1;
+     */
+    requestId: string;
+    /**
+     * @generated from field: repeated trading.v1.MarginPositionRow positions = 2;
+     */
+    positions: MarginPositionRow[];
+    /**
+     * Absent on the last page. Present means more rows exist, never that the next
+     * page is non-empty.
+     *
+     * @generated from field: optional string next_cursor = 3;
+     */
+    nextCursor?: string;
+    /**
+     * Both recovery surfaces serialize as [] when the read ran and found nothing.
+     * They cannot express "not read": a degraded read logs a warning and reports
+     * empty, matching how the markets feed degrades a failed venue.
+     *
+     * @generated from field: repeated trading.v1.MarginIncompleteOpen incomplete_opens = 4;
+     */
+    incompleteOpens: MarginIncompleteOpen[];
+    /**
+     * @generated from field: repeated trading.v1.MarginPendingPlan pending_plans = 5;
+     */
+    pendingPlans: MarginPendingPlan[];
+    constructor(data?: PartialMessage<MarginPositionsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "trading.v1.MarginPositionsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarginPositionsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarginPositionsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarginPositionsResponse;
+    static equals(a: MarginPositionsResponse | PlainMessage<MarginPositionsResponse> | undefined, b: MarginPositionsResponse | PlainMessage<MarginPositionsResponse> | undefined): boolean;
+}