example-js-sdk 0.0.1

package/lib/codec/mememax/orbix/market/fee.d.ts

@@ -0,0 +1,134 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "mememax.orbix.market";
+/**
+ * A fee structure has multiple fee tiers are sorted by `required_stake`
+ * and a single fee category. When a trade is executed, the fee tier with
+ * the greatest required stake which is fulfilled by the user is used.
+ *
+ * There must always be at least one fee tier for the `spot` and `futures`
+ * `market_type` fee category that has 0 `required_stake` and no
+ * `whitelisted_address` so that it can act as the base fee for that market
+ * type.
+ */
+export interface FeeStructure {
+    feeCategory?: FeeCategory;
+    feeTiers: FeeTier[];
+}
+/**
+ * The category for a given fee tier, identified by the
+ * market being traded via `market_type` or `market_id`, and
+ * optionally a `whitelisted_address`.
+ */
+export interface FeeCategory {
+    /**
+     * Either `spot` or `futures` or nil. If nil, then
+     * a market_id must be provided.
+     */
+    marketType: string;
+    /**
+     * Can be used to override the `market_type` based fee to give
+     * specific markets a certain fee discount.
+     * Note that if there is already a fee tier for the user's stake that
+     * results in a lower fee for a given trade, that fee structure will be used
+     * instead.
+     */
+    marketId: string;
+    /**
+     * Optional parameter that can be used to give certain addresses
+     * additional fee tier(s) for the given `market_type` or `market_id`.
+     * Can only be used to reduce fees, not increase them. Can be used with module
+     * accounts.
+     */
+    whitelistedAddress: string;
+}
+/**
+ * A fee tier represents the trading fee for a user that meets the required
+ * stake.
+ */
+export interface FeeTier {
+    /** The required stake for a user for the fee tier to apply. */
+    requiredStake: string;
+    /** The taker and maker fee that applies when a trade is executed. */
+    tradingFees?: TradingFees;
+}
+/**
+ * The fees applied for each trade.
+ *
+ * Note that for greater `required_stake`, either the `taker_fee`
+ * or `maker_fee` must be reduced.
+ * Neither `taker_fee` nor `maker_fee` can be greater for
+ * a greater `required_stake`.
+ */
+export interface TradingFees {
+    /**
+     * The fee applied when the order is executed in the smame
+     * block greater as when it is triggered.
+     * Cannot be negative.
+     */
+    takerFee: string;
+    /**
+     * The fee or rebate (when negative) applied when the order is executed
+     * in a block greater than when it is triggered.
+     */
+    makerFee: string;
+}
+/**
+ * Allows non stake coins to count as part of the
+ * `required_stake` in a fee tier.
+ *
+ * For each stake equivalance, the amount of coins for
+ * the specificed denom in the user's available balance
+ * at the time of the trade will be divided by the `ratio`
+ * and added to his actual stake amount when checking
+ * for fee tier feecategories.
+ */
+export interface StakeEquivalence {
+    denom: string;
+    ratio: string;
+}
+export declare const FeeStructure: {
+    encode(message: FeeStructure, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FeeStructure;
+    fromJSON(object: any): FeeStructure;
+    toJSON(message: FeeStructure): unknown;
+    create(base?: DeepPartial<FeeStructure>): FeeStructure;
+    fromPartial(object: DeepPartial<FeeStructure>): FeeStructure;
+};
+export declare const FeeCategory: {
+    encode(message: FeeCategory, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FeeCategory;
+    fromJSON(object: any): FeeCategory;
+    toJSON(message: FeeCategory): unknown;
+    create(base?: DeepPartial<FeeCategory>): FeeCategory;
+    fromPartial(object: DeepPartial<FeeCategory>): FeeCategory;
+};
+export declare const FeeTier: {
+    encode(message: FeeTier, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FeeTier;
+    fromJSON(object: any): FeeTier;
+    toJSON(message: FeeTier): unknown;
+    create(base?: DeepPartial<FeeTier>): FeeTier;
+    fromPartial(object: DeepPartial<FeeTier>): FeeTier;
+};
+export declare const TradingFees: {
+    encode(message: TradingFees, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TradingFees;
+    fromJSON(object: any): TradingFees;
+    toJSON(message: TradingFees): unknown;
+    create(base?: DeepPartial<TradingFees>): TradingFees;
+    fromPartial(object: DeepPartial<TradingFees>): TradingFees;
+};
+export declare const StakeEquivalence: {
+    encode(message: StakeEquivalence, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StakeEquivalence;
+    fromJSON(object: any): StakeEquivalence;
+    toJSON(message: StakeEquivalence): unknown;
+    create(base?: DeepPartial<StakeEquivalence>): StakeEquivalence;
+    fromPartial(object: DeepPartial<StakeEquivalence>): StakeEquivalence;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/mememax/orbix/market/fee.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakeEquivalence = exports.TradingFees = exports.FeeTier = exports.FeeCategory = exports.FeeStructure = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "mememax.orbix.market";
+function createBaseFeeStructure() {
+    return { feeCategory: undefined, feeTiers: [] };
+}
+exports.FeeStructure = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.feeCategory !== undefined) {
+            exports.FeeCategory.encode(message.feeCategory, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.feeTiers) {
+            exports.FeeTier.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFeeStructure();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.feeCategory = exports.FeeCategory.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.feeTiers.push(exports.FeeTier.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            feeCategory: isSet(object.feeCategory) ? exports.FeeCategory.fromJSON(object.feeCategory) : undefined,
+            feeTiers: Array.isArray(object?.feeTiers) ? object.feeTiers.map((e) => exports.FeeTier.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.feeCategory !== undefined &&
+            (obj.feeCategory = message.feeCategory ? exports.FeeCategory.toJSON(message.feeCategory) : undefined);
+        if (message.feeTiers) {
+            obj.feeTiers = message.feeTiers.map((e) => e ? exports.FeeTier.toJSON(e) : undefined);
+        }
+        else {
+            obj.feeTiers = [];
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.FeeStructure.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFeeStructure();
+        message.feeCategory = (object.feeCategory !== undefined && object.feeCategory !== null)
+            ? exports.FeeCategory.fromPartial(object.feeCategory)
+            : undefined;
+        message.feeTiers = object.feeTiers?.map((e) => exports.FeeTier.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseFeeCategory() {
+    return { marketType: "", marketId: "", whitelistedAddress: "" };
+}
+exports.FeeCategory = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.marketType !== "") {
+            writer.uint32(10).string(message.marketType);
+        }
+        if (message.marketId !== "") {
+            writer.uint32(18).string(message.marketId);
+        }
+        if (message.whitelistedAddress !== "") {
+            writer.uint32(34).string(message.whitelistedAddress);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFeeCategory();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.marketType = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.marketId = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.whitelistedAddress = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            marketType: isSet(object.marketType) ? String(object.marketType) : "",
+            marketId: isSet(object.marketId) ? String(object.marketId) : "",
+            whitelistedAddress: isSet(object.whitelistedAddress) ? String(object.whitelistedAddress) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.marketType !== undefined && (obj.marketType = message.marketType);
+        message.marketId !== undefined && (obj.marketId = message.marketId);
+        message.whitelistedAddress !== undefined && (obj.whitelistedAddress = message.whitelistedAddress);
+        return obj;
+    },
+    create(base) {
+        return exports.FeeCategory.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFeeCategory();
+        message.marketType = object.marketType ?? "";
+        message.marketId = object.marketId ?? "";
+        message.whitelistedAddress = object.whitelistedAddress ?? "";
+        return message;
+    },
+};
+function createBaseFeeTier() {
+    return { requiredStake: "", tradingFees: undefined };
+}
+exports.FeeTier = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.requiredStake !== "") {
+            writer.uint32(10).string(message.requiredStake);
+        }
+        if (message.tradingFees !== undefined) {
+            exports.TradingFees.encode(message.tradingFees, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFeeTier();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.requiredStake = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.tradingFees = exports.TradingFees.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            requiredStake: isSet(object.requiredStake) ? String(object.requiredStake) : "",
+            tradingFees: isSet(object.tradingFees) ? exports.TradingFees.fromJSON(object.tradingFees) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.requiredStake !== undefined && (obj.requiredStake = message.requiredStake);
+        message.tradingFees !== undefined &&
+            (obj.tradingFees = message.tradingFees ? exports.TradingFees.toJSON(message.tradingFees) : undefined);
+        return obj;
+    },
+    create(base) {
+        return exports.FeeTier.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFeeTier();
+        message.requiredStake = object.requiredStake ?? "";
+        message.tradingFees = (object.tradingFees !== undefined && object.tradingFees !== null)
+            ? exports.TradingFees.fromPartial(object.tradingFees)
+            : undefined;
+        return message;
+    },
+};
+function createBaseTradingFees() {
+    return { takerFee: "", makerFee: "" };
+}
+exports.TradingFees = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.takerFee !== "") {
+            writer.uint32(42).string(message.takerFee);
+        }
+        if (message.makerFee !== "") {
+            writer.uint32(50).string(message.makerFee);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTradingFees();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.takerFee = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.makerFee = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            takerFee: isSet(object.takerFee) ? String(object.takerFee) : "",
+            makerFee: isSet(object.makerFee) ? String(object.makerFee) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.takerFee !== undefined && (obj.takerFee = message.takerFee);
+        message.makerFee !== undefined && (obj.makerFee = message.makerFee);
+        return obj;
+    },
+    create(base) {
+        return exports.TradingFees.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTradingFees();
+        message.takerFee = object.takerFee ?? "";
+        message.makerFee = object.makerFee ?? "";
+        return message;
+    },
+};
+function createBaseStakeEquivalence() {
+    return { denom: "", ratio: "" };
+}
+exports.StakeEquivalence = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.ratio !== "") {
+            writer.uint32(18).string(message.ratio);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStakeEquivalence();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.denom = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ratio = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            denom: isSet(object.denom) ? String(object.denom) : "",
+            ratio: isSet(object.ratio) ? String(object.ratio) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.denom !== undefined && (obj.denom = message.denom);
+        message.ratio !== undefined && (obj.ratio = message.ratio);
+        return obj;
+    },
+    create(base) {
+        return exports.StakeEquivalence.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseStakeEquivalence();
+        message.denom = object.denom ?? "";
+        message.ratio = object.ratio ?? "";
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/lib/codec/mememax/orbix/market/genesis.d.ts

@@ -0,0 +1,33 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { FeeStructure, StakeEquivalence } from "./fee";
+import { ControlledParams, Market } from "./market";
+import { Params } from "./params";
+export declare const protobufPackage = "mememax.orbix.market";
+/** GenesisState defines the market module's genesis state. */
+export interface GenesisState {
+    /**
+     * this line is used by starport scaffolding # genesis/proto/state
+     * this line is used by starport scaffolding # ibc/genesis/proto
+     */
+    markets: Market[];
+    /** params defines all the paramaters of the module. */
+    params?: Params;
+    controlledParams?: ControlledParams;
+    marketIdSequence: Long;
+    stakeEquivalences: StakeEquivalence[];
+    feeStructures: FeeStructure[];
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    create(base?: DeepPartial<GenesisState>): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/mememax/orbix/market/genesis.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const fee_1 = require("./fee");
+const market_1 = require("./market");
+const params_1 = require("./params");
+exports.protobufPackage = "mememax.orbix.market";
+function createBaseGenesisState() {
+    return {
+        markets: [],
+        params: undefined,
+        controlledParams: undefined,
+        marketIdSequence: long_1.default.ZERO,
+        stakeEquivalences: [],
+        feeStructures: [],
+    };
+}
+exports.GenesisState = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.markets) {
+            market_1.Market.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.controlledParams !== undefined) {
+            market_1.ControlledParams.encode(message.controlledParams, writer.uint32(26).fork()).ldelim();
+        }
+        if (!message.marketIdSequence.isZero()) {
+            writer.uint32(32).int64(message.marketIdSequence);
+        }
+        for (const v of message.stakeEquivalences) {
+            fee_1.StakeEquivalence.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.feeStructures) {
+            fee_1.FeeStructure.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.markets.push(market_1.Market.decode(reader, reader.uint32()));
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.params = params_1.Params.decode(reader, reader.uint32());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.controlledParams = market_1.ControlledParams.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.marketIdSequence = reader.int64();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.stakeEquivalences.push(fee_1.StakeEquivalence.decode(reader, reader.uint32()));
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.feeStructures.push(fee_1.FeeStructure.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            markets: Array.isArray(object?.markets) ? object.markets.map((e) => market_1.Market.fromJSON(e)) : [],
+            params: isSet(object.params) ? params_1.Params.fromJSON(object.params) : undefined,
+            controlledParams: isSet(object.controlledParams) ? market_1.ControlledParams.fromJSON(object.controlledParams) : undefined,
+            marketIdSequence: isSet(object.marketIdSequence) ? long_1.default.fromValue(object.marketIdSequence) : long_1.default.ZERO,
+            stakeEquivalences: Array.isArray(object?.stakeEquivalences)
+                ? object.stakeEquivalences.map((e) => fee_1.StakeEquivalence.fromJSON(e))
+                : [],
+            feeStructures: Array.isArray(object?.feeStructures)
+                ? object.feeStructures.map((e) => fee_1.FeeStructure.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.markets) {
+            obj.markets = message.markets.map((e) => e ? market_1.Market.toJSON(e) : undefined);
+        }
+        else {
+            obj.markets = [];
+        }
+        message.params !== undefined && (obj.params = message.params ? params_1.Params.toJSON(message.params) : undefined);
+        message.controlledParams !== undefined &&
+            (obj.controlledParams = message.controlledParams ? market_1.ControlledParams.toJSON(message.controlledParams) : undefined);
+        message.marketIdSequence !== undefined &&
+            (obj.marketIdSequence = (message.marketIdSequence || long_1.default.ZERO).toString());
+        if (message.stakeEquivalences) {
+            obj.stakeEquivalences = message.stakeEquivalences.map((e) => e ? fee_1.StakeEquivalence.toJSON(e) : undefined);
+        }
+        else {
+            obj.stakeEquivalences = [];
+        }
+        if (message.feeStructures) {
+            obj.feeStructures = message.feeStructures.map((e) => e ? fee_1.FeeStructure.toJSON(e) : undefined);
+        }
+        else {
+            obj.feeStructures = [];
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.GenesisState.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.markets = object.markets?.map((e) => market_1.Market.fromPartial(e)) || [];
+        message.params = (object.params !== undefined && object.params !== null)
+            ? params_1.Params.fromPartial(object.params)
+            : undefined;
+        message.controlledParams = (object.controlledParams !== undefined && object.controlledParams !== null)
+            ? market_1.ControlledParams.fromPartial(object.controlledParams)
+            : undefined;
+        message.marketIdSequence = (object.marketIdSequence !== undefined && object.marketIdSequence !== null)
+            ? long_1.default.fromValue(object.marketIdSequence)
+            : long_1.default.ZERO;
+        message.stakeEquivalences = object.stakeEquivalences?.map((e) => fee_1.StakeEquivalence.fromPartial(e)) || [];
+        message.feeStructures = object.feeStructures?.map((e) => fee_1.FeeStructure.fromPartial(e)) || [];
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}