@zoguxprotocol/proto 0.1.0

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

@@ -0,0 +1,131 @@
+import { EventParams, EventParamsSDKType, ProposeParams, ProposeParamsSDKType, SafetyParams, SafetyParamsSDKType } from "./params";
+import { BridgeEventInfo, BridgeEventInfoSDKType } from "./bridge_event_info";
+import { TokenInfo, TokenInfoSDKType, TokenPair, TokenPairSDKType } from "./token";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the bridge module's genesis state. */
+
+export interface GenesisState {
+  /** The parameters of the module. */
+  eventParams?: EventParams;
+  proposeParams?: ProposeParams;
+  safetyParams?: SafetyParams;
+  /**
+   * Acknowledged event info that stores:
+   * - the next event ID to be added to consensus.
+   * - Ethereum block height of the most recently acknowledged bridge event.
+   */
+
+  acknowledgedEventInfo?: BridgeEventInfo;
+  /** Token information for all registered tokens. */
+
+  tokenInfos: TokenInfo[];
+  /** Token pair mappings for cross-chain transfers. */
+
+  tokenPairs: TokenPair[];
+}
+/** GenesisState defines the bridge module's genesis state. */
+
+export interface GenesisStateSDKType {
+  event_params?: EventParamsSDKType;
+  propose_params?: ProposeParamsSDKType;
+  safety_params?: SafetyParamsSDKType;
+  acknowledged_event_info?: BridgeEventInfoSDKType;
+  token_infos: TokenInfoSDKType[];
+  token_pairs: TokenPairSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    eventParams: undefined,
+    proposeParams: undefined,
+    safetyParams: undefined,
+    acknowledgedEventInfo: undefined,
+    tokenInfos: [],
+    tokenPairs: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.eventParams !== undefined) {
+      EventParams.encode(message.eventParams, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.proposeParams !== undefined) {
+      ProposeParams.encode(message.proposeParams, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.safetyParams !== undefined) {
+      SafetyParams.encode(message.safetyParams, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.acknowledgedEventInfo !== undefined) {
+      BridgeEventInfo.encode(message.acknowledgedEventInfo, writer.uint32(34).fork()).ldelim();
+    }
+
+    for (const v of message.tokenInfos) {
+      TokenInfo.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+
+    for (const v of message.tokenPairs) {
+      TokenPair.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.eventParams = EventParams.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.proposeParams = ProposeParams.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.safetyParams = SafetyParams.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.acknowledgedEventInfo = BridgeEventInfo.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.tokenInfos.push(TokenInfo.decode(reader, reader.uint32()));
+          break;
+
+        case 6:
+          message.tokenPairs.push(TokenPair.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.eventParams = object.eventParams !== undefined && object.eventParams !== null ? EventParams.fromPartial(object.eventParams) : undefined;
+    message.proposeParams = object.proposeParams !== undefined && object.proposeParams !== null ? ProposeParams.fromPartial(object.proposeParams) : undefined;
+    message.safetyParams = object.safetyParams !== undefined && object.safetyParams !== null ? SafetyParams.fromPartial(object.safetyParams) : undefined;
+    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)) || [];
+    return message;
+  }
+
+};

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

@@ -0,0 +1,404 @@
+import { Duration, DurationSDKType } from "../../google/protobuf/duration";
+import { Long, DeepPartial } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/**
+ * EventParams stores parameters about which events to recognize and which
+ * tokens to mint.
+ */
+
+export interface EventParams {
+  /** The denom of the token to mint. */
+  denom: string;
+  /** The numerical chain ID of the Ethereum chain to query. */
+
+  ethChainId: Long;
+  /** The address of the Ethereum contract to monitor for logs. */
+
+  ethAddress: string;
+}
+/**
+ * EventParams stores parameters about which events to recognize and which
+ * tokens to mint.
+ */
+
+export interface EventParamsSDKType {
+  denom: string;
+  eth_chain_id: Long;
+  eth_address: string;
+}
+/** ProposeParams stores parameters for proposing to the module. */
+
+export interface ProposeParams {
+  /**
+   * The maximum number of bridge events to propose per block.
+   * Limits the number of events to propose in a single block
+   * in-order to smooth out the flow of events.
+   */
+  maxBridgesPerBlock: number;
+  /**
+   * The minimum duration to wait between a finalized bridge and
+   * proposing it. This allows other validators to have enough time to
+   * also recognize its occurence. Therefore the bridge daemon should
+   * pool for new finalized events at least as often as this parameter.
+   */
+
+  proposeDelayDuration?: Duration;
+  /**
+   * Do not propose any events if a [0, 1_000_000) random number generator
+   * generates a number smaller than this number.
+   * Setting this parameter to 1_000_000 means always skipping proposing events.
+   */
+
+  skipRatePpm: number;
+  /**
+   * Do not propose any events if the timestamp of the proposal block is
+   * behind the proposers' wall-clock by at least this duration.
+   */
+
+  skipIfBlockDelayedByDuration?: Duration;
+}
+/** ProposeParams stores parameters for proposing to the module. */
+
+export interface ProposeParamsSDKType {
+  max_bridges_per_block: number;
+  propose_delay_duration?: DurationSDKType;
+  skip_rate_ppm: number;
+  skip_if_block_delayed_by_duration?: DurationSDKType;
+}
+/** SafetyParams stores safety parameters for the module. */
+
+export interface SafetyParams {
+  /** True if bridging is disabled. */
+  isDisabled: boolean;
+  /**
+   * The number of blocks that bridges accepted in-consensus will be pending
+   * until the minted tokens are granted.
+   */
+
+  delayBlocks: number;
+}
+/** SafetyParams stores safety parameters for the module. */
+
+export interface SafetyParamsSDKType {
+  is_disabled: boolean;
+  delay_blocks: number;
+}
+/** TSSParams stores parameters for TSS (Threshold Signature Scheme). */
+
+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). */
+
+  whitelistEnabled: boolean;
+  /** Supported chain IDs (1=Ethereum, 42161=Arbitrum, etc.). */
+
+  supportedChainIds: Long[];
+}
+/** TSSParams stores parameters for TSS (Threshold Signature Scheme). */
+
+export interface TSSParamsSDKType {
+  threshold: number;
+  total_parties: number;
+  timeout_seconds: Long;
+  whitelist_enabled: boolean;
+  supported_chain_ids: Long[];
+}
+
+function createBaseEventParams(): EventParams {
+  return {
+    denom: "",
+    ethChainId: Long.UZERO,
+    ethAddress: ""
+  };
+}
+
+export const EventParams = {
+  encode(message: EventParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+
+    if (!message.ethChainId.isZero()) {
+      writer.uint32(16).uint64(message.ethChainId);
+    }
+
+    if (message.ethAddress !== "") {
+      writer.uint32(26).string(message.ethAddress);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): EventParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+
+        case 2:
+          message.ethChainId = (reader.uint64() as Long);
+          break;
+
+        case 3:
+          message.ethAddress = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<EventParams>): EventParams {
+    const message = createBaseEventParams();
+    message.denom = object.denom ?? "";
+    message.ethChainId = object.ethChainId !== undefined && object.ethChainId !== null ? Long.fromValue(object.ethChainId) : Long.UZERO;
+    message.ethAddress = object.ethAddress ?? "";
+    return message;
+  }
+
+};
+
+function createBaseProposeParams(): ProposeParams {
+  return {
+    maxBridgesPerBlock: 0,
+    proposeDelayDuration: undefined,
+    skipRatePpm: 0,
+    skipIfBlockDelayedByDuration: undefined
+  };
+}
+
+export const ProposeParams = {
+  encode(message: ProposeParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.maxBridgesPerBlock !== 0) {
+      writer.uint32(8).uint32(message.maxBridgesPerBlock);
+    }
+
+    if (message.proposeDelayDuration !== undefined) {
+      Duration.encode(message.proposeDelayDuration, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.skipRatePpm !== 0) {
+      writer.uint32(24).uint32(message.skipRatePpm);
+    }
+
+    if (message.skipIfBlockDelayedByDuration !== undefined) {
+      Duration.encode(message.skipIfBlockDelayedByDuration, writer.uint32(34).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ProposeParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseProposeParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.maxBridgesPerBlock = reader.uint32();
+          break;
+
+        case 2:
+          message.proposeDelayDuration = Duration.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.skipRatePpm = reader.uint32();
+          break;
+
+        case 4:
+          message.skipIfBlockDelayedByDuration = Duration.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ProposeParams>): ProposeParams {
+    const message = createBaseProposeParams();
+    message.maxBridgesPerBlock = object.maxBridgesPerBlock ?? 0;
+    message.proposeDelayDuration = object.proposeDelayDuration !== undefined && object.proposeDelayDuration !== null ? Duration.fromPartial(object.proposeDelayDuration) : undefined;
+    message.skipRatePpm = object.skipRatePpm ?? 0;
+    message.skipIfBlockDelayedByDuration = object.skipIfBlockDelayedByDuration !== undefined && object.skipIfBlockDelayedByDuration !== null ? Duration.fromPartial(object.skipIfBlockDelayedByDuration) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseSafetyParams(): SafetyParams {
+  return {
+    isDisabled: false,
+    delayBlocks: 0
+  };
+}
+
+export const SafetyParams = {
+  encode(message: SafetyParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.isDisabled === true) {
+      writer.uint32(8).bool(message.isDisabled);
+    }
+
+    if (message.delayBlocks !== 0) {
+      writer.uint32(16).uint32(message.delayBlocks);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SafetyParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSafetyParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.isDisabled = reader.bool();
+          break;
+
+        case 2:
+          message.delayBlocks = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SafetyParams>): SafetyParams {
+    const message = createBaseSafetyParams();
+    message.isDisabled = object.isDisabled ?? false;
+    message.delayBlocks = object.delayBlocks ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseTSSParams(): TSSParams {
+  return {
+    threshold: 0,
+    totalParties: 0,
+    timeoutSeconds: Long.UZERO,
+    whitelistEnabled: false,
+    supportedChainIds: []
+  };
+}
+
+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);
+    }
+
+    if (message.whitelistEnabled === true) {
+      writer.uint32(32).bool(message.whitelistEnabled);
+    }
+
+    writer.uint32(42).fork();
+
+    for (const v of message.supportedChainIds) {
+      writer.int64(v);
+    }
+
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TSSParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTSSParams();
+
+    while (reader.pos < end) {
+      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;
+
+        case 4:
+          message.whitelistEnabled = reader.bool();
+          break;
+
+        case 5:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+
+            while (reader.pos < end2) {
+              message.supportedChainIds.push((reader.int64() as Long));
+            }
+          } else {
+            message.supportedChainIds.push((reader.int64() as Long));
+          }
+
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  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)) || [];
+    return message;
+  }
+
+};

package/src/codegen/zogux/bridge/query.lcd.ts

@@ -0,0 +1,162 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryEventParamsRequest, QueryEventParamsResponseSDKType, QueryProposeParamsRequest, QueryProposeParamsResponseSDKType, QuerySafetyParamsRequest, QuerySafetyParamsResponseSDKType, QueryAcknowledgedEventInfoRequest, QueryAcknowledgedEventInfoResponseSDKType, QueryRecognizedEventInfoRequest, QueryRecognizedEventInfoResponseSDKType, QueryDelayedCompleteBridgeMessagesRequest, QueryDelayedCompleteBridgeMessagesResponseSDKType, QueryTSSParamsRequest, QueryTSSParamsResponseSDKType, QueryWithdrawalRequestRequest, QueryWithdrawalRequestResponseSDKType, QueryWithdrawalsByAddressRequest, QueryWithdrawalsByAddressResponseSDKType, QueryPendingWithdrawalsRequest, QueryPendingWithdrawalsResponseSDKType, QueryWithdrawalByChainAndNonceRequest, QueryWithdrawalByChainAndNonceResponseSDKType } from "./query";
+import { QueryTokenInfoRequest, QueryTokenInfoResponseSDKType, QueryTokenPairRequest, QueryTokenPairResponseSDKType, QueryAllTokensRequest, QueryAllTokensResponseSDKType, QueryTokenPairsBySourceRequest, QueryTokenPairsBySourceResponseSDKType } from "./token";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.eventParams = this.eventParams.bind(this);
+    this.proposeParams = this.proposeParams.bind(this);
+    this.safetyParams = this.safetyParams.bind(this);
+    this.acknowledgedEventInfo = this.acknowledgedEventInfo.bind(this);
+    this.recognizedEventInfo = this.recognizedEventInfo.bind(this);
+    this.delayedCompleteBridgeMessages = this.delayedCompleteBridgeMessages.bind(this);
+    this.tSSParams = this.tSSParams.bind(this);
+    this.withdrawalRequest = this.withdrawalRequest.bind(this);
+    this.withdrawalsByAddress = this.withdrawalsByAddress.bind(this);
+    this.pendingWithdrawals = this.pendingWithdrawals.bind(this);
+    this.withdrawalByChainAndNonce = this.withdrawalByChainAndNonce.bind(this);
+    this.tokenInfo = this.tokenInfo.bind(this);
+    this.tokenPair = this.tokenPair.bind(this);
+    this.allTokens = this.allTokens.bind(this);
+    this.tokenPairsBySource = this.tokenPairsBySource.bind(this);
+  }
+  /* Queries the EventParams. */
+
+
+  async eventParams(_params: QueryEventParamsRequest = {}): Promise<QueryEventParamsResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/event_params`;
+    return await this.req.get<QueryEventParamsResponseSDKType>(endpoint);
+  }
+  /* Queries the ProposeParams. */
+
+
+  async proposeParams(_params: QueryProposeParamsRequest = {}): Promise<QueryProposeParamsResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/propose_params`;
+    return await this.req.get<QueryProposeParamsResponseSDKType>(endpoint);
+  }
+  /* Queries the SafetyParams. */
+
+
+  async safetyParams(_params: QuerySafetyParamsRequest = {}): Promise<QuerySafetyParamsResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/safety_params`;
+    return await this.req.get<QuerySafetyParamsResponseSDKType>(endpoint);
+  }
+  /* Queries the AcknowledgedEventInfo.
+   An "acknowledged" event is one that is in-consensus and has been stored
+   in-state. */
+
+
+  async acknowledgedEventInfo(_params: QueryAcknowledgedEventInfoRequest = {}): Promise<QueryAcknowledgedEventInfoResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/acknowledged_event_info`;
+    return await this.req.get<QueryAcknowledgedEventInfoResponseSDKType>(endpoint);
+  }
+  /* Queries the RecognizedEventInfo.
+   A "recognized" event is one that is finalized on the Ethereum blockchain
+   and has been identified by the queried node. It is not yet in-consensus. */
+
+
+  async recognizedEventInfo(_params: QueryRecognizedEventInfoRequest = {}): Promise<QueryRecognizedEventInfoResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/recognized_event_info`;
+    return await this.req.get<QueryRecognizedEventInfoResponseSDKType>(endpoint);
+  }
+  /* Queries all `MsgCompleteBridge` messages that are delayed (not yet
+   executed) and corresponding block heights at which they will execute. */
+
+
+  async delayedCompleteBridgeMessages(params: QueryDelayedCompleteBridgeMessagesRequest): Promise<QueryDelayedCompleteBridgeMessagesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.address !== "undefined") {
+      options.params.address = params.address;
+    }
+
+    const endpoint = `zogux/v4/bridge/delayed_complete_bridge_messages`;
+    return await this.req.get<QueryDelayedCompleteBridgeMessagesResponseSDKType>(endpoint, options);
+  }
+  /* Queries TSS parameters. */
+
+
+  async tSSParams(_params: QueryTSSParamsRequest = {}): Promise<QueryTSSParamsResponseSDKType> {
+    const endpoint = `zoguxprotocol/v4/bridge/tss_params`;
+    return await this.req.get<QueryTSSParamsResponseSDKType>(endpoint);
+  }
+  /* Queries a withdrawal request by ID. */
+
+
+  async withdrawalRequest(params: QueryWithdrawalRequestRequest): Promise<QueryWithdrawalRequestResponseSDKType> {
+    const endpoint = `zoguxprotocol/v4/bridge/withdrawal/${params.id}`;
+    return await this.req.get<QueryWithdrawalRequestResponseSDKType>(endpoint);
+  }
+  /* Queries withdrawals by address. */
+
+
+  async withdrawalsByAddress(params: QueryWithdrawalsByAddressRequest): Promise<QueryWithdrawalsByAddressResponseSDKType> {
+    const endpoint = `zoguxprotocol/v4/bridge/withdrawals/${params.address}`;
+    return await this.req.get<QueryWithdrawalsByAddressResponseSDKType>(endpoint);
+  }
+  /* Queries pending withdrawals that need TSS signatures.
+   Used by TSS service to get withdrawals to sign. */
+
+
+  async pendingWithdrawals(params: QueryPendingWithdrawalsRequest): Promise<QueryPendingWithdrawalsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.chainId !== "undefined") {
+      options.params.chain_id = params.chainId;
+    }
+
+    if (typeof params?.limit !== "undefined") {
+      options.params.limit = params.limit;
+    }
+
+    const endpoint = `zoguxprotocol/v4/bridge/pending_withdrawals`;
+    return await this.req.get<QueryPendingWithdrawalsResponseSDKType>(endpoint, options);
+  }
+  /* Queries a specific withdrawal by chain ID and nonce.
+   Used by TSS service to check deposit info. */
+
+
+  async withdrawalByChainAndNonce(params: QueryWithdrawalByChainAndNonceRequest): Promise<QueryWithdrawalByChainAndNonceResponseSDKType> {
+    const endpoint = `zoguxprotocol/v4/bridge/withdrawal_by_chain/${params.chainId}/${params.nonce}`;
+    return await this.req.get<QueryWithdrawalByChainAndNonceResponseSDKType>(endpoint);
+  }
+  /* Queries token information by chain ID and address. */
+
+
+  async tokenInfo(params: QueryTokenInfoRequest): Promise<QueryTokenInfoResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/token/${params.chainId}/${params.tokenAddress}`;
+    return await this.req.get<QueryTokenInfoResponseSDKType>(endpoint);
+  }
+  /* Queries a token pair mapping. */
+
+
+  async tokenPair(params: QueryTokenPairRequest): Promise<QueryTokenPairResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/token_pair/${params.srcChainId}/${params.srcTokenAddress}/${params.dstChainId}`;
+    return await this.req.get<QueryTokenPairResponseSDKType>(endpoint);
+  }
+  /* Queries all registered tokens. */
+
+
+  async allTokens(_params: QueryAllTokensRequest = {}): Promise<QueryAllTokensResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/tokens`;
+    return await this.req.get<QueryAllTokensResponseSDKType>(endpoint);
+  }
+  /* Queries all token pairs for a given source token. */
+
+
+  async tokenPairsBySource(params: QueryTokenPairsBySourceRequest): Promise<QueryTokenPairsBySourceResponseSDKType> {
+    const endpoint = `zogux/v4/bridge/token_pairs/${params.srcChainId}/${params.srcTokenAddress}`;
+    return await this.req.get<QueryTokenPairsBySourceResponseSDKType>(endpoint);
+  }
+
+}