@zoguxprotocol/proto 0.1.6 → 0.1.7

package/src/codegen/zogux/sending/tx.rpc.msg.ts

@@ -1,12 +1,15 @@
-import { MsgDepositToSubaccount, MsgWithdrawFromSubaccount, MsgSendFromModuleToAccount } from "./transfer";
+import { MsgCreateTransferSpot, MsgDepositToSubaccount, MsgWithdrawFromSubaccount, MsgSendFromModuleToAccount, MsgDepositToSpot, MsgWithdrawFromSpot, MsgTransferSpotToPerp, MsgTransferPerpToSpot } from "./transfer";
 import { Rpc } from "../../helpers";
 import * as _m0 from "protobufjs/minimal";
-import { MsgCreateTransfer, MsgCreateTransferResponse, MsgDepositToSubaccountResponse, MsgWithdrawFromSubaccountResponse, MsgSendFromModuleToAccountResponse } from "./tx";
+import { MsgCreateTransfer, MsgCreateTransferResponse, MsgCreateTransferSpotResponse, MsgDepositToSubaccountResponse, MsgWithdrawFromSubaccountResponse, MsgSendFromModuleToAccountResponse, MsgDepositToSpotResponse, MsgWithdrawFromSpotResponse, MsgTransferSpotToPerpResponse, MsgTransferPerpToSpotResponse } from "./tx";
 /** Msg defines the Msg service. */
 
 export interface Msg {
   /** CreateTransfer initiates a new transfer between subaccounts. */
   createTransfer(request: MsgCreateTransfer): Promise<MsgCreateTransferResponse>;
+  /** CreateTransferSpot initiates a new transfer of spot assets between subaccounts. */
+
+  createTransferSpot(request: MsgCreateTransferSpot): Promise<MsgCreateTransferSpotResponse>;
   /**
    * DepositToSubaccount initiates a new transfer from an `x/bank` account
    * to an `x/subaccounts` subaccount.
@@ -25,6 +28,30 @@ export interface Msg {
    */
 
   sendFromModuleToAccount(request: MsgSendFromModuleToAccount): Promise<MsgSendFromModuleToAccountResponse>;
+  /**
+   * DepositToSpot initiates a new transfer from an `x/bank` account
+   * to an `x/subaccounts` subaccount's spot balance.
+   */
+
+  depositToSpot(request: MsgDepositToSpot): Promise<MsgDepositToSpotResponse>;
+  /**
+   * WithdrawFromSpot initiates a new transfer from an `x/subaccounts`
+   * subaccount's spot balance to an `x/bank` account.
+   */
+
+  withdrawFromSpot(request: MsgWithdrawFromSpot): Promise<MsgWithdrawFromSpotResponse>;
+  /**
+   * TransferSpotToPerp transfers funds from spot balance to perpetual
+   * collateral within the same subaccount.
+   */
+
+  transferSpotToPerp(request: MsgTransferSpotToPerp): Promise<MsgTransferSpotToPerpResponse>;
+  /**
+   * TransferPerpToSpot transfers funds from perpetual collateral to
+   * spot balance. Can transfer within the same subaccount or between different subaccounts.
+   */
+
+  transferPerpToSpot(request: MsgTransferPerpToSpot): Promise<MsgTransferPerpToSpotResponse>;
 }
 export class MsgClientImpl implements Msg {
   private readonly rpc: Rpc;
@@ -32,9 +59,14 @@ export class MsgClientImpl implements Msg {
   constructor(rpc: Rpc) {
     this.rpc = rpc;
     this.createTransfer = this.createTransfer.bind(this);
+    this.createTransferSpot = this.createTransferSpot.bind(this);
     this.depositToSubaccount = this.depositToSubaccount.bind(this);
     this.withdrawFromSubaccount = this.withdrawFromSubaccount.bind(this);
     this.sendFromModuleToAccount = this.sendFromModuleToAccount.bind(this);
+    this.depositToSpot = this.depositToSpot.bind(this);
+    this.withdrawFromSpot = this.withdrawFromSpot.bind(this);
+    this.transferSpotToPerp = this.transferSpotToPerp.bind(this);
+    this.transferPerpToSpot = this.transferPerpToSpot.bind(this);
   }
 
   createTransfer(request: MsgCreateTransfer): Promise<MsgCreateTransferResponse> {
@@ -43,6 +75,12 @@ export class MsgClientImpl implements Msg {
     return promise.then(data => MsgCreateTransferResponse.decode(new _m0.Reader(data)));
   }
 
+  createTransferSpot(request: MsgCreateTransferSpot): Promise<MsgCreateTransferSpotResponse> {
+    const data = MsgCreateTransferSpot.encode(request).finish();
+    const promise = this.rpc.request("zogux.sending.Msg", "CreateTransferSpot", data);
+    return promise.then(data => MsgCreateTransferSpotResponse.decode(new _m0.Reader(data)));
+  }
+
   depositToSubaccount(request: MsgDepositToSubaccount): Promise<MsgDepositToSubaccountResponse> {
     const data = MsgDepositToSubaccount.encode(request).finish();
     const promise = this.rpc.request("zogux.sending.Msg", "DepositToSubaccount", data);
@@ -61,4 +99,28 @@ export class MsgClientImpl implements Msg {
     return promise.then(data => MsgSendFromModuleToAccountResponse.decode(new _m0.Reader(data)));
   }
 
+  depositToSpot(request: MsgDepositToSpot): Promise<MsgDepositToSpotResponse> {
+    const data = MsgDepositToSpot.encode(request).finish();
+    const promise = this.rpc.request("zogux.sending.Msg", "DepositToSpot", data);
+    return promise.then(data => MsgDepositToSpotResponse.decode(new _m0.Reader(data)));
+  }
+
+  withdrawFromSpot(request: MsgWithdrawFromSpot): Promise<MsgWithdrawFromSpotResponse> {
+    const data = MsgWithdrawFromSpot.encode(request).finish();
+    const promise = this.rpc.request("zogux.sending.Msg", "WithdrawFromSpot", data);
+    return promise.then(data => MsgWithdrawFromSpotResponse.decode(new _m0.Reader(data)));
+  }
+
+  transferSpotToPerp(request: MsgTransferSpotToPerp): Promise<MsgTransferSpotToPerpResponse> {
+    const data = MsgTransferSpotToPerp.encode(request).finish();
+    const promise = this.rpc.request("zogux.sending.Msg", "TransferSpotToPerp", data);
+    return promise.then(data => MsgTransferSpotToPerpResponse.decode(new _m0.Reader(data)));
+  }
+
+  transferPerpToSpot(request: MsgTransferPerpToSpot): Promise<MsgTransferPerpToSpotResponse> {
+    const data = MsgTransferPerpToSpot.encode(request).finish();
+    const promise = this.rpc.request("zogux.sending.Msg", "TransferPerpToSpot", data);
+    return promise.then(data => MsgTransferPerpToSpotResponse.decode(new _m0.Reader(data)));
+  }
+
 }

package/src/codegen/zogux/sending/tx.ts

@@ -18,6 +18,12 @@ export interface MsgCreateTransferResponse {}
 /** MsgCreateTransferResponse is a response type used for new transfers. */
 
 export interface MsgCreateTransferResponseSDKType {}
+/** MsgCreateTransferSpotResponse is a response type used for new spot transfers. */
+
+export interface MsgCreateTransferSpotResponse {}
+/** MsgCreateTransferSpotResponse is a response type used for new spot transfers. */
+
+export interface MsgCreateTransferSpotResponseSDKType {}
 /**
  * MsgDepositToSubaccountResponse is a response type used for new
  * account-to-subaccount transfers.
@@ -54,6 +60,54 @@ export interface MsgSendFromModuleToAccountResponse {}
  */
 
 export interface MsgSendFromModuleToAccountResponseSDKType {}
+/**
+ * MsgDepositToSpotResponse is a response type used for new
+ * account-to-spot transfers.
+ */
+
+export interface MsgDepositToSpotResponse {}
+/**
+ * MsgDepositToSpotResponse is a response type used for new
+ * account-to-spot transfers.
+ */
+
+export interface MsgDepositToSpotResponseSDKType {}
+/**
+ * MsgWithdrawFromSpotResponse is a response type used for new
+ * spot-to-account transfers.
+ */
+
+export interface MsgWithdrawFromSpotResponse {}
+/**
+ * MsgWithdrawFromSpotResponse is a response type used for new
+ * spot-to-account transfers.
+ */
+
+export interface MsgWithdrawFromSpotResponseSDKType {}
+/**
+ * MsgTransferSpotToPerpResponse is a response type used for
+ * spot-to-perp transfers within a subaccount.
+ */
+
+export interface MsgTransferSpotToPerpResponse {}
+/**
+ * MsgTransferSpotToPerpResponse is a response type used for
+ * spot-to-perp transfers within a subaccount.
+ */
+
+export interface MsgTransferSpotToPerpResponseSDKType {}
+/**
+ * MsgTransferPerpToSpotResponse is a response type used for
+ * perp-to-spot transfers (same or different subaccounts).
+ */
+
+export interface MsgTransferPerpToSpotResponse {}
+/**
+ * MsgTransferPerpToSpotResponse is a response type used for
+ * perp-to-spot transfers (same or different subaccounts).
+ */
+
+export interface MsgTransferPerpToSpotResponseSDKType {}
 
 function createBaseMsgCreateTransfer(): MsgCreateTransfer {
   return {
@@ -134,6 +188,40 @@ export const MsgCreateTransferResponse = {
 
 };
 
+function createBaseMsgCreateTransferSpotResponse(): MsgCreateTransferSpotResponse {
+  return {};
+}
+
+export const MsgCreateTransferSpotResponse = {
+  encode(_: MsgCreateTransferSpotResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateTransferSpotResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCreateTransferSpotResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgCreateTransferSpotResponse>): MsgCreateTransferSpotResponse {
+    const message = createBaseMsgCreateTransferSpotResponse();
+    return message;
+  }
+
+};
+
 function createBaseMsgDepositToSubaccountResponse(): MsgDepositToSubaccountResponse {
   return {};
 }
@@ -234,4 +322,140 @@ export const MsgSendFromModuleToAccountResponse = {
     return message;
   }
 
+};
+
+function createBaseMsgDepositToSpotResponse(): MsgDepositToSpotResponse {
+  return {};
+}
+
+export const MsgDepositToSpotResponse = {
+  encode(_: MsgDepositToSpotResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDepositToSpotResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDepositToSpotResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgDepositToSpotResponse>): MsgDepositToSpotResponse {
+    const message = createBaseMsgDepositToSpotResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgWithdrawFromSpotResponse(): MsgWithdrawFromSpotResponse {
+  return {};
+}
+
+export const MsgWithdrawFromSpotResponse = {
+  encode(_: MsgWithdrawFromSpotResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgWithdrawFromSpotResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgWithdrawFromSpotResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgWithdrawFromSpotResponse>): MsgWithdrawFromSpotResponse {
+    const message = createBaseMsgWithdrawFromSpotResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgTransferSpotToPerpResponse(): MsgTransferSpotToPerpResponse {
+  return {};
+}
+
+export const MsgTransferSpotToPerpResponse = {
+  encode(_: MsgTransferSpotToPerpResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTransferSpotToPerpResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTransferSpotToPerpResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgTransferSpotToPerpResponse>): MsgTransferSpotToPerpResponse {
+    const message = createBaseMsgTransferSpotToPerpResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgTransferPerpToSpotResponse(): MsgTransferPerpToSpotResponse {
+  return {};
+}
+
+export const MsgTransferPerpToSpotResponse = {
+  encode(_: MsgTransferPerpToSpotResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTransferPerpToSpotResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTransferPerpToSpotResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgTransferPerpToSpotResponse>): MsgTransferPerpToSpotResponse {
+    const message = createBaseMsgTransferPerpToSpotResponse();
+    return message;
+  }
+
 };

package/src/codegen/zogux/subaccounts/spot_position.ts

@@ -0,0 +1,82 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * SpotAssetLocked tracks locked funds for pending spot orders for a specific asset.
+ * This is used to ensure users have sufficient balance when placing limit orders.
+ */
+
+export interface SpotAssetLocked {
+  /** The Id of the Asset being locked (e.g., USDC = 0, BTC = 1). */
+  assetId: number;
+  /**
+   * Quantums of this asset locked for pending spot orders.
+   * For BUY orders: quote asset (e.g., USDC) is locked.
+   * For SELL orders: base asset (e.g., BTC) is locked.
+   */
+
+  quantumsLocked: Uint8Array;
+}
+/**
+ * SpotAssetLocked tracks locked funds for pending spot orders for a specific asset.
+ * This is used to ensure users have sufficient balance when placing limit orders.
+ */
+
+export interface SpotAssetLockedSDKType {
+  asset_id: number;
+  quantums_locked: Uint8Array;
+}
+
+function createBaseSpotAssetLocked(): SpotAssetLocked {
+  return {
+    assetId: 0,
+    quantumsLocked: new Uint8Array()
+  };
+}
+
+export const SpotAssetLocked = {
+  encode(message: SpotAssetLocked, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.assetId !== 0) {
+      writer.uint32(8).uint32(message.assetId);
+    }
+
+    if (message.quantumsLocked.length !== 0) {
+      writer.uint32(18).bytes(message.quantumsLocked);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SpotAssetLocked {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSpotAssetLocked();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.assetId = reader.uint32();
+          break;
+
+        case 2:
+          message.quantumsLocked = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SpotAssetLocked>): SpotAssetLocked {
+    const message = createBaseSpotAssetLocked();
+    message.assetId = object.assetId ?? 0;
+    message.quantumsLocked = object.quantumsLocked ?? new Uint8Array();
+    return message;
+  }
+
+};

package/src/codegen/zogux/subaccounts/subaccount.ts

@@ -1,5 +1,6 @@
 import { AssetPosition, AssetPositionSDKType } from "./asset_position";
 import { PerpetualPosition, PerpetualPositionSDKType } from "./perpetual_position";
+import { SpotAssetLocked, SpotAssetLockedSDKType } from "./spot_position";
 import * as _m0 from "protobufjs/minimal";
 import { DeepPartial } from "../../helpers";
 /** SubaccountId defines a unique identifier for a Subaccount. */
@@ -29,7 +30,8 @@ export interface Subaccount {
   /** The Id of the Subaccount */
   id?: SubaccountId;
   /**
-   * All `AssetPosition`s associated with this subaccount.
+   * All `AssetPosition`s associated with this subaccount for perpetual trading.
+   * This is the collateral/margin for perpetual positions.
    * Always sorted ascending by `asset_id`.
    */
 
@@ -46,6 +48,19 @@ export interface Subaccount {
    */
 
   marginEnabled: boolean;
+  /**
+   * All `AssetPosition`s for spot trading balances.
+   * This is separate from perpetual collateral to isolate risk.
+   * Always sorted ascending by `asset_id`.
+   */
+
+  spotAssetPositions: AssetPosition[];
+  /**
+   * All locked funds for pending spot orders.
+   * Always sorted ascending by `asset_id`.
+   */
+
+  spotLockedBalances: SpotAssetLocked[];
 }
 /**
  * Subaccount defines a single sub-account for a given address.
@@ -57,6 +72,8 @@ export interface SubaccountSDKType {
   asset_positions: AssetPositionSDKType[];
   perpetual_positions: PerpetualPositionSDKType[];
   margin_enabled: boolean;
+  spot_asset_positions: AssetPositionSDKType[];
+  spot_locked_balances: SpotAssetLockedSDKType[];
 }
 
 function createBaseSubaccountId(): SubaccountId {
@@ -119,7 +136,9 @@ function createBaseSubaccount(): Subaccount {
     id: undefined,
     assetPositions: [],
     perpetualPositions: [],
-    marginEnabled: false
+    marginEnabled: false,
+    spotAssetPositions: [],
+    spotLockedBalances: []
   };
 }
 
@@ -141,6 +160,14 @@ export const Subaccount = {
       writer.uint32(32).bool(message.marginEnabled);
     }
 
+    for (const v of message.spotAssetPositions) {
+      AssetPosition.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+
+    for (const v of message.spotLockedBalances) {
+      SpotAssetLocked.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -169,6 +196,14 @@ export const Subaccount = {
           message.marginEnabled = reader.bool();
           break;
 
+        case 5:
+          message.spotAssetPositions.push(AssetPosition.decode(reader, reader.uint32()));
+          break;
+
+        case 6:
+          message.spotLockedBalances.push(SpotAssetLocked.decode(reader, reader.uint32()));
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -184,6 +219,8 @@ export const Subaccount = {
     message.assetPositions = object.assetPositions?.map(e => AssetPosition.fromPartial(e)) || [];
     message.perpetualPositions = object.perpetualPositions?.map(e => PerpetualPosition.fromPartial(e)) || [];
     message.marginEnabled = object.marginEnabled ?? false;
+    message.spotAssetPositions = object.spotAssetPositions?.map(e => AssetPosition.fromPartial(e)) || [];
+    message.spotLockedBalances = object.spotLockedBalances?.map(e => SpotAssetLocked.fromPartial(e)) || [];
     return message;
   }
 

package/src/codegen/zogux/subaccounts/tx.rpc.msg.ts

@@ -0,0 +1,27 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgRecoverySpotBalance, MsgRecoverySpotBalanceResponse } from "./tx";
+/** Msg defines the subaccounts Msg service. */
+
+export interface Msg {
+  /**
+   * RecoverySpotBalance is an admin function to recover spot balance discrepancies.
+   * This should only be called by authorized admin/governance addresses.
+   */
+  recoverySpotBalance(request: MsgRecoverySpotBalance): Promise<MsgRecoverySpotBalanceResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.recoverySpotBalance = this.recoverySpotBalance.bind(this);
+  }
+
+  recoverySpotBalance(request: MsgRecoverySpotBalance): Promise<MsgRecoverySpotBalanceResponse> {
+    const data = MsgRecoverySpotBalance.encode(request).finish();
+    const promise = this.rpc.request("zogux.subaccounts.Msg", "RecoverySpotBalance", data);
+    return promise.then(data => MsgRecoverySpotBalanceResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/zogux/subaccounts/tx.ts

@@ -0,0 +1,144 @@
+import { SubaccountId, SubaccountIdSDKType } from "./subaccount";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** MsgRecoverySpotBalance is the request type for recovering spot balance discrepancies. */
+
+export interface MsgRecoverySpotBalance {
+  /** Authority is the address authorized to execute this message (typically governance). */
+  authority: string;
+  /** SubaccountId identifies the subaccount to recover. */
+
+  subaccountId?: SubaccountId;
+  /** AssetId is the asset ID to recover balance for. */
+
+  assetId: number;
+  /**
+   * DeltaAmount is the amount to add (positive) or subtract (negative) to recover the balance.
+   * This is a string representation of a big.Int.
+   */
+
+  deltaAmount: string;
+}
+/** MsgRecoverySpotBalance is the request type for recovering spot balance discrepancies. */
+
+export interface MsgRecoverySpotBalanceSDKType {
+  authority: string;
+  subaccount_id?: SubaccountIdSDKType;
+  asset_id: number;
+  delta_amount: string;
+}
+/** MsgRecoverySpotBalanceResponse is the response type for MsgRecoverySpotBalance. */
+
+export interface MsgRecoverySpotBalanceResponse {}
+/** MsgRecoverySpotBalanceResponse is the response type for MsgRecoverySpotBalance. */
+
+export interface MsgRecoverySpotBalanceResponseSDKType {}
+
+function createBaseMsgRecoverySpotBalance(): MsgRecoverySpotBalance {
+  return {
+    authority: "",
+    subaccountId: undefined,
+    assetId: 0,
+    deltaAmount: ""
+  };
+}
+
+export const MsgRecoverySpotBalance = {
+  encode(message: MsgRecoverySpotBalance, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    if (message.subaccountId !== undefined) {
+      SubaccountId.encode(message.subaccountId, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.assetId !== 0) {
+      writer.uint32(24).uint32(message.assetId);
+    }
+
+    if (message.deltaAmount !== "") {
+      writer.uint32(34).string(message.deltaAmount);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRecoverySpotBalance {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRecoverySpotBalance();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.subaccountId = SubaccountId.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.assetId = reader.uint32();
+          break;
+
+        case 4:
+          message.deltaAmount = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgRecoverySpotBalance>): MsgRecoverySpotBalance {
+    const message = createBaseMsgRecoverySpotBalance();
+    message.authority = object.authority ?? "";
+    message.subaccountId = object.subaccountId !== undefined && object.subaccountId !== null ? SubaccountId.fromPartial(object.subaccountId) : undefined;
+    message.assetId = object.assetId ?? 0;
+    message.deltaAmount = object.deltaAmount ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgRecoverySpotBalanceResponse(): MsgRecoverySpotBalanceResponse {
+  return {};
+}
+
+export const MsgRecoverySpotBalanceResponse = {
+  encode(_: MsgRecoverySpotBalanceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRecoverySpotBalanceResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRecoverySpotBalanceResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgRecoverySpotBalanceResponse>): MsgRecoverySpotBalanceResponse {
+    const message = createBaseMsgRecoverySpotBalanceResponse();
+    return message;
+  }
+
+};