@zoguxprotocol/proto 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoguxprotocol/proto",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "access": "public",
   "description": "Protos for Zogux protocol",
   "author": "Zogux Trading Inc.",
@@ -35,7 +35,7 @@
     "url": "https://github.com/zoguxprotocol/zogux-chain/issues"
   },
   "devDependencies": {
-    "@cosmjs/stargate": "^0.32.1",
+    "@cosmjs/stargate": "^0.33.1",
     "@dydxprotocol/node-service-base-dev": "^0.3.2",
     "@osmonauts/lcd": "^0.6.0",
     "@osmonauts/telescope": "0.86.0",

package/src/codegen/cosmos/bundle.ts

@@ -184,9 +184,9 @@ import * as _344 from "./slashing/v1beta1/tx.rpc.msg";
 import * as _345 from "./staking/v1beta1/tx.rpc.msg";
 import * as _346 from "./upgrade/v1beta1/tx.rpc.msg";
 import * as _347 from "./vesting/v1beta1/tx.rpc.msg";
-import * as _412 from "./lcd";
-import * as _413 from "./rpc.query";
-import * as _414 from "./rpc.tx";
+import * as _413 from "./lcd";
+import * as _414 from "./rpc.query";
+import * as _415 from "./rpc.tx";
 export namespace cosmos {
   export namespace app {
     export namespace runtime {
@@ -571,8 +571,8 @@ export namespace cosmos {
       ..._347
     };
   }
-  export const ClientFactory = { ..._412,
-    ..._413,
-    ..._414
+  export const ClientFactory = { ..._413,
+    ..._414,
+    ..._415
   };
 }

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

@@ -0,0 +1,24 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgCreateAsset, MsgCreateAssetResponse } from "./tx";
+/** Msg defines the Msg service. */
+
+export interface Msg {
+  /** CreateAsset allows the authority to create a new asset. */
+  createAsset(request: MsgCreateAsset): Promise<MsgCreateAssetResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.createAsset = this.createAsset.bind(this);
+  }
+
+  createAsset(request: MsgCreateAsset): Promise<MsgCreateAssetResponse> {
+    const data = MsgCreateAsset.encode(request).finish();
+    const promise = this.rpc.request("zogux.assets.Msg", "CreateAsset", data);
+    return promise.then(data => MsgCreateAssetResponse.decode(new _m0.Reader(data)));
+  }
+
+}

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

@@ -1 +1,113 @@
-export {}
+import { Asset, AssetSDKType } from "./asset";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** MsgCreateAsset defines a message for creating a new asset. */
+
+export interface MsgCreateAsset {
+  /** The authority to create the asset (e.g. governance module). */
+  authority: string;
+  /** The asset to create. */
+
+  asset?: Asset;
+}
+/** MsgCreateAsset defines a message for creating a new asset. */
+
+export interface MsgCreateAssetSDKType {
+  authority: string;
+  asset?: AssetSDKType;
+}
+/** MsgCreateAssetResponse defines the Msg/CreateAsset response type. */
+
+export interface MsgCreateAssetResponse {}
+/** MsgCreateAssetResponse defines the Msg/CreateAsset response type. */
+
+export interface MsgCreateAssetResponseSDKType {}
+
+function createBaseMsgCreateAsset(): MsgCreateAsset {
+  return {
+    authority: "",
+    asset: undefined
+  };
+}
+
+export const MsgCreateAsset = {
+  encode(message: MsgCreateAsset, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    if (message.asset !== undefined) {
+      Asset.encode(message.asset, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateAsset {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCreateAsset();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.asset = Asset.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgCreateAsset>): MsgCreateAsset {
+    const message = createBaseMsgCreateAsset();
+    message.authority = object.authority ?? "";
+    message.asset = object.asset !== undefined && object.asset !== null ? Asset.fromPartial(object.asset) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgCreateAssetResponse(): MsgCreateAssetResponse {
+  return {};
+}
+
+export const MsgCreateAssetResponse = {
+  encode(_: MsgCreateAssetResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateAssetResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCreateAssetResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgCreateAssetResponse>): MsgCreateAssetResponse {
+    const message = createBaseMsgCreateAssetResponse();
+    return message;
+  }
+
+};

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

@@ -14,7 +14,7 @@ export interface EventWithdrawalRequested {
   /** Destination address on target chain */
 
   toAddress: string;
-  /** Amount to withdraw */
+  /** Amount to withdraw (in EVM decimals after conversion) */
 
   amount: string;
   /** Target chain ID */
@@ -32,6 +32,15 @@ export interface EventWithdrawalRequested {
   /** Estimated timeout for signatures */
 
   timeoutSeconds: Long;
+  /** Token address on EVM chain */
+
+  tokenAddress: string;
+  /** Source chain token decimals (Zogux) */
+
+  srcDecimals: number;
+  /** Destination chain token decimals (EVM) */
+
+  dstDecimals: number;
 }
 /**
  * EventWithdrawalRequested is emitted when a user requests a withdrawal.
@@ -48,6 +57,9 @@ export interface EventWithdrawalRequestedSDKType {
   nonce: Long;
   block_height: Long;
   timeout_seconds: Long;
+  token_address: string;
+  src_decimals: number;
+  dst_decimals: number;
 }
 /**
  * EventWithdrawalSignatureSubmitted is emitted when a validator submits a
@@ -74,7 +86,51 @@ export interface EventWithdrawalSignatureSubmittedSDKType {
   validator: string;
   block_height: Long;
 }
-/** EventWithdrawalCompleted is emitted when a withdrawal is completed. */
+/**
+ * EventWithdrawalSigned is emitted when a withdrawal has collected enough TSS signatures.
+ * Signer service should listen to this and submit to EVM.
+ */
+
+export interface EventWithdrawalSigned {
+  /** Withdrawal ID */
+  withdrawalId: string;
+  /** Aggregated TSS signature */
+
+  signature: Uint8Array;
+  /** Block height when signed */
+
+  blockHeight: Long;
+}
+/**
+ * EventWithdrawalSigned is emitted when a withdrawal has collected enough TSS signatures.
+ * Signer service should listen to this and submit to EVM.
+ */
+
+export interface EventWithdrawalSignedSDKType {
+  withdrawal_id: string;
+  signature: Uint8Array;
+  block_height: Long;
+}
+/** EventWithdrawalSubmitted is emitted when signer has submitted the withdrawal to EVM. */
+
+export interface EventWithdrawalSubmitted {
+  /** Withdrawal ID */
+  withdrawalId: string;
+  /** EVM transaction hash */
+
+  txHash: string;
+  /** Block height when submitted */
+
+  blockHeight: Long;
+}
+/** EventWithdrawalSubmitted is emitted when signer has submitted the withdrawal to EVM. */
+
+export interface EventWithdrawalSubmittedSDKType {
+  withdrawal_id: string;
+  tx_hash: string;
+  block_height: Long;
+}
+/** EventWithdrawalCompleted is emitted when a withdrawal is confirmed on EVM. */
 
 export interface EventWithdrawalCompleted {
   /** Withdrawal ID */
@@ -85,13 +141,17 @@ export interface EventWithdrawalCompleted {
   /** Block height when completed */
 
   blockHeight: Long;
+  /** EVM transaction hash confirming the withdrawal */
+
+  evmTxHash: string;
 }
-/** EventWithdrawalCompleted is emitted when a withdrawal is completed. */
+/** EventWithdrawalCompleted is emitted when a withdrawal is confirmed on EVM. */
 
 export interface EventWithdrawalCompletedSDKType {
   withdrawal_id: string;
   signature: Uint8Array;
   block_height: Long;
+  evm_tx_hash: string;
 }
 /** EventWithdrawalCancelled is emitted when a withdrawal is cancelled. */
 
@@ -123,7 +183,10 @@ function createBaseEventWithdrawalRequested(): EventWithdrawalRequested {
     denom: "",
     nonce: Long.UZERO,
     blockHeight: Long.UZERO,
-    timeoutSeconds: Long.UZERO
+    timeoutSeconds: Long.UZERO,
+    tokenAddress: "",
+    srcDecimals: 0,
+    dstDecimals: 0
   };
 }
 
@@ -165,6 +228,18 @@ export const EventWithdrawalRequested = {
       writer.uint32(72).uint64(message.timeoutSeconds);
     }
 
+    if (message.tokenAddress !== "") {
+      writer.uint32(82).string(message.tokenAddress);
+    }
+
+    if (message.srcDecimals !== 0) {
+      writer.uint32(88).uint32(message.srcDecimals);
+    }
+
+    if (message.dstDecimals !== 0) {
+      writer.uint32(96).uint32(message.dstDecimals);
+    }
+
     return writer;
   },
 
@@ -213,6 +288,18 @@ export const EventWithdrawalRequested = {
           message.timeoutSeconds = (reader.uint64() as Long);
           break;
 
+        case 10:
+          message.tokenAddress = reader.string();
+          break;
+
+        case 11:
+          message.srcDecimals = reader.uint32();
+          break;
+
+        case 12:
+          message.dstDecimals = reader.uint32();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -233,6 +320,9 @@ export const EventWithdrawalRequested = {
     message.nonce = object.nonce !== undefined && object.nonce !== null ? Long.fromValue(object.nonce) : Long.UZERO;
     message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? Long.fromValue(object.blockHeight) : Long.UZERO;
     message.timeoutSeconds = object.timeoutSeconds !== undefined && object.timeoutSeconds !== null ? Long.fromValue(object.timeoutSeconds) : Long.UZERO;
+    message.tokenAddress = object.tokenAddress ?? "";
+    message.srcDecimals = object.srcDecimals ?? 0;
+    message.dstDecimals = object.dstDecimals ?? 0;
     return message;
   }
 
@@ -303,7 +393,7 @@ export const EventWithdrawalSignatureSubmitted = {
 
 };
 
-function createBaseEventWithdrawalCompleted(): EventWithdrawalCompleted {
+function createBaseEventWithdrawalSigned(): EventWithdrawalSigned {
   return {
     withdrawalId: "",
     signature: new Uint8Array(),
@@ -311,6 +401,137 @@ function createBaseEventWithdrawalCompleted(): EventWithdrawalCompleted {
   };
 }
 
+export const EventWithdrawalSigned = {
+  encode(message: EventWithdrawalSigned, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.withdrawalId !== "") {
+      writer.uint32(10).string(message.withdrawalId);
+    }
+
+    if (message.signature.length !== 0) {
+      writer.uint32(18).bytes(message.signature);
+    }
+
+    if (!message.blockHeight.isZero()) {
+      writer.uint32(24).uint64(message.blockHeight);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EventWithdrawalSigned {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventWithdrawalSigned();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.withdrawalId = reader.string();
+          break;
+
+        case 2:
+          message.signature = reader.bytes();
+          break;
+
+        case 3:
+          message.blockHeight = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<EventWithdrawalSigned>): EventWithdrawalSigned {
+    const message = createBaseEventWithdrawalSigned();
+    message.withdrawalId = object.withdrawalId ?? "";
+    message.signature = object.signature ?? new Uint8Array();
+    message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? Long.fromValue(object.blockHeight) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseEventWithdrawalSubmitted(): EventWithdrawalSubmitted {
+  return {
+    withdrawalId: "",
+    txHash: "",
+    blockHeight: Long.UZERO
+  };
+}
+
+export const EventWithdrawalSubmitted = {
+  encode(message: EventWithdrawalSubmitted, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.withdrawalId !== "") {
+      writer.uint32(10).string(message.withdrawalId);
+    }
+
+    if (message.txHash !== "") {
+      writer.uint32(18).string(message.txHash);
+    }
+
+    if (!message.blockHeight.isZero()) {
+      writer.uint32(24).uint64(message.blockHeight);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EventWithdrawalSubmitted {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventWithdrawalSubmitted();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.withdrawalId = reader.string();
+          break;
+
+        case 2:
+          message.txHash = reader.string();
+          break;
+
+        case 3:
+          message.blockHeight = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<EventWithdrawalSubmitted>): EventWithdrawalSubmitted {
+    const message = createBaseEventWithdrawalSubmitted();
+    message.withdrawalId = object.withdrawalId ?? "";
+    message.txHash = object.txHash ?? "";
+    message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? Long.fromValue(object.blockHeight) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseEventWithdrawalCompleted(): EventWithdrawalCompleted {
+  return {
+    withdrawalId: "",
+    signature: new Uint8Array(),
+    blockHeight: Long.UZERO,
+    evmTxHash: ""
+  };
+}
+
 export const EventWithdrawalCompleted = {
   encode(message: EventWithdrawalCompleted, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.withdrawalId !== "") {
@@ -325,6 +546,10 @@ export const EventWithdrawalCompleted = {
       writer.uint32(24).uint64(message.blockHeight);
     }
 
+    if (message.evmTxHash !== "") {
+      writer.uint32(34).string(message.evmTxHash);
+    }
+
     return writer;
   },
 
@@ -349,6 +574,10 @@ export const EventWithdrawalCompleted = {
           message.blockHeight = (reader.uint64() as Long);
           break;
 
+        case 4:
+          message.evmTxHash = reader.string();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -363,6 +592,7 @@ export const EventWithdrawalCompleted = {
     message.withdrawalId = object.withdrawalId ?? "";
     message.signature = object.signature ?? new Uint8Array();
     message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? Long.fromValue(object.blockHeight) : Long.UZERO;
+    message.evmTxHash = object.evmTxHash ?? "";
     return message;
   }
 

package/src/codegen/zogux/bridge/genesis.ts

@@ -1,4 +1,4 @@
-import { EventParams, EventParamsSDKType, ProposeParams, ProposeParamsSDKType, SafetyParams, SafetyParamsSDKType } from "./params";
+import { EventParams, EventParamsSDKType, ProposeParams, ProposeParamsSDKType, SafetyParams, SafetyParamsSDKType, TSSParams, TSSParamsSDKType } from "./params";
 import { BridgeEventInfo, BridgeEventInfoSDKType } from "./bridge_event_info";
 import { TokenInfo, TokenInfoSDKType, TokenPair, TokenPairSDKType } from "./token";
 import * as _m0 from "protobufjs/minimal";
@@ -23,6 +23,9 @@ export interface GenesisState {
   /** Token pair mappings for cross-chain transfers. */
 
   tokenPairs: TokenPair[];
+  /** TSS (Threshold Signature Scheme) parameters. */
+
+  tssParams?: TSSParams;
 }
 /** GenesisState defines the bridge module's genesis state. */
 
@@ -33,6 +36,7 @@ export interface GenesisStateSDKType {
   acknowledged_event_info?: BridgeEventInfoSDKType;
   token_infos: TokenInfoSDKType[];
   token_pairs: TokenPairSDKType[];
+  tss_params?: TSSParamsSDKType;
 }
 
 function createBaseGenesisState(): GenesisState {
@@ -42,7 +46,8 @@ function createBaseGenesisState(): GenesisState {
     safetyParams: undefined,
     acknowledgedEventInfo: undefined,
     tokenInfos: [],
-    tokenPairs: []
+    tokenPairs: [],
+    tssParams: undefined
   };
 }
 
@@ -72,6 +77,10 @@ export const GenesisState = {
       TokenPair.encode(v!, writer.uint32(50).fork()).ldelim();
     }
 
+    if (message.tssParams !== undefined) {
+      TSSParams.encode(message.tssParams, writer.uint32(58).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -108,6 +117,10 @@ export const GenesisState = {
           message.tokenPairs.push(TokenPair.decode(reader, reader.uint32()));
           break;
 
+        case 7:
+          message.tssParams = TSSParams.decode(reader, reader.uint32());
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -125,6 +138,7 @@ export const GenesisState = {
     message.acknowledgedEventInfo = object.acknowledgedEventInfo !== undefined && object.acknowledgedEventInfo !== null ? BridgeEventInfo.fromPartial(object.acknowledgedEventInfo) : undefined;
     message.tokenInfos = object.tokenInfos?.map(e => TokenInfo.fromPartial(e)) || [];
     message.tokenPairs = object.tokenPairs?.map(e => TokenPair.fromPartial(e)) || [];
+    message.tssParams = object.tssParams !== undefined && object.tssParams !== null ? TSSParams.fromPartial(object.tssParams) : undefined;
     return message;
   }
 

package/src/codegen/zogux/bridge/params.ts

@@ -83,16 +83,13 @@ export interface SafetyParamsSDKType {
   is_disabled: boolean;
   delay_blocks: number;
 }
-/** TSSParams stores parameters for TSS (Threshold Signature Scheme). */
+/**
+ * TSSParams stores parameters for TSS (Threshold Signature Scheme).
+ * Note: TSS produces a single aggregated signature, no threshold counting needed.
+ */
 
 export interface TSSParams {
-  /** Threshold of signatures required (e.g., 2 for 2/3). */
-  threshold: number;
-  /** Total number of TSS parties/validators. */
-
-  totalParties: number;
   /** Timeout for TSS signing operations in seconds. */
-
   timeoutSeconds: Long;
   /** Whitelist enabled (permissioned mode). */
 
@@ -100,15 +97,23 @@ export interface TSSParams {
   /** Supported chain IDs (1=Ethereum, 42161=Arbitrum, etc.). */
 
   supportedChainIds: Long[];
+  /**
+   * TSS group public key (hex-encoded, 66 chars for compressed or 130 for uncompressed).
+   * This is used to verify TSS signatures.
+   */
+
+  tssPubKey: string;
 }
-/** TSSParams stores parameters for TSS (Threshold Signature Scheme). */
+/**
+ * TSSParams stores parameters for TSS (Threshold Signature Scheme).
+ * Note: TSS produces a single aggregated signature, no threshold counting needed.
+ */
 
 export interface TSSParamsSDKType {
-  threshold: number;
-  total_parties: number;
   timeout_seconds: Long;
   whitelist_enabled: boolean;
   supported_chain_ids: Long[];
+  tss_pub_key: string;
 }
 
 function createBaseEventParams(): EventParams {
@@ -308,24 +313,15 @@ export const SafetyParams = {
 
 function createBaseTSSParams(): TSSParams {
   return {
-    threshold: 0,
-    totalParties: 0,
     timeoutSeconds: Long.UZERO,
     whitelistEnabled: false,
-    supportedChainIds: []
+    supportedChainIds: [],
+    tssPubKey: ""
   };
 }
 
 export const TSSParams = {
   encode(message: TSSParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.threshold !== 0) {
-      writer.uint32(8).uint32(message.threshold);
-    }
-
-    if (message.totalParties !== 0) {
-      writer.uint32(16).uint32(message.totalParties);
-    }
-
     if (!message.timeoutSeconds.isZero()) {
       writer.uint32(24).uint64(message.timeoutSeconds);
     }
@@ -341,6 +337,11 @@ export const TSSParams = {
     }
 
     writer.ldelim();
+
+    if (message.tssPubKey !== "") {
+      writer.uint32(50).string(message.tssPubKey);
+    }
+
     return writer;
   },
 
@@ -353,14 +354,6 @@ export const TSSParams = {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
-        case 1:
-          message.threshold = reader.uint32();
-          break;
-
-        case 2:
-          message.totalParties = reader.uint32();
-          break;
-
         case 3:
           message.timeoutSeconds = (reader.uint64() as Long);
           break;
@@ -382,6 +375,10 @@ export const TSSParams = {
 
           break;
 
+        case 6:
+          message.tssPubKey = reader.string();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -393,11 +390,10 @@ export const TSSParams = {
 
   fromPartial(object: DeepPartial<TSSParams>): TSSParams {
     const message = createBaseTSSParams();
-    message.threshold = object.threshold ?? 0;
-    message.totalParties = object.totalParties ?? 0;
     message.timeoutSeconds = object.timeoutSeconds !== undefined && object.timeoutSeconds !== null ? Long.fromValue(object.timeoutSeconds) : Long.UZERO;
     message.whitelistEnabled = object.whitelistEnabled ?? false;
     message.supportedChainIds = object.supportedChainIds?.map(e => Long.fromValue(e)) || [];
+    message.tssPubKey = object.tssPubKey ?? "";
     return message;
   }