@perpx/proto 0.0.0

package/src/codegen/perpx/prices/tx.rpc.msg.ts

@@ -0,0 +1,50 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgUpdateMarketPrices, MsgUpdateMarketPricesResponse, MsgCreateOracleMarket, MsgCreateOracleMarketResponse, MsgUpdateMarketParam, MsgUpdateMarketParamResponse } from "./tx";
+/** Msg defines the Msg service. */
+
+export interface Msg {
+  /**
+   * UpdateMarketPrices updates the oracle price of a market relative to
+   * quoteCurrency.
+   */
+  updateMarketPrices(request: MsgUpdateMarketPrices): Promise<MsgUpdateMarketPricesResponse>;
+  /** CreateOracleMarket creates a new oracle market. */
+
+  createOracleMarket(request: MsgCreateOracleMarket): Promise<MsgCreateOracleMarketResponse>;
+  /**
+   * UpdateMarketParams allows governance to update the parameters of an
+   * oracle market.
+   */
+
+  updateMarketParam(request: MsgUpdateMarketParam): Promise<MsgUpdateMarketParamResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.updateMarketPrices = this.updateMarketPrices.bind(this);
+    this.createOracleMarket = this.createOracleMarket.bind(this);
+    this.updateMarketParam = this.updateMarketParam.bind(this);
+  }
+
+  updateMarketPrices(request: MsgUpdateMarketPrices): Promise<MsgUpdateMarketPricesResponse> {
+    const data = MsgUpdateMarketPrices.encode(request).finish();
+    const promise = this.rpc.request("perpx.prices.Msg", "UpdateMarketPrices", data);
+    return promise.then(data => MsgUpdateMarketPricesResponse.decode(new _m0.Reader(data)));
+  }
+
+  createOracleMarket(request: MsgCreateOracleMarket): Promise<MsgCreateOracleMarketResponse> {
+    const data = MsgCreateOracleMarket.encode(request).finish();
+    const promise = this.rpc.request("perpx.prices.Msg", "CreateOracleMarket", data);
+    return promise.then(data => MsgCreateOracleMarketResponse.decode(new _m0.Reader(data)));
+  }
+
+  updateMarketParam(request: MsgUpdateMarketParam): Promise<MsgUpdateMarketParamResponse> {
+    const data = MsgUpdateMarketParam.encode(request).finish();
+    const promise = this.rpc.request("perpx.prices.Msg", "UpdateMarketParam", data);
+    return promise.then(data => MsgUpdateMarketParamResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/perpx/prices/tx.ts

@@ -0,0 +1,405 @@
+import { MarketParam, MarketParamSDKType } from "./market_param";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../helpers";
+/**
+ * MsgCreateOracleMarket is a message used by x/gov for creating a new oracle
+ * market.
+ */
+
+export interface MsgCreateOracleMarket {
+  /** The address that controls the module. */
+  authority: string;
+  /** `params` defines parameters for the new oracle market. */
+
+  params?: MarketParam;
+}
+/**
+ * MsgCreateOracleMarket is a message used by x/gov for creating a new oracle
+ * market.
+ */
+
+export interface MsgCreateOracleMarketSDKType {
+  authority: string;
+  params?: MarketParamSDKType;
+}
+/** MsgCreateOracleMarketResponse defines the CreateOracleMarket response type. */
+
+export interface MsgCreateOracleMarketResponse {}
+/** MsgCreateOracleMarketResponse defines the CreateOracleMarket response type. */
+
+export interface MsgCreateOracleMarketResponseSDKType {}
+/** MsgUpdateMarketPrices is a request type for the UpdateMarketPrices method. */
+
+export interface MsgUpdateMarketPrices {
+  marketPriceUpdates: MsgUpdateMarketPrices_MarketPrice[];
+}
+/** MsgUpdateMarketPrices is a request type for the UpdateMarketPrices method. */
+
+export interface MsgUpdateMarketPricesSDKType {
+  market_price_updates: MsgUpdateMarketPrices_MarketPriceSDKType[];
+}
+/** MarketPrice represents a price update for a single market */
+
+export interface MsgUpdateMarketPrices_MarketPrice {
+  /** The id of market to update */
+  marketId: number;
+  /** The updated price */
+
+  price: Long;
+}
+/** MarketPrice represents a price update for a single market */
+
+export interface MsgUpdateMarketPrices_MarketPriceSDKType {
+  market_id: number;
+  price: Long;
+}
+/**
+ * MsgUpdateMarketPricesResponse defines the MsgUpdateMarketPrices response
+ * type.
+ */
+
+export interface MsgUpdateMarketPricesResponse {}
+/**
+ * MsgUpdateMarketPricesResponse defines the MsgUpdateMarketPrices response
+ * type.
+ */
+
+export interface MsgUpdateMarketPricesResponseSDKType {}
+/**
+ * MsgUpdateMarketParam is a message used by x/gov for updating the parameters
+ * of an oracle market.
+ */
+
+export interface MsgUpdateMarketParam {
+  authority: string;
+  /** The market param to update. Each field must be set. */
+
+  marketParam?: MarketParam;
+}
+/**
+ * MsgUpdateMarketParam is a message used by x/gov for updating the parameters
+ * of an oracle market.
+ */
+
+export interface MsgUpdateMarketParamSDKType {
+  authority: string;
+  market_param?: MarketParamSDKType;
+}
+/** MsgUpdateMarketParamResponse defines the UpdateMarketParam response type. */
+
+export interface MsgUpdateMarketParamResponse {}
+/** MsgUpdateMarketParamResponse defines the UpdateMarketParam response type. */
+
+export interface MsgUpdateMarketParamResponseSDKType {}
+
+function createBaseMsgCreateOracleMarket(): MsgCreateOracleMarket {
+  return {
+    authority: "",
+    params: undefined
+  };
+}
+
+export const MsgCreateOracleMarket = {
+  encode(message: MsgCreateOracleMarket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    if (message.params !== undefined) {
+      MarketParam.encode(message.params, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateOracleMarket {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCreateOracleMarket();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.params = MarketParam.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgCreateOracleMarket>): MsgCreateOracleMarket {
+    const message = createBaseMsgCreateOracleMarket();
+    message.authority = object.authority ?? "";
+    message.params = object.params !== undefined && object.params !== null ? MarketParam.fromPartial(object.params) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgCreateOracleMarketResponse(): MsgCreateOracleMarketResponse {
+  return {};
+}
+
+export const MsgCreateOracleMarketResponse = {
+  encode(_: MsgCreateOracleMarketResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateOracleMarketResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCreateOracleMarketResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgCreateOracleMarketResponse>): MsgCreateOracleMarketResponse {
+    const message = createBaseMsgCreateOracleMarketResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgUpdateMarketPrices(): MsgUpdateMarketPrices {
+  return {
+    marketPriceUpdates: []
+  };
+}
+
+export const MsgUpdateMarketPrices = {
+  encode(message: MsgUpdateMarketPrices, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.marketPriceUpdates) {
+      MsgUpdateMarketPrices_MarketPrice.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateMarketPrices {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateMarketPrices();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.marketPriceUpdates.push(MsgUpdateMarketPrices_MarketPrice.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgUpdateMarketPrices>): MsgUpdateMarketPrices {
+    const message = createBaseMsgUpdateMarketPrices();
+    message.marketPriceUpdates = object.marketPriceUpdates?.map(e => MsgUpdateMarketPrices_MarketPrice.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseMsgUpdateMarketPrices_MarketPrice(): MsgUpdateMarketPrices_MarketPrice {
+  return {
+    marketId: 0,
+    price: Long.UZERO
+  };
+}
+
+export const MsgUpdateMarketPrices_MarketPrice = {
+  encode(message: MsgUpdateMarketPrices_MarketPrice, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.marketId !== 0) {
+      writer.uint32(8).uint32(message.marketId);
+    }
+
+    if (!message.price.isZero()) {
+      writer.uint32(16).uint64(message.price);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateMarketPrices_MarketPrice {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateMarketPrices_MarketPrice();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.marketId = reader.uint32();
+          break;
+
+        case 2:
+          message.price = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgUpdateMarketPrices_MarketPrice>): MsgUpdateMarketPrices_MarketPrice {
+    const message = createBaseMsgUpdateMarketPrices_MarketPrice();
+    message.marketId = object.marketId ?? 0;
+    message.price = object.price !== undefined && object.price !== null ? Long.fromValue(object.price) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseMsgUpdateMarketPricesResponse(): MsgUpdateMarketPricesResponse {
+  return {};
+}
+
+export const MsgUpdateMarketPricesResponse = {
+  encode(_: MsgUpdateMarketPricesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateMarketPricesResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateMarketPricesResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgUpdateMarketPricesResponse>): MsgUpdateMarketPricesResponse {
+    const message = createBaseMsgUpdateMarketPricesResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgUpdateMarketParam(): MsgUpdateMarketParam {
+  return {
+    authority: "",
+    marketParam: undefined
+  };
+}
+
+export const MsgUpdateMarketParam = {
+  encode(message: MsgUpdateMarketParam, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    if (message.marketParam !== undefined) {
+      MarketParam.encode(message.marketParam, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateMarketParam {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateMarketParam();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.marketParam = MarketParam.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgUpdateMarketParam>): MsgUpdateMarketParam {
+    const message = createBaseMsgUpdateMarketParam();
+    message.authority = object.authority ?? "";
+    message.marketParam = object.marketParam !== undefined && object.marketParam !== null ? MarketParam.fromPartial(object.marketParam) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgUpdateMarketParamResponse(): MsgUpdateMarketParamResponse {
+  return {};
+}
+
+export const MsgUpdateMarketParamResponse = {
+  encode(_: MsgUpdateMarketParamResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateMarketParamResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateMarketParamResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgUpdateMarketParamResponse>): MsgUpdateMarketParamResponse {
+    const message = createBaseMsgUpdateMarketParamResponse();
+    return message;
+  }
+
+};

package/src/codegen/perpx/ratelimit/capacity.ts

@@ -0,0 +1,147 @@
+import { Limiter, LimiterSDKType } from "./limit_params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** DenomCapacity stores a list of rate limit capacity for a denom. */
+
+export interface DenomCapacity {
+  /**
+   * denom is the denomination of the token being rate limited.
+   * e.g. ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5
+   */
+  denom: string;
+  /**
+   * capacity_list is a list of capacity amount tracked for each `Limiter`
+   * on the denom. This list has a 1:1 mapping to `limiter` list under
+   * `LimitParams`.
+   */
+
+  capacityList: Uint8Array[];
+}
+/** DenomCapacity stores a list of rate limit capacity for a denom. */
+
+export interface DenomCapacitySDKType {
+  denom: string;
+  capacity_list: Uint8Array[];
+}
+/** LimiterCapacity contains a pair of limiter and its corresponding capacity. */
+
+export interface LimiterCapacity {
+  limiter?: Limiter;
+  capacity: Uint8Array;
+}
+/** LimiterCapacity contains a pair of limiter and its corresponding capacity. */
+
+export interface LimiterCapacitySDKType {
+  limiter?: LimiterSDKType;
+  capacity: Uint8Array;
+}
+
+function createBaseDenomCapacity(): DenomCapacity {
+  return {
+    denom: "",
+    capacityList: []
+  };
+}
+
+export const DenomCapacity = {
+  encode(message: DenomCapacity, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+
+    for (const v of message.capacityList) {
+      writer.uint32(18).bytes(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DenomCapacity {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDenomCapacity();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+
+        case 2:
+          message.capacityList.push(reader.bytes());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<DenomCapacity>): DenomCapacity {
+    const message = createBaseDenomCapacity();
+    message.denom = object.denom ?? "";
+    message.capacityList = object.capacityList?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseLimiterCapacity(): LimiterCapacity {
+  return {
+    limiter: undefined,
+    capacity: new Uint8Array()
+  };
+}
+
+export const LimiterCapacity = {
+  encode(message: LimiterCapacity, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.limiter !== undefined) {
+      Limiter.encode(message.limiter, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.capacity.length !== 0) {
+      writer.uint32(18).bytes(message.capacity);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LimiterCapacity {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLimiterCapacity();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.limiter = Limiter.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.capacity = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<LimiterCapacity>): LimiterCapacity {
+    const message = createBaseLimiterCapacity();
+    message.limiter = object.limiter !== undefined && object.limiter !== null ? Limiter.fromPartial(object.limiter) : undefined;
+    message.capacity = object.capacity ?? new Uint8Array();
+    return message;
+  }
+
+};

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

@@ -0,0 +1,59 @@
+import { LimitParams, LimitParamsSDKType } from "./limit_params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the ratelimit module's genesis state. */
+
+export interface GenesisState {
+  /** limit_params_list defines the list of `LimitParams` at genesis. */
+  limitParamsList: LimitParams[];
+}
+/** GenesisState defines the ratelimit module's genesis state. */
+
+export interface GenesisStateSDKType {
+  limit_params_list: LimitParamsSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    limitParamsList: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.limitParamsList) {
+      LimitParams.encode(v!, writer.uint32(10).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.limitParamsList.push(LimitParams.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.limitParamsList = object.limitParamsList?.map(e => LimitParams.fromPartial(e)) || [];
+    return message;
+  }
+
+};