@perpx/proto 0.0.0

package/src/codegen/perpx/bridge/bridge_event.ts

@@ -0,0 +1,101 @@
+import { Coin, CoinSDKType } from "../../cosmos/base/v1beta1/coin";
+import { Long, DeepPartial } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/** BridgeEvent is a recognized event from the Ethereum blockchain. */
+
+export interface BridgeEvent {
+  /** The unique id of the Ethereum event log. */
+  id: number;
+  /** The tokens bridged. */
+
+  coin?: Coin;
+  /** The account address or module address to bridge to. */
+
+  address: string;
+  /** The Ethereum block height of the event. */
+
+  ethBlockHeight: Long;
+}
+/** BridgeEvent is a recognized event from the Ethereum blockchain. */
+
+export interface BridgeEventSDKType {
+  id: number;
+  coin?: CoinSDKType;
+  address: string;
+  eth_block_height: Long;
+}
+
+function createBaseBridgeEvent(): BridgeEvent {
+  return {
+    id: 0,
+    coin: undefined,
+    address: "",
+    ethBlockHeight: Long.UZERO
+  };
+}
+
+export const BridgeEvent = {
+  encode(message: BridgeEvent, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    if (message.coin !== undefined) {
+      Coin.encode(message.coin, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.address !== "") {
+      writer.uint32(26).string(message.address);
+    }
+
+    if (!message.ethBlockHeight.isZero()) {
+      writer.uint32(32).uint64(message.ethBlockHeight);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BridgeEvent {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBridgeEvent();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        case 2:
+          message.coin = Coin.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.address = reader.string();
+          break;
+
+        case 4:
+          message.ethBlockHeight = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BridgeEvent>): BridgeEvent {
+    const message = createBaseBridgeEvent();
+    message.id = object.id ?? 0;
+    message.coin = object.coin !== undefined && object.coin !== null ? Coin.fromPartial(object.coin) : undefined;
+    message.address = object.address ?? "";
+    message.ethBlockHeight = object.ethBlockHeight !== undefined && object.ethBlockHeight !== null ? Long.fromValue(object.ethBlockHeight) : Long.UZERO;
+    return message;
+  }
+
+};

package/src/codegen/perpx/bridge/bridge_event_info.ts

@@ -0,0 +1,81 @@
+import { Long, DeepPartial } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/**
+ * BridgeEventInfo stores information about the most recently processed bridge
+ * event.
+ */
+
+export interface BridgeEventInfo {
+  /**
+   * The next event id (the last processed id plus one) of the logs from the
+   * Ethereum contract.
+   */
+  nextId: number;
+  /** The Ethereum block height of the most recently processed bridge event. */
+
+  ethBlockHeight: Long;
+}
+/**
+ * BridgeEventInfo stores information about the most recently processed bridge
+ * event.
+ */
+
+export interface BridgeEventInfoSDKType {
+  next_id: number;
+  eth_block_height: Long;
+}
+
+function createBaseBridgeEventInfo(): BridgeEventInfo {
+  return {
+    nextId: 0,
+    ethBlockHeight: Long.UZERO
+  };
+}
+
+export const BridgeEventInfo = {
+  encode(message: BridgeEventInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.nextId !== 0) {
+      writer.uint32(8).uint32(message.nextId);
+    }
+
+    if (!message.ethBlockHeight.isZero()) {
+      writer.uint32(16).uint64(message.ethBlockHeight);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BridgeEventInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBridgeEventInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.nextId = reader.uint32();
+          break;
+
+        case 2:
+          message.ethBlockHeight = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BridgeEventInfo>): BridgeEventInfo {
+    const message = createBaseBridgeEventInfo();
+    message.nextId = object.nextId ?? 0;
+    message.ethBlockHeight = object.ethBlockHeight !== undefined && object.ethBlockHeight !== null ? Long.fromValue(object.ethBlockHeight) : Long.UZERO;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,102 @@
+import { EventParams, EventParamsSDKType, ProposeParams, ProposeParamsSDKType, SafetyParams, SafetyParamsSDKType } from "./params";
+import { BridgeEventInfo, BridgeEventInfoSDKType } from "./bridge_event_info";
+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;
+}
+/** GenesisState defines the bridge module's genesis state. */
+
+export interface GenesisStateSDKType {
+  event_params?: EventParamsSDKType;
+  propose_params?: ProposeParamsSDKType;
+  safety_params?: SafetyParamsSDKType;
+  acknowledged_event_info?: BridgeEventInfoSDKType;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    eventParams: undefined,
+    proposeParams: undefined,
+    safetyParams: undefined,
+    acknowledgedEventInfo: undefined
+  };
+}
+
+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();
+    }
+
+    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;
+
+        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;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,280 @@
+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;
+}
+
+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;
+  }
+
+};

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

@@ -0,0 +1,75 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryEventParamsRequest, QueryEventParamsResponseSDKType, QueryProposeParamsRequest, QueryProposeParamsResponseSDKType, QuerySafetyParamsRequest, QuerySafetyParamsResponseSDKType, QueryAcknowledgedEventInfoRequest, QueryAcknowledgedEventInfoResponseSDKType, QueryRecognizedEventInfoRequest, QueryRecognizedEventInfoResponseSDKType, QueryDelayedCompleteBridgeMessagesRequest, QueryDelayedCompleteBridgeMessagesResponseSDKType } from "./query";
+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);
+  }
+  /* Queries the EventParams. */
+
+
+  async eventParams(_params: QueryEventParamsRequest = {}): Promise<QueryEventParamsResponseSDKType> {
+    const endpoint = `perpx/v4/bridge/event_params`;
+    return await this.req.get<QueryEventParamsResponseSDKType>(endpoint);
+  }
+  /* Queries the ProposeParams. */
+
+
+  async proposeParams(_params: QueryProposeParamsRequest = {}): Promise<QueryProposeParamsResponseSDKType> {
+    const endpoint = `perpx/v4/bridge/propose_params`;
+    return await this.req.get<QueryProposeParamsResponseSDKType>(endpoint);
+  }
+  /* Queries the SafetyParams. */
+
+
+  async safetyParams(_params: QuerySafetyParamsRequest = {}): Promise<QuerySafetyParamsResponseSDKType> {
+    const endpoint = `perpx/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 = `perpx/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 = `perpx/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 = `perpx/v4/bridge/delayed_complete_bridge_messages`;
+    return await this.req.get<QueryDelayedCompleteBridgeMessagesResponseSDKType>(endpoint, options);
+  }
+
+}