@uniswap/client-trading 0.6.0 → 0.7.0

package/dist/trading/v1/api_pb.js

@@ -622,6 +622,13 @@ export var PlanStepType;
      * @generated from enum value: PLAN_STEP_TYPE_MARGIN_EXECUTE = 16;
      */
     PlanStepType[PlanStepType["MARGIN_EXECUTE"] = 16] = "MARGIN_EXECUTE";
+    /**
+     * Fused Swap→Bridge: one Universal Router transaction that swaps on the
+     * source chain and deposits the output into the Across SpokePool.
+     *
+     * @generated from enum value: PLAN_STEP_TYPE_SWAP_BRIDGE = 17;
+     */
+    PlanStepType[PlanStepType["SWAP_BRIDGE"] = 17] = "SWAP_BRIDGE";
 })(PlanStepType || (PlanStepType = {}));
 // Retrieve enum metadata with: proto3.getEnumType(PlanStepType)
 proto3.util.setEnumType(PlanStepType, "trading.v1.PlanStepType", [
@@ -642,6 +649,7 @@ proto3.util.setEnumType(PlanStepType, "trading.v1.PlanStepType", [
     { no: 14, name: "PLAN_STEP_TYPE_VAULT_DEPOSIT" },
     { no: 15, name: "PLAN_STEP_TYPE_VAULT_WITHDRAW" },
     { no: 16, name: "PLAN_STEP_TYPE_MARGIN_EXECUTE" },
+    { no: 17, name: "PLAN_STEP_TYPE_SWAP_BRIDGE" },
 ]);
 /**
  * Set when the output is a fee taken from the swap; unset for the swapper's
@@ -959,6 +967,107 @@ 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 message trading.v1.Encode7702Request
  */
@@ -9317,3 +9426,596 @@ 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 },
+]);