@uniswap/client-trading 0.6.1 → 0.8.0

package/dist/trading/v1/api_pb.js

@@ -967,6 +967,136 @@ proto3.util.setEnumType(MarginVenue, "trading.v1.MarginVenue", [
     { no: 1, name: "AAVE_V3" },
     { no: 2, name: "AAVE_V4" },
 ]);
+/**
+ * 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 var MarginIntent;
+(function (MarginIntent) {
+    /**
+     * @generated from enum value: MARGIN_INTENT_OPEN = 0;
+     */
+    MarginIntent[MarginIntent["OPEN"] = 0] = "OPEN";
+    /**
+     * @generated from enum value: MARGIN_INTENT_CLOSE = 1;
+     */
+    MarginIntent[MarginIntent["CLOSE"] = 1] = "CLOSE";
+    /**
+     * @generated from enum value: MARGIN_INTENT_INCREASE_LEVERAGE = 2;
+     */
+    MarginIntent[MarginIntent["INCREASE_LEVERAGE"] = 2] = "INCREASE_LEVERAGE";
+    /**
+     * @generated from enum value: MARGIN_INTENT_DECREASE_LEVERAGE = 3;
+     */
+    MarginIntent[MarginIntent["DECREASE_LEVERAGE"] = 3] = "DECREASE_LEVERAGE";
+    /**
+     * @generated from enum value: MARGIN_INTENT_ADD_EQUITY = 4;
+     */
+    MarginIntent[MarginIntent["ADD_EQUITY"] = 4] = "ADD_EQUITY";
+    /**
+     * @generated from enum value: MARGIN_INTENT_WITHDRAW_EQUITY = 5;
+     */
+    MarginIntent[MarginIntent["WITHDRAW_EQUITY"] = 5] = "WITHDRAW_EQUITY";
+    /**
+     * @generated from enum value: MARGIN_INTENT_ADD_EQUITY_AND_INCREASE_LEVERAGE = 6;
+     */
+    MarginIntent[MarginIntent["ADD_EQUITY_AND_INCREASE_LEVERAGE"] = 6] = "ADD_EQUITY_AND_INCREASE_LEVERAGE";
+    /**
+     * @generated from enum value: MARGIN_INTENT_ADD_EQUITY_AND_DECREASE_LEVERAGE = 7;
+     */
+    MarginIntent[MarginIntent["ADD_EQUITY_AND_DECREASE_LEVERAGE"] = 7] = "ADD_EQUITY_AND_DECREASE_LEVERAGE";
+    /**
+     * @generated from enum value: MARGIN_INTENT_WITHDRAW_EQUITY_AND_INCREASE_LEVERAGE = 8;
+     */
+    MarginIntent[MarginIntent["WITHDRAW_EQUITY_AND_INCREASE_LEVERAGE"] = 8] = "WITHDRAW_EQUITY_AND_INCREASE_LEVERAGE";
+    /**
+     * @generated from enum value: MARGIN_INTENT_WITHDRAW_EQUITY_AND_DECREASE_LEVERAGE = 9;
+     */
+    MarginIntent[MarginIntent["WITHDRAW_EQUITY_AND_DECREASE_LEVERAGE"] = 9] = "WITHDRAW_EQUITY_AND_DECREASE_LEVERAGE";
+})(MarginIntent || (MarginIntent = {}));
+// Retrieve enum metadata with: proto3.getEnumType(MarginIntent)
+proto3.util.setEnumType(MarginIntent, "trading.v1.MarginIntent", [
+    { no: 0, name: "MARGIN_INTENT_OPEN" },
+    { no: 1, name: "MARGIN_INTENT_CLOSE" },
+    { no: 2, name: "MARGIN_INTENT_INCREASE_LEVERAGE" },
+    { no: 3, name: "MARGIN_INTENT_DECREASE_LEVERAGE" },
+    { no: 4, name: "MARGIN_INTENT_ADD_EQUITY" },
+    { no: 5, name: "MARGIN_INTENT_WITHDRAW_EQUITY" },
+    { no: 6, name: "MARGIN_INTENT_ADD_EQUITY_AND_INCREASE_LEVERAGE" },
+    { no: 7, name: "MARGIN_INTENT_ADD_EQUITY_AND_DECREASE_LEVERAGE" },
+    { no: 8, name: "MARGIN_INTENT_WITHDRAW_EQUITY_AND_INCREASE_LEVERAGE" },
+    { no: 9, name: "MARGIN_INTENT_WITHDRAW_EQUITY_AND_DECREASE_LEVERAGE" },
+]);
+/**
+ * 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 var MarginOperationType;
+(function (MarginOperationType) {
+    /**
+     * @generated from enum value: INCREASE_POSITION = 0;
+     */
+    MarginOperationType[MarginOperationType["INCREASE_POSITION"] = 0] = "INCREASE_POSITION";
+    /**
+     * @generated from enum value: DECREASE_POSITION = 1;
+     */
+    MarginOperationType[MarginOperationType["DECREASE_POSITION"] = 1] = "DECREASE_POSITION";
+    /**
+     * @generated from enum value: ADD_COLLATERAL = 2;
+     */
+    MarginOperationType[MarginOperationType["ADD_COLLATERAL"] = 2] = "ADD_COLLATERAL";
+    /**
+     * @generated from enum value: WITHDRAW = 3;
+     */
+    MarginOperationType[MarginOperationType["WITHDRAW"] = 3] = "WITHDRAW";
+    /**
+     * @generated from enum value: SWEEP = 4;
+     */
+    MarginOperationType[MarginOperationType["SWEEP"] = 4] = "SWEEP";
+})(MarginOperationType || (MarginOperationType = {}));
+// Retrieve enum metadata with: proto3.getEnumType(MarginOperationType)
+proto3.util.setEnumType(MarginOperationType, "trading.v1.MarginOperationType", [
+    { no: 0, name: "INCREASE_POSITION" },
+    { no: 1, name: "DECREASE_POSITION" },
+    { no: 2, name: "ADD_COLLATERAL" },
+    { no: 3, name: "WITHDRAW" },
+    { no: 4, name: "SWEEP" },
+]);
+/**
+ * @generated from enum trading.v1.MarginPositionStatus
+ */
+export var MarginPositionStatus;
+(function (MarginPositionStatus) {
+    /**
+     * @generated from enum value: ACTIVE = 0;
+     */
+    MarginPositionStatus[MarginPositionStatus["ACTIVE"] = 0] = "ACTIVE";
+    /**
+     * @generated from enum value: COMPLETED = 1;
+     */
+    MarginPositionStatus[MarginPositionStatus["COMPLETED"] = 1] = "COMPLETED";
+    /**
+     * @generated from enum value: LIQUIDATED = 2;
+     */
+    MarginPositionStatus[MarginPositionStatus["LIQUIDATED"] = 2] = "LIQUIDATED";
+    /**
+     * @generated from enum value: PARTIALLY_LIQUIDATED = 3;
+     */
+    MarginPositionStatus[MarginPositionStatus["PARTIALLY_LIQUIDATED"] = 3] = "PARTIALLY_LIQUIDATED";
+})(MarginPositionStatus || (MarginPositionStatus = {}));
+// Retrieve enum metadata with: proto3.getEnumType(MarginPositionStatus)
+proto3.util.setEnumType(MarginPositionStatus, "trading.v1.MarginPositionStatus", [
+    { no: 0, name: "ACTIVE" },
+    { no: 1, name: "COMPLETED" },
+    { no: 2, name: "LIQUIDATED" },
+    { no: 3, name: "PARTIALLY_LIQUIDATED" },
+]);
 /**
  * @generated from message trading.v1.Encode7702Request
  */
@@ -9325,3 +9455,908 @@ MarginMarketsResponse.fields = proto3.util.newFieldList(() => [
     { no: 2, name: "markets", kind: "message", T: MarginMarketRow, repeated: true },
     { no: 3, name: "next_cursor", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
 ]);
+/**
+ * increaseLeverage, decreaseLeverage. Equity is held, so no amount.
+ *
+ * @generated from message trading.v1.MarginLeverageAction
+ */
+export class MarginLeverageAction extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string position_id = 1;
+         */
+        this.positionId = "";
+        /**
+         * Decimal string ("3", "2.55"), never a float.
+         *
+         * @generated from field: string leverage_target = 2;
+         */
+        this.leverageTarget = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginLeverageAction().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginLeverageAction().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginLeverageAction().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginLeverageAction, a, b);
+    }
+}
+MarginLeverageAction.runtime = proto3;
+MarginLeverageAction.typeName = "trading.v1.MarginLeverageAction";
+MarginLeverageAction.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "position_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "leverage_target", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * The four composites. Both axes move, so both magnitudes are carried.
+ *
+ * @generated from message trading.v1.MarginEquityLeverageAction
+ */
+export class MarginEquityLeverageAction extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string position_id = 1;
+         */
+        this.positionId = "";
+        /**
+         * @generated from field: string leverage_target = 2;
+         */
+        this.leverageTarget = "";
+        /**
+         * @generated from field: string amount = 3;
+         */
+        this.amount = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginEquityLeverageAction().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginEquityLeverageAction().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginEquityLeverageAction().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginEquityLeverageAction, a, b);
+    }
+}
+MarginEquityLeverageAction.runtime = proto3;
+MarginEquityLeverageAction.typeName = "trading.v1.MarginEquityLeverageAction";
+MarginEquityLeverageAction.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "position_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "leverage_target", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * 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 class MarginEquityAction extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string position_id = 1;
+         */
+        this.positionId = "";
+        /**
+         * @generated from field: string amount = 2;
+         */
+        this.amount = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginEquityAction().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginEquityAction().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginEquityAction().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginEquityAction, a, b);
+    }
+}
+MarginEquityAction.runtime = proto3;
+MarginEquityAction.typeName = "trading.v1.MarginEquityAction";
+MarginEquityAction.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "position_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * close. The whole position, so structurally neither a target nor an amount.
+ *
+ * @generated from message trading.v1.MarginPositionAction
+ */
+export class MarginPositionAction extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string position_id = 1;
+         */
+        this.positionId = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginPositionAction().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginPositionAction().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginPositionAction().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginPositionAction, a, b);
+    }
+}
+MarginPositionAction.runtime = proto3;
+MarginPositionAction.typeName = "trading.v1.MarginPositionAction";
+MarginPositionAction.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "position_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * open. No position_id: the server allocates one at plan create.
+ *
+ * @generated from message trading.v1.MarginOpenAction
+ */
+export class MarginOpenAction extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string leverage_target = 1;
+         */
+        this.leverageTarget = "";
+        /**
+         * 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;
+         */
+        this.venues = [];
+        /**
+         * @generated from field: string amount = 3;
+         */
+        this.amount = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginOpenAction().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginOpenAction().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginOpenAction().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginOpenAction, a, b);
+    }
+}
+MarginOpenAction.runtime = proto3;
+MarginOpenAction.typeName = "trading.v1.MarginOpenAction";
+MarginOpenAction.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "leverage_target", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "venues", kind: "enum", T: proto3.getEnumType(MarginVenue), repeated: true },
+    { no: 3, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * 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 class MarginSwapConfig extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: repeated trading.v1.Protocols protocols = 3;
+         */
+        this.protocols = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginSwapConfig().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginSwapConfig().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginSwapConfig().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginSwapConfig, a, b);
+    }
+}
+MarginSwapConfig.runtime = proto3;
+MarginSwapConfig.typeName = "trading.v1.MarginSwapConfig";
+MarginSwapConfig.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "slippage_tolerance", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+    { no: 2, name: "auto_slippage", kind: "enum", T: proto3.getEnumType(AutoSlippage), opt: true },
+    { no: 3, name: "protocols", kind: "enum", T: proto3.getEnumType(Protocols), repeated: true },
+]);
+/**
+ * @generated from message trading.v1.MarginQuoteRequest
+ */
+export class MarginQuoteRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * 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;
+         */
+        this.positionChainId = 0;
+        /**
+         * @generated from field: string exposure_token = 2;
+         */
+        this.exposureToken = "";
+        /**
+         * @generated from field: string counter_token = 3;
+         */
+        this.counterToken = "";
+        /**
+         * @generated from field: trading.v1.MarginDirection direction = 4;
+         */
+        this.direction = MarginDirection.LONG;
+        /**
+         * @generated from field: string swapper = 5;
+         */
+        this.swapper = "";
+        /**
+         * @generated from oneof trading.v1.MarginQuoteRequest.action
+         */
+        this.action = { case: undefined };
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginQuoteRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginQuoteRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginQuoteRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginQuoteRequest, a, b);
+    }
+}
+MarginQuoteRequest.runtime = proto3;
+MarginQuoteRequest.typeName = "trading.v1.MarginQuoteRequest";
+MarginQuoteRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "position_chain_id", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "exposure_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "counter_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "direction", kind: "enum", T: proto3.getEnumType(MarginDirection) },
+    { no: 5, name: "swapper", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 6, name: "slippage_tolerance", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+    { no: 8, name: "swap_config", kind: "message", T: MarginSwapConfig, opt: true },
+    { no: 9, name: "wallet_token", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 10, name: "wallet_chain_id", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+    { no: 20, name: "open", kind: "message", T: MarginOpenAction, oneof: "action" },
+    { no: 21, name: "close", kind: "message", T: MarginPositionAction, oneof: "action" },
+    { no: 22, name: "increase_leverage", kind: "message", T: MarginLeverageAction, oneof: "action" },
+    { no: 23, name: "decrease_leverage", kind: "message", T: MarginLeverageAction, oneof: "action" },
+    { no: 24, name: "add_equity", kind: "message", T: MarginEquityAction, oneof: "action" },
+    { no: 25, name: "withdraw_equity", kind: "message", T: MarginEquityAction, oneof: "action" },
+    { no: 26, name: "add_equity_and_increase_leverage", kind: "message", T: MarginEquityLeverageAction, oneof: "action" },
+    { no: 27, name: "add_equity_and_decrease_leverage", kind: "message", T: MarginEquityLeverageAction, oneof: "action" },
+    { no: 28, name: "withdraw_equity_and_increase_leverage", kind: "message", T: MarginEquityLeverageAction, oneof: "action" },
+    { no: 29, name: "withdraw_equity_and_decrease_leverage", kind: "message", T: MarginEquityLeverageAction, oneof: "action" },
+]);
+/**
+ * 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 class MarginOperation extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: trading.v1.MarginOperationType type = 1;
+         */
+        this.type = MarginOperationType.INCREASE_POSITION;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginOperation().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginOperation().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginOperation().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginOperation, a, b);
+    }
+}
+MarginOperation.runtime = proto3;
+MarginOperation.typeName = "trading.v1.MarginOperation";
+MarginOperation.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "type", kind: "enum", T: proto3.getEnumType(MarginOperationType) },
+    { no: 2, name: "collateral_to_buy", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "max_debt_in", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 4, name: "debt_to_repay", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 5, name: "max_collateral_in", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 6, name: "max_ltv_after", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 7, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 8, name: "min_hop_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 9, name: "effective_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+]);
+/**
+ * @generated from message trading.v1.MarginExecutionLeg
+ */
+export class MarginExecutionLeg extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: trading.v1.MarginVenue venue = 1;
+         */
+        this.venue = MarginVenue.MORPHO;
+        /**
+         * Ordered. A composite action populates more than one.
+         *
+         * @generated from field: repeated trading.v1.MarginOperation operations = 3;
+         */
+        this.operations = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginExecutionLeg().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginExecutionLeg().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginExecutionLeg().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginExecutionLeg, a, b);
+    }
+}
+MarginExecutionLeg.runtime = proto3;
+MarginExecutionLeg.typeName = "trading.v1.MarginExecutionLeg";
+MarginExecutionLeg.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "venue", kind: "enum", T: proto3.getEnumType(MarginVenue) },
+    { no: 2, name: "sub_id", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "operations", kind: "message", T: MarginOperation, repeated: true },
+]);
+/**
+ * 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 class MarginFunding extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: int32 token_in_chain_id = 1;
+         */
+        this.tokenInChainId = 0;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginFunding().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginFunding().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginFunding().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginFunding, a, b);
+    }
+}
+MarginFunding.runtime = proto3;
+MarginFunding.typeName = "trading.v1.MarginFunding";
+MarginFunding.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "token_in_chain_id", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 3, name: "input", kind: "message", T: QuoteInput },
+    { no: 4, name: "output", kind: "message", T: QuoteOutput },
+    { no: 6, name: "slippage_tolerance", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+    { no: 9, name: "min_bridge_out", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 10, name: "price_impact", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+]);
+/**
+ * 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 class MarginExecution extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: int32 position_chain_id = 1;
+         */
+        this.positionChainId = 0;
+        /**
+         * @generated from field: string swapper = 2;
+         */
+        this.swapper = "";
+        /**
+         * @generated from field: string exposure_token = 3;
+         */
+        this.exposureToken = "";
+        /**
+         * @generated from field: string counter_token = 4;
+         */
+        this.counterToken = "";
+        /**
+         * @generated from field: trading.v1.MarginDirection direction = 5;
+         */
+        this.direction = MarginDirection.LONG;
+        /**
+         * @generated from field: trading.v1.MarginIntent intent = 6;
+         */
+        this.intent = MarginIntent.OPEN;
+        /**
+         * @generated from field: repeated trading.v1.MarginExecutionLeg legs = 12;
+         */
+        this.legs = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginExecution().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginExecution().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginExecution().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginExecution, a, b);
+    }
+}
+MarginExecution.runtime = proto3;
+MarginExecution.typeName = "trading.v1.MarginExecution";
+MarginExecution.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "position_chain_id", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "swapper", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "exposure_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "counter_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "direction", kind: "enum", T: proto3.getEnumType(MarginDirection) },
+    { no: 6, name: "intent", kind: "enum", T: proto3.getEnumType(MarginIntent) },
+    { no: 7, name: "position_id", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 8, name: "leverage_target", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 9, name: "slippage_tolerance", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
+    { no: 11, name: "funding", kind: "message", T: MarginFunding, opt: true },
+    { no: 12, name: "legs", kind: "message", T: MarginExecutionLeg, repeated: true },
+]);
+/**
+ * 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 class MarginDisplay extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginDisplay().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginDisplay().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginDisplay().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginDisplay, a, b);
+    }
+}
+MarginDisplay.runtime = proto3;
+MarginDisplay.typeName = "trading.v1.MarginDisplay";
+MarginDisplay.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "size", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 2, name: "leverage", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "effective_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 4, name: "liquidation_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 6, name: "health_factor", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 7, name: "borrow_rate", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 8, name: "oracle_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 9, name: "collateral_returned", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 10, name: "debt_repaid", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+]);
+/**
+ * @generated from message trading.v1.MarginQuoteResponse
+ */
+export class MarginQuoteResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string request_id = 1;
+         */
+        this.requestId = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginQuoteResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginQuoteResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginQuoteResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginQuoteResponse, a, b);
+    }
+}
+MarginQuoteResponse.runtime = proto3;
+MarginQuoteResponse.typeName = "trading.v1.MarginQuoteResponse";
+MarginQuoteResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "request_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "execution", kind: "message", T: MarginExecution },
+    { no: 3, name: "display", kind: "message", T: MarginDisplay },
+    { no: 4, name: "gas_estimate", kind: "message", T: GasEstimate, opt: true },
+]);
+/**
+ * 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 class MarginPositionLeg extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: trading.v1.MarginVenue venue = 1;
+         */
+        this.venue = MarginVenue.MORPHO;
+        /**
+         * The `positionId` handle every action key echoes back. Returned whether or
+         * not a screen renders it.
+         *
+         * @generated from field: string sub_id = 2;
+         */
+        this.subId = "";
+        /**
+         * The MarginAccount this leg lives at, derived offchain from (owner, subId).
+         *
+         * @generated from field: string account = 3;
+         */
+        this.account = "";
+        /**
+         * @generated from field: string debt = 4;
+         */
+        this.debt = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginPositionLeg().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginPositionLeg().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginPositionLeg().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginPositionLeg, a, b);
+    }
+}
+MarginPositionLeg.runtime = proto3;
+MarginPositionLeg.typeName = "trading.v1.MarginPositionLeg";
+MarginPositionLeg.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "venue", kind: "enum", T: proto3.getEnumType(MarginVenue) },
+    { no: 2, name: "sub_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "account", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "debt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "borrow_rate", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+]);
+/**
+ * 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 class MarginPositionRow extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: trading.v1.MarginPositionStatus status = 1;
+         */
+        this.status = MarginPositionStatus.ACTIVE;
+        /**
+         * @generated from field: trading.v1.MarginDirection direction = 2;
+         */
+        this.direction = MarginDirection.LONG;
+        /**
+         * @generated from field: string size = 5;
+         */
+        this.size = "";
+        /**
+         * @generated from field: repeated trading.v1.MarginPositionLeg legs = 6;
+         */
+        this.legs = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginPositionRow().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginPositionRow().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginPositionRow().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginPositionRow, a, b);
+    }
+}
+MarginPositionRow.runtime = proto3;
+MarginPositionRow.typeName = "trading.v1.MarginPositionRow";
+MarginPositionRow.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "status", kind: "enum", T: proto3.getEnumType(MarginPositionStatus) },
+    { no: 2, name: "direction", kind: "enum", T: proto3.getEnumType(MarginDirection) },
+    { no: 3, name: "exposure_token", kind: "message", T: MarginTokenMetadata },
+    { no: 4, name: "counter_token", kind: "message", T: MarginTokenMetadata },
+    { no: 5, name: "size", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 6, name: "legs", kind: "message", T: MarginPositionLeg, repeated: true },
+    { no: 7, name: "entry_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 8, name: "opened_at", kind: "scalar", T: 3 /* ScalarType.INT64 */, opt: true },
+    { no: 9, name: "accrued_interest", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 10, name: "unrealized_pnl", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 11, name: "roe", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 12, name: "equity", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 13, name: "leverage", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 14, name: "oracle_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 15, name: "liquidation_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 16, name: "buffer", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 17, name: "health_factor", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 18, name: "borrow_rate", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 19, name: "max_withdrawable", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 20, name: "closed_at", kind: "scalar", T: 3 /* ScalarType.INT64 */, opt: true },
+    { no: 21, name: "exit_price", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 22, name: "realized_pnl", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+]);
+/**
+ * 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 class MarginIncompleteOpen extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string account = 1;
+         */
+        this.account = "";
+        /**
+         * @generated from field: string sub_id = 2;
+         */
+        this.subId = "";
+        /**
+         * 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;
+         */
+        this.deployed = false;
+        /**
+         * @generated from field: string amount = 5;
+         */
+        this.amount = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginIncompleteOpen().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginIncompleteOpen().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginIncompleteOpen().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginIncompleteOpen, a, b);
+    }
+}
+MarginIncompleteOpen.runtime = proto3;
+MarginIncompleteOpen.typeName = "trading.v1.MarginIncompleteOpen";
+MarginIncompleteOpen.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "account", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "sub_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "deployed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 4, name: "token", kind: "message", T: MarginTokenMetadata },
+    { no: 5, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * 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 class MarginPendingPlan extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string plan_id = 1;
+         */
+        this.planId = "";
+        /**
+         * @generated from field: int64 created_at = 2;
+         */
+        this.createdAt = protoInt64.zero;
+        /**
+         * @generated from field: int32 current_step = 3;
+         */
+        this.currentStep = 0;
+        /**
+         * @generated from field: bool cancellable = 4;
+         */
+        this.cancellable = false;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginPendingPlan().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginPendingPlan().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginPendingPlan().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginPendingPlan, a, b);
+    }
+}
+MarginPendingPlan.runtime = proto3;
+MarginPendingPlan.typeName = "trading.v1.MarginPendingPlan";
+MarginPendingPlan.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "plan_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "created_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+    { no: 3, name: "current_step", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 4, name: "cancellable", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+]);
+/**
+ * @generated from message trading.v1.MarginPositionsRequest
+ */
+export class MarginPositionsRequest extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string swapper = 1;
+         */
+        this.swapper = "";
+        /**
+         * @generated from field: int32 chain_id = 2;
+         */
+        this.chainId = 0;
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginPositionsRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginPositionsRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginPositionsRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginPositionsRequest, a, b);
+    }
+}
+MarginPositionsRequest.runtime = proto3;
+MarginPositionsRequest.typeName = "trading.v1.MarginPositionsRequest";
+MarginPositionsRequest.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "swapper", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "chain_id", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 3, name: "status", kind: "enum", T: proto3.getEnumType(MarginPositionStatus), opt: true },
+    { no: 4, name: "cursor", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 5, name: "limit", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+]);
+/**
+ * @generated from message trading.v1.MarginPositionsResponse
+ */
+export class MarginPositionsResponse extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string request_id = 1;
+         */
+        this.requestId = "";
+        /**
+         * @generated from field: repeated trading.v1.MarginPositionRow positions = 2;
+         */
+        this.positions = [];
+        /**
+         * 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;
+         */
+        this.incompleteOpens = [];
+        /**
+         * @generated from field: repeated trading.v1.MarginPendingPlan pending_plans = 5;
+         */
+        this.pendingPlans = [];
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new MarginPositionsResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new MarginPositionsResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new MarginPositionsResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(MarginPositionsResponse, a, b);
+    }
+}
+MarginPositionsResponse.runtime = proto3;
+MarginPositionsResponse.typeName = "trading.v1.MarginPositionsResponse";
+MarginPositionsResponse.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "request_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "positions", kind: "message", T: MarginPositionRow, repeated: true },
+    { no: 3, name: "next_cursor", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 4, name: "incomplete_opens", kind: "message", T: MarginIncompleteOpen, repeated: true },
+    { no: 5, name: "pending_plans", kind: "message", T: MarginPendingPlan, repeated: true },
+]);