@zoguxprotocol/proto 0.1.8 → 0.1.9

package/src/codegen/zogux/indexer/events/events.ts

@@ -3,6 +3,8 @@ import { IndexerOrder, IndexerOrderSDKType, IndexerOrderId, IndexerOrderIdSDKTyp
 import { OrderRemovalReason } from "../shared/removal_reason";
 import { PerpetualMarketType } from "../protocol/v1/perpetual";
 import { VaultStatus } from "../protocol/v1/vault";
+import { TokenPair, TokenPairSDKType } from "../../bridge/token";
+import { DepositType } from "../../bridge/bridge_event";
 import * as _m0 from "protobufjs/minimal";
 import { DeepPartial, Long } from "../../../helpers";
 /** Type is the type for funding values. */
@@ -74,6 +76,154 @@ export function fundingEventV1_TypeToJSON(object: FundingEventV1_Type): string {
       return "UNRECOGNIZED";
   }
 }
+/** BridgeDepositStatus tracks the lifecycle of a bridge deposit. */
+
+export enum BridgeDepositStatus {
+  BRIDGE_DEPOSIT_STATUS_UNSPECIFIED = 0,
+
+  /** BRIDGE_DEPOSIT_STATUS_ACKNOWLEDGED - Deposit has been acknowledged by consensus (AcknowledgeBridges). */
+  BRIDGE_DEPOSIT_STATUS_ACKNOWLEDGED = 1,
+
+  /** BRIDGE_DEPOSIT_STATUS_COMPLETED - Deposit has been completed — tokens minted/transferred to user (CompleteBridge). */
+  BRIDGE_DEPOSIT_STATUS_COMPLETED = 2,
+  UNRECOGNIZED = -1,
+}
+export const BridgeDepositStatusSDKType = BridgeDepositStatus;
+export function bridgeDepositStatusFromJSON(object: any): BridgeDepositStatus {
+  switch (object) {
+    case 0:
+    case "BRIDGE_DEPOSIT_STATUS_UNSPECIFIED":
+      return BridgeDepositStatus.BRIDGE_DEPOSIT_STATUS_UNSPECIFIED;
+
+    case 1:
+    case "BRIDGE_DEPOSIT_STATUS_ACKNOWLEDGED":
+      return BridgeDepositStatus.BRIDGE_DEPOSIT_STATUS_ACKNOWLEDGED;
+
+    case 2:
+    case "BRIDGE_DEPOSIT_STATUS_COMPLETED":
+      return BridgeDepositStatus.BRIDGE_DEPOSIT_STATUS_COMPLETED;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return BridgeDepositStatus.UNRECOGNIZED;
+  }
+}
+export function bridgeDepositStatusToJSON(object: BridgeDepositStatus): string {
+  switch (object) {
+    case BridgeDepositStatus.BRIDGE_DEPOSIT_STATUS_UNSPECIFIED:
+      return "BRIDGE_DEPOSIT_STATUS_UNSPECIFIED";
+
+    case BridgeDepositStatus.BRIDGE_DEPOSIT_STATUS_ACKNOWLEDGED:
+      return "BRIDGE_DEPOSIT_STATUS_ACKNOWLEDGED";
+
+    case BridgeDepositStatus.BRIDGE_DEPOSIT_STATUS_COMPLETED:
+      return "BRIDGE_DEPOSIT_STATUS_COMPLETED";
+
+    case BridgeDepositStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** BridgeWithdrawalStatus tracks the lifecycle of a bridge withdrawal. */
+
+export enum BridgeWithdrawalStatus {
+  BRIDGE_WITHDRAWAL_STATUS_UNSPECIFIED = 0,
+
+  /** BRIDGE_WITHDRAWAL_STATUS_PENDING - Withdrawal requested, funds locked (RequestWithdrawal). */
+  BRIDGE_WITHDRAWAL_STATUS_PENDING = 1,
+
+  /** BRIDGE_WITHDRAWAL_STATUS_SIGNED - TSS threshold signatures collected (SubmitWithdrawalSignature). */
+  BRIDGE_WITHDRAWAL_STATUS_SIGNED = 2,
+
+  /** BRIDGE_WITHDRAWAL_STATUS_SUBMITTED - Submitted to EVM chain, waiting for confirmation (MarkWithdrawalSubmitted). */
+  BRIDGE_WITHDRAWAL_STATUS_SUBMITTED = 3,
+
+  /** BRIDGE_WITHDRAWAL_STATUS_COMPLETED - Confirmed on EVM chain (ConfirmWithdrawal). */
+  BRIDGE_WITHDRAWAL_STATUS_COMPLETED = 4,
+
+  /** BRIDGE_WITHDRAWAL_STATUS_CANCELLED - Cancelled, funds refunded (CancelWithdrawal). */
+  BRIDGE_WITHDRAWAL_STATUS_CANCELLED = 5,
+
+  /** BRIDGE_WITHDRAWAL_STATUS_FAILED - Failed (e.g. TSS timeout, EVM revert); funds remain locked until resolved (FailWithdrawal). */
+  BRIDGE_WITHDRAWAL_STATUS_FAILED = 6,
+
+  /** BRIDGE_WITHDRAWAL_STATUS_RESOLVED - Resolved by admin; locked funds sent to destination (ResolveWithdrawal). */
+  BRIDGE_WITHDRAWAL_STATUS_RESOLVED = 7,
+  UNRECOGNIZED = -1,
+}
+export const BridgeWithdrawalStatusSDKType = BridgeWithdrawalStatus;
+export function bridgeWithdrawalStatusFromJSON(object: any): BridgeWithdrawalStatus {
+  switch (object) {
+    case 0:
+    case "BRIDGE_WITHDRAWAL_STATUS_UNSPECIFIED":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_UNSPECIFIED;
+
+    case 1:
+    case "BRIDGE_WITHDRAWAL_STATUS_PENDING":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_PENDING;
+
+    case 2:
+    case "BRIDGE_WITHDRAWAL_STATUS_SIGNED":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_SIGNED;
+
+    case 3:
+    case "BRIDGE_WITHDRAWAL_STATUS_SUBMITTED":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_SUBMITTED;
+
+    case 4:
+    case "BRIDGE_WITHDRAWAL_STATUS_COMPLETED":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_COMPLETED;
+
+    case 5:
+    case "BRIDGE_WITHDRAWAL_STATUS_CANCELLED":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_CANCELLED;
+
+    case 6:
+    case "BRIDGE_WITHDRAWAL_STATUS_FAILED":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_FAILED;
+
+    case 7:
+    case "BRIDGE_WITHDRAWAL_STATUS_RESOLVED":
+      return BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_RESOLVED;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return BridgeWithdrawalStatus.UNRECOGNIZED;
+  }
+}
+export function bridgeWithdrawalStatusToJSON(object: BridgeWithdrawalStatus): string {
+  switch (object) {
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_UNSPECIFIED:
+      return "BRIDGE_WITHDRAWAL_STATUS_UNSPECIFIED";
+
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_PENDING:
+      return "BRIDGE_WITHDRAWAL_STATUS_PENDING";
+
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_SIGNED:
+      return "BRIDGE_WITHDRAWAL_STATUS_SIGNED";
+
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_SUBMITTED:
+      return "BRIDGE_WITHDRAWAL_STATUS_SUBMITTED";
+
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_COMPLETED:
+      return "BRIDGE_WITHDRAWAL_STATUS_COMPLETED";
+
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_CANCELLED:
+      return "BRIDGE_WITHDRAWAL_STATUS_CANCELLED";
+
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_FAILED:
+      return "BRIDGE_WITHDRAWAL_STATUS_FAILED";
+
+    case BridgeWithdrawalStatus.BRIDGE_WITHDRAWAL_STATUS_RESOLVED:
+      return "BRIDGE_WITHDRAWAL_STATUS_RESOLVED";
+
+    case BridgeWithdrawalStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
 /**
  * FundingUpdate is used for funding update events and includes a funding
  * value and an optional funding index that correspond to a perpetual market.
@@ -684,6 +834,15 @@ export interface AssetCreateEventV1 {
    */
 
   atomicResolution: number;
+  /**
+   * The name of base denomination unit of the Asset (e.g. `uatom`, `ibc/xxxxx`).
+   * Must be unique and match the denom used in sdk.Coin in x/bank.
+   */
+
+  denom: string;
+  /** The exponent of converting one unit of denom to a full coin. */
+
+  denomExponent: number;
 }
 /**
  * AssetCreateEventV1 message contains all the information about an new Asset on
@@ -696,6 +855,8 @@ export interface AssetCreateEventV1SDKType {
   has_market: boolean;
   market_id: number;
   atomic_resolution: number;
+  denom: string;
+  denom_exponent: number;
 }
 /**
  * PerpetualMarketCreateEventV1 message contains all the information about a
@@ -1528,6 +1689,80 @@ export interface UpsertVaultEventV1SDKType {
   clob_pair_id: number;
   status: VaultStatus;
 }
+/** Event emitted when bridge token pairs are set (MsgSetTokenPairs). */
+
+export interface SetTokenPairsEventV1 {
+  tokenPairs: TokenPair[];
+}
+/** Event emitted when bridge token pairs are set (MsgSetTokenPairs). */
+
+export interface SetTokenPairsEventV1SDKType {
+  token_pairs: TokenPairSDKType[];
+}
+/** Event emitted at each deposit state transition (EVM → Zogux). */
+
+export interface BridgeDepositEventV1 {
+  id: number;
+  address: string;
+  coinDenom: string;
+  coinAmount: string;
+  ethBlockHeight: Long;
+  status: BridgeDepositStatus;
+  /** Where to credit the bridged funds: main account, spot, or perps (0=MAIN, 1=SPOT, 2=PREPS). */
+
+  depositType: DepositType;
+  /** EVM transaction hash of the deposit. */
+
+  evmTxHash: string;
+  /** Transaction hash of the Zogux chain transaction that finalized the bridge deposit. */
+
+  zoguxTxHash: string;
+}
+/** Event emitted at each deposit state transition (EVM → Zogux). */
+
+export interface BridgeDepositEventV1SDKType {
+  id: number;
+  address: string;
+  coin_denom: string;
+  coin_amount: string;
+  eth_block_height: Long;
+  status: BridgeDepositStatus;
+  deposit_type: DepositType;
+  evm_tx_hash: string;
+  zogux_tx_hash: string;
+}
+/** Event emitted at each withdrawal state transition (Zogux → EVM). */
+
+export interface BridgeWithdrawalEventV1 {
+  withdrawalId: string;
+  fromAddress: string;
+  toAddress: string;
+  amount: string;
+  chainId: Long;
+  denom: string;
+  nonce: Long;
+  status: BridgeWithdrawalStatus;
+  blockHeight: Long;
+  evmTxHash: string;
+  cancelReason: string;
+  message: Uint8Array;
+}
+/** Event emitted at each withdrawal state transition (Zogux → EVM). */
+
+export interface BridgeWithdrawalEventV1SDKType {
+  withdrawal_id: string;
+  from_address: string;
+  to_address: string;
+  amount: string;
+  chain_id: Long;
+  denom: string;
+  nonce: Long;
+  status: BridgeWithdrawalStatus;
+  block_height: Long;
+  evm_tx_hash: string;
+  cancel_reason: string;
+  message: Uint8Array;
+}
 
 function createBaseFundingUpdateV1(): FundingUpdateV1 {
   return {
@@ -3010,7 +3245,9 @@ function createBaseAssetCreateEventV1(): AssetCreateEventV1 {
     symbol: "",
     hasMarket: false,
     marketId: 0,
-    atomicResolution: 0
+    atomicResolution: 0,
+    denom: "",
+    denomExponent: 0
   };
 }
 
@@ -3036,6 +3273,14 @@ export const AssetCreateEventV1 = {
       writer.uint32(40).sint32(message.atomicResolution);
     }
 
+    if (message.denom !== "") {
+      writer.uint32(50).string(message.denom);
+    }
+
+    if (message.denomExponent !== 0) {
+      writer.uint32(56).sint32(message.denomExponent);
+    }
+
     return writer;
   },
 
@@ -3068,6 +3313,14 @@ export const AssetCreateEventV1 = {
           message.atomicResolution = reader.sint32();
           break;
 
+        case 6:
+          message.denom = reader.string();
+          break;
+
+        case 7:
+          message.denomExponent = reader.sint32();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -3084,6 +3337,8 @@ export const AssetCreateEventV1 = {
     message.hasMarket = object.hasMarket ?? false;
     message.marketId = object.marketId ?? 0;
     message.atomicResolution = object.atomicResolution ?? 0;
+    message.denom = object.denom ?? "";
+    message.denomExponent = object.denomExponent ?? 0;
     return message;
   }
 
@@ -4602,4 +4857,329 @@ export const UpsertVaultEventV1 = {
     return message;
   }
 
+};
+
+function createBaseSetTokenPairsEventV1(): SetTokenPairsEventV1 {
+  return {
+    tokenPairs: []
+  };
+}
+
+export const SetTokenPairsEventV1 = {
+  encode(message: SetTokenPairsEventV1, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.tokenPairs) {
+      TokenPair.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SetTokenPairsEventV1 {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSetTokenPairsEventV1();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.tokenPairs.push(TokenPair.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SetTokenPairsEventV1>): SetTokenPairsEventV1 {
+    const message = createBaseSetTokenPairsEventV1();
+    message.tokenPairs = object.tokenPairs?.map(e => TokenPair.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseBridgeDepositEventV1(): BridgeDepositEventV1 {
+  return {
+    id: 0,
+    address: "",
+    coinDenom: "",
+    coinAmount: "",
+    ethBlockHeight: Long.UZERO,
+    status: 0,
+    depositType: 0,
+    evmTxHash: "",
+    zoguxTxHash: ""
+  };
+}
+
+export const BridgeDepositEventV1 = {
+  encode(message: BridgeDepositEventV1, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    if (message.address !== "") {
+      writer.uint32(18).string(message.address);
+    }
+
+    if (message.coinDenom !== "") {
+      writer.uint32(26).string(message.coinDenom);
+    }
+
+    if (message.coinAmount !== "") {
+      writer.uint32(34).string(message.coinAmount);
+    }
+
+    if (!message.ethBlockHeight.isZero()) {
+      writer.uint32(40).uint64(message.ethBlockHeight);
+    }
+
+    if (message.status !== 0) {
+      writer.uint32(48).int32(message.status);
+    }
+
+    if (message.depositType !== 0) {
+      writer.uint32(56).int32(message.depositType);
+    }
+
+    if (message.evmTxHash !== "") {
+      writer.uint32(66).string(message.evmTxHash);
+    }
+
+    if (message.zoguxTxHash !== "") {
+      writer.uint32(74).string(message.zoguxTxHash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BridgeDepositEventV1 {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBridgeDepositEventV1();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        case 2:
+          message.address = reader.string();
+          break;
+
+        case 3:
+          message.coinDenom = reader.string();
+          break;
+
+        case 4:
+          message.coinAmount = reader.string();
+          break;
+
+        case 5:
+          message.ethBlockHeight = (reader.uint64() as Long);
+          break;
+
+        case 6:
+          message.status = (reader.int32() as any);
+          break;
+
+        case 7:
+          message.depositType = (reader.int32() as any);
+          break;
+
+        case 8:
+          message.evmTxHash = reader.string();
+          break;
+
+        case 9:
+          message.zoguxTxHash = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BridgeDepositEventV1>): BridgeDepositEventV1 {
+    const message = createBaseBridgeDepositEventV1();
+    message.id = object.id ?? 0;
+    message.address = object.address ?? "";
+    message.coinDenom = object.coinDenom ?? "";
+    message.coinAmount = object.coinAmount ?? "";
+    message.ethBlockHeight = object.ethBlockHeight !== undefined && object.ethBlockHeight !== null ? Long.fromValue(object.ethBlockHeight) : Long.UZERO;
+    message.status = object.status ?? 0;
+    message.depositType = object.depositType ?? 0;
+    message.evmTxHash = object.evmTxHash ?? "";
+    message.zoguxTxHash = object.zoguxTxHash ?? "";
+    return message;
+  }
+
+};
+
+function createBaseBridgeWithdrawalEventV1(): BridgeWithdrawalEventV1 {
+  return {
+    withdrawalId: "",
+    fromAddress: "",
+    toAddress: "",
+    amount: "",
+    chainId: Long.ZERO,
+    denom: "",
+    nonce: Long.UZERO,
+    status: 0,
+    blockHeight: Long.UZERO,
+    evmTxHash: "",
+    cancelReason: "",
+    message: new Uint8Array()
+  };
+}
+
+export const BridgeWithdrawalEventV1 = {
+  encode(message: BridgeWithdrawalEventV1, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.withdrawalId !== "") {
+      writer.uint32(10).string(message.withdrawalId);
+    }
+
+    if (message.fromAddress !== "") {
+      writer.uint32(18).string(message.fromAddress);
+    }
+
+    if (message.toAddress !== "") {
+      writer.uint32(26).string(message.toAddress);
+    }
+
+    if (message.amount !== "") {
+      writer.uint32(34).string(message.amount);
+    }
+
+    if (!message.chainId.isZero()) {
+      writer.uint32(40).int64(message.chainId);
+    }
+
+    if (message.denom !== "") {
+      writer.uint32(50).string(message.denom);
+    }
+
+    if (!message.nonce.isZero()) {
+      writer.uint32(56).uint64(message.nonce);
+    }
+
+    if (message.status !== 0) {
+      writer.uint32(64).int32(message.status);
+    }
+
+    if (!message.blockHeight.isZero()) {
+      writer.uint32(72).uint64(message.blockHeight);
+    }
+
+    if (message.evmTxHash !== "") {
+      writer.uint32(82).string(message.evmTxHash);
+    }
+
+    if (message.cancelReason !== "") {
+      writer.uint32(90).string(message.cancelReason);
+    }
+
+    if (message.message.length !== 0) {
+      writer.uint32(98).bytes(message.message);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BridgeWithdrawalEventV1 {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBridgeWithdrawalEventV1();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.withdrawalId = reader.string();
+          break;
+
+        case 2:
+          message.fromAddress = reader.string();
+          break;
+
+        case 3:
+          message.toAddress = reader.string();
+          break;
+
+        case 4:
+          message.amount = reader.string();
+          break;
+
+        case 5:
+          message.chainId = (reader.int64() as Long);
+          break;
+
+        case 6:
+          message.denom = reader.string();
+          break;
+
+        case 7:
+          message.nonce = (reader.uint64() as Long);
+          break;
+
+        case 8:
+          message.status = (reader.int32() as any);
+          break;
+
+        case 9:
+          message.blockHeight = (reader.uint64() as Long);
+          break;
+
+        case 10:
+          message.evmTxHash = reader.string();
+          break;
+
+        case 11:
+          message.cancelReason = reader.string();
+          break;
+
+        case 12:
+          message.message = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BridgeWithdrawalEventV1>): BridgeWithdrawalEventV1 {
+    const message = createBaseBridgeWithdrawalEventV1();
+    message.withdrawalId = object.withdrawalId ?? "";
+    message.fromAddress = object.fromAddress ?? "";
+    message.toAddress = object.toAddress ?? "";
+    message.amount = object.amount ?? "";
+    message.chainId = object.chainId !== undefined && object.chainId !== null ? Long.fromValue(object.chainId) : Long.ZERO;
+    message.denom = object.denom ?? "";
+    message.nonce = object.nonce !== undefined && object.nonce !== null ? Long.fromValue(object.nonce) : Long.UZERO;
+    message.status = object.status ?? 0;
+    message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? Long.fromValue(object.blockHeight) : Long.UZERO;
+    message.evmTxHash = object.evmTxHash ?? "";
+    message.cancelReason = object.cancelReason ?? "";
+    message.message = object.message ?? new Uint8Array();
+    return message;
+  }
+
 };