@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.18

package/sparkdream/service/v1/operator.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operator = void 0;
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseOperator() {
+    return {
+        address: "",
+        serviceType: "",
+        controller: "",
+        bondAmount: "",
+        metadata: new Uint8Array(),
+        status: 0,
+        underfundedSince: BigInt(0),
+        unbondCompleteAt: BigInt(0),
+        tier1SlashedInWindow: "",
+        tier1WindowStart: BigInt(0),
+        tier1WindowStartBond: "",
+        registeredAt: BigInt(0),
+        retiredAt: BigInt(0),
+        totalLifetimeBondBlocks: "",
+        lastBondBlockUpdateAt: BigInt(0)
+    };
+}
+/**
+ * Operator is the canonical record for a SPARK-bonded external-service
+ * operator (see x-service-spec.md §3.1). Live records (status ∈
+ * {ACTIVE, UNDERFUNDED, UNBONDING}) live in the Operators store keyed by
+ * (address, service_type); terminal records (SLASHED, RETIRED) are moved
+ * to ArchivedOperators at the terminal transition.
+ * @name Operator
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Operator
+ */
+exports.Operator = {
+    typeUrl: "/sparkdream.service.v1.Operator",
+    aminoType: "sparkdream/x/service/Operator",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.controller !== "") {
+            writer.uint32(26).string(message.controller);
+        }
+        if (message.bondAmount !== "") {
+            writer.uint32(34).string(message.bondAmount);
+        }
+        if (message.metadata.length !== 0) {
+            writer.uint32(42).bytes(message.metadata);
+        }
+        if (message.status !== 0) {
+            writer.uint32(48).int32(message.status);
+        }
+        if (message.underfundedSince !== BigInt(0)) {
+            writer.uint32(56).int64(message.underfundedSince);
+        }
+        if (message.unbondCompleteAt !== BigInt(0)) {
+            writer.uint32(64).int64(message.unbondCompleteAt);
+        }
+        if (message.tier1SlashedInWindow !== "") {
+            writer.uint32(74).string(message.tier1SlashedInWindow);
+        }
+        if (message.tier1WindowStart !== BigInt(0)) {
+            writer.uint32(80).int64(message.tier1WindowStart);
+        }
+        if (message.tier1WindowStartBond !== "") {
+            writer.uint32(90).string(message.tier1WindowStartBond);
+        }
+        if (message.registeredAt !== BigInt(0)) {
+            writer.uint32(96).int64(message.registeredAt);
+        }
+        if (message.retiredAt !== BigInt(0)) {
+            writer.uint32(104).int64(message.retiredAt);
+        }
+        if (message.totalLifetimeBondBlocks !== "") {
+            writer.uint32(114).string(message.totalLifetimeBondBlocks);
+        }
+        if (message.lastBondBlockUpdateAt !== BigInt(0)) {
+            writer.uint32(120).int64(message.lastBondBlockUpdateAt);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOperator();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.controller = reader.string();
+                    break;
+                case 4:
+                    message.bondAmount = reader.string();
+                    break;
+                case 5:
+                    message.metadata = reader.bytes();
+                    break;
+                case 6:
+                    message.status = reader.int32();
+                    break;
+                case 7:
+                    message.underfundedSince = reader.int64();
+                    break;
+                case 8:
+                    message.unbondCompleteAt = reader.int64();
+                    break;
+                case 9:
+                    message.tier1SlashedInWindow = reader.string();
+                    break;
+                case 10:
+                    message.tier1WindowStart = reader.int64();
+                    break;
+                case 11:
+                    message.tier1WindowStartBond = reader.string();
+                    break;
+                case 12:
+                    message.registeredAt = reader.int64();
+                    break;
+                case 13:
+                    message.retiredAt = reader.int64();
+                    break;
+                case 14:
+                    message.totalLifetimeBondBlocks = reader.string();
+                    break;
+                case 15:
+                    message.lastBondBlockUpdateAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseOperator();
+        message.address = object.address ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.controller = object.controller ?? "";
+        message.bondAmount = object.bondAmount ?? "";
+        message.metadata = object.metadata ?? new Uint8Array();
+        message.status = object.status ?? 0;
+        message.underfundedSince = object.underfundedSince !== undefined && object.underfundedSince !== null ? BigInt(object.underfundedSince.toString()) : BigInt(0);
+        message.unbondCompleteAt = object.unbondCompleteAt !== undefined && object.unbondCompleteAt !== null ? BigInt(object.unbondCompleteAt.toString()) : BigInt(0);
+        message.tier1SlashedInWindow = object.tier1SlashedInWindow ?? "";
+        message.tier1WindowStart = object.tier1WindowStart !== undefined && object.tier1WindowStart !== null ? BigInt(object.tier1WindowStart.toString()) : BigInt(0);
+        message.tier1WindowStartBond = object.tier1WindowStartBond ?? "";
+        message.registeredAt = object.registeredAt !== undefined && object.registeredAt !== null ? BigInt(object.registeredAt.toString()) : BigInt(0);
+        message.retiredAt = object.retiredAt !== undefined && object.retiredAt !== null ? BigInt(object.retiredAt.toString()) : BigInt(0);
+        message.totalLifetimeBondBlocks = object.totalLifetimeBondBlocks ?? "";
+        message.lastBondBlockUpdateAt = object.lastBondBlockUpdateAt !== undefined && object.lastBondBlockUpdateAt !== null ? BigInt(object.lastBondBlockUpdateAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseOperator();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.controller !== undefined && object.controller !== null) {
+            message.controller = object.controller;
+        }
+        if (object.bond_amount !== undefined && object.bond_amount !== null) {
+            message.bondAmount = object.bond_amount;
+        }
+        if (object.metadata !== undefined && object.metadata !== null) {
+            message.metadata = (0, helpers_1.bytesFromBase64)(object.metadata);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.underfunded_since !== undefined && object.underfunded_since !== null) {
+            message.underfundedSince = BigInt(object.underfunded_since);
+        }
+        if (object.unbond_complete_at !== undefined && object.unbond_complete_at !== null) {
+            message.unbondCompleteAt = BigInt(object.unbond_complete_at);
+        }
+        if (object.tier1_slashed_in_window !== undefined && object.tier1_slashed_in_window !== null) {
+            message.tier1SlashedInWindow = object.tier1_slashed_in_window;
+        }
+        if (object.tier1_window_start !== undefined && object.tier1_window_start !== null) {
+            message.tier1WindowStart = BigInt(object.tier1_window_start);
+        }
+        if (object.tier1_window_start_bond !== undefined && object.tier1_window_start_bond !== null) {
+            message.tier1WindowStartBond = object.tier1_window_start_bond;
+        }
+        if (object.registered_at !== undefined && object.registered_at !== null) {
+            message.registeredAt = BigInt(object.registered_at);
+        }
+        if (object.retired_at !== undefined && object.retired_at !== null) {
+            message.retiredAt = BigInt(object.retired_at);
+        }
+        if (object.total_lifetime_bond_blocks !== undefined && object.total_lifetime_bond_blocks !== null) {
+            message.totalLifetimeBondBlocks = object.total_lifetime_bond_blocks;
+        }
+        if (object.last_bond_block_update_at !== undefined && object.last_bond_block_update_at !== null) {
+            message.lastBondBlockUpdateAt = BigInt(object.last_bond_block_update_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.controller = message.controller === "" ? undefined : message.controller;
+        obj.bond_amount = message.bondAmount === "" ? undefined : message.bondAmount;
+        obj.metadata = message.metadata ? (0, helpers_1.base64FromBytes)(message.metadata) : undefined;
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.underfunded_since = message.underfundedSince !== BigInt(0) ? message.underfundedSince?.toString() : undefined;
+        obj.unbond_complete_at = message.unbondCompleteAt !== BigInt(0) ? message.unbondCompleteAt?.toString() : undefined;
+        obj.tier1_slashed_in_window = message.tier1SlashedInWindow === "" ? undefined : message.tier1SlashedInWindow;
+        obj.tier1_window_start = message.tier1WindowStart !== BigInt(0) ? message.tier1WindowStart?.toString() : undefined;
+        obj.tier1_window_start_bond = message.tier1WindowStartBond === "" ? undefined : message.tier1WindowStartBond;
+        obj.registered_at = message.registeredAt !== BigInt(0) ? message.registeredAt?.toString() : undefined;
+        obj.retired_at = message.retiredAt !== BigInt(0) ? message.retiredAt?.toString() : undefined;
+        obj.total_lifetime_bond_blocks = message.totalLifetimeBondBlocks === "" ? undefined : message.totalLifetimeBondBlocks;
+        obj.last_bond_block_update_at = message.lastBondBlockUpdateAt !== BigInt(0) ? message.lastBondBlockUpdateAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Operator.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Operator",
+            value: exports.Operator.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Operator.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Operator.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Operator",
+            value: exports.Operator.encode(message).finish()
+        };
+    }
+};

package/sparkdream/service/v1/params.d.ts

@@ -0,0 +1,346 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Params defines the module-wide parameters for x/service. See
+ * x-service-spec.md §4.2 for full semantics and validation rules. All
+ * fields are x/gov-mutable via MsgUpdateParams unless hardened later
+ * via the x/mint immutable-parameter pattern (§4.2 high-impact
+ * hardening candidates).
+ *
+ * Per-service-type overrides for `default_*` fields live on
+ * ServiceTypeConfig (§3.2). The values here are the defaults that
+ * apply when a service type's override is zero.
+ *
+ * Bond-denom-valued amounts are stored as bare math.Int values; the
+ * keeper wraps them into sdk.Coin at the point of use via the identity
+ * keeper's BondDenom(ctx).
+ * @name Params
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Params
+ */
+export interface Params {
+    /**
+     * default_unbonding_period_blocks is the default unbonding window
+     * (~14 days at default block time).
+     */
+    defaultUnbondingPeriodBlocks: bigint;
+    /**
+     * default_unilateral_slash_cap_bps is the default per-slash cap
+     * (500 = 5%).
+     */
+    defaultUnilateralSlashCapBps: number;
+    /**
+     * default_tier1_window_blocks is the default rolling-window length
+     * for aggregate tier-1 cap accounting (~90 days).
+     */
+    defaultTier1WindowBlocks: bigint;
+    /**
+     * default_tier1_aggregate_cap_bps is the default cumulative-slash
+     * cap within the window (1500 = 15%).
+     */
+    defaultTier1AggregateCapBps: number;
+    /**
+     * default_tier1_cooldown_blocks is the default minimum interval
+     * between tier-1 slashes against the same operator (~7 days).
+     */
+    defaultTier1CooldownBlocks: bigint;
+    /**
+     * default_underfunded_grace_blocks is the default time an
+     * UNDERFUNDED operator has to top up before being force-unbonded
+     * (~7 days).
+     */
+    defaultUnderfundedGraceBlocks: bigint;
+    /**
+     * report_contest_window_blocks is the window an operator has to
+     * contest a tier-1 slash (~24 hours). Also the tier-1 escrow
+     * release delay.
+     */
+    reportContestWindowBlocks: bigint;
+    /**
+     * max_pending_blocks is the auto-dismiss horizon for PENDING
+     * reports (~30 days).
+     */
+    maxPendingBlocks: bigint;
+    /**
+     * max_escalated_blocks is the auto-timeout horizon for ESCALATED
+     * reports awaiting jury verdict (~60 days). MUST be greater than
+     * max_pending_blocks.
+     */
+    maxEscalatedBlocks: bigint;
+    /**
+     * report_refile_cooldown_blocks is the per-controller cooldown for
+     * re-filing a previously-dismissed allegation (~30 days). MUST be
+     * ≥ max_pending_blocks.
+     */
+    reportRefileCooldownBlocks: bigint;
+    /**
+     * report_deposit_amount is the SPARK escrow required to file
+     * MsgReportOperator, in bond-denom micro-units (default 10 SPARK =
+     * 10_000_000). Wrapped into sdk.Coin with the chain's bond denom
+     * at the point of use.
+     */
+    reportDepositAmount: string;
+    /**
+     * min_reporter_trust_level gates who can file reports, as an enum
+     * name (e.g. "TRUST_LEVEL_ESTABLISHED"). Empty = no gate.
+     */
+    minReporterTrustLevel: string;
+    /**
+     * max_reports_per_reporter_per_operator_per_window is the
+     * sliding-window cap on filings by a single reporter against a
+     * single (operator, service_type) (default 3).
+     */
+    maxReportsPerReporterPerOperatorPerWindow: number;
+    /**
+     * reporter_rate_limit_window_blocks is the window over which the
+     * above cap applies (~30 days).
+     */
+    reporterRateLimitWindowBlocks: bigint;
+    /**
+     * endblocker_sweep_limit is the per-queue per-block cap on records
+     * processed by EndBlocker sweeps (default 100). Prevents unbounded
+     * per-block work.
+     */
+    endblockerSweepLimit: number;
+    /**
+     * max_metadata_bytes caps Operator.metadata size (default 4096;
+     * hard cap 65536).
+     */
+    maxMetadataBytes: number;
+    /**
+     * max_reason_bytes caps Report.reason and similar free-form text
+     * (default 512; hard cap 4096).
+     */
+    maxReasonBytes: number;
+    /**
+     * max_active_operators_per_address caps the number of live
+     * operator records a single address may hold across service types
+     * (default 16). Prevents reputation gaming via mass
+     * micro-registration (§6.6).
+     */
+    maxActiveOperatorsPerAddress: number;
+    /**
+     * reputation_grant_per_bond_block is the reputation accrued per
+     * SPARK-block of ACTIVE bond, applied at successful unbond claim
+     * and capped by the §6.6 anti-gaming rule.
+     */
+    reputationGrantPerBondBlock: string;
+    /**
+     * default_pagination_limit is the default page size when a client
+     * omits pagination.limit on a paginated query (default 100).
+     */
+    defaultPaginationLimit: number;
+    /**
+     * max_pagination_limit hard-caps pagination.limit to bound query
+     * gas (default 1000; absolute cap 10000).
+     */
+    maxPaginationLimit: number;
+    /**
+     * max_system_reports_per_caller_per_window caps how many distinct
+     * system reports a single allowlisted caller module (e.g.
+     * "federation") may open via OpenSystemReport within a rolling
+     * window of rate_limit_window_blocks. Idempotent re-calls (same
+     * dedupe_key) don't count against the cap. Default 50 — tunable
+     * from observed federation challenge volume post-launch.
+     */
+    maxSystemReportsPerCallerPerWindow: number;
+    /**
+     * rate_limit_window_blocks is the rolling window over which the
+     * above per-caller cap applies (~1 day at default block time).
+     * x/service has no native epoch concept, so this is an explicit
+     * block-count param rather than reusing season/shield epochs.
+     */
+    rateLimitWindowBlocks: bigint;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/sparkdream.service.v1.Params";
+    value: Uint8Array;
+}
+/**
+ * Params defines the module-wide parameters for x/service. See
+ * x-service-spec.md §4.2 for full semantics and validation rules. All
+ * fields are x/gov-mutable via MsgUpdateParams unless hardened later
+ * via the x/mint immutable-parameter pattern (§4.2 high-impact
+ * hardening candidates).
+ *
+ * Per-service-type overrides for `default_*` fields live on
+ * ServiceTypeConfig (§3.2). The values here are the defaults that
+ * apply when a service type's override is zero.
+ *
+ * Bond-denom-valued amounts are stored as bare math.Int values; the
+ * keeper wraps them into sdk.Coin at the point of use via the identity
+ * keeper's BondDenom(ctx).
+ * @name ParamsAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Params
+ */
+export interface ParamsAmino {
+    /**
+     * default_unbonding_period_blocks is the default unbonding window
+     * (~14 days at default block time).
+     */
+    default_unbonding_period_blocks?: string;
+    /**
+     * default_unilateral_slash_cap_bps is the default per-slash cap
+     * (500 = 5%).
+     */
+    default_unilateral_slash_cap_bps?: number;
+    /**
+     * default_tier1_window_blocks is the default rolling-window length
+     * for aggregate tier-1 cap accounting (~90 days).
+     */
+    default_tier1_window_blocks?: string;
+    /**
+     * default_tier1_aggregate_cap_bps is the default cumulative-slash
+     * cap within the window (1500 = 15%).
+     */
+    default_tier1_aggregate_cap_bps?: number;
+    /**
+     * default_tier1_cooldown_blocks is the default minimum interval
+     * between tier-1 slashes against the same operator (~7 days).
+     */
+    default_tier1_cooldown_blocks?: string;
+    /**
+     * default_underfunded_grace_blocks is the default time an
+     * UNDERFUNDED operator has to top up before being force-unbonded
+     * (~7 days).
+     */
+    default_underfunded_grace_blocks?: string;
+    /**
+     * report_contest_window_blocks is the window an operator has to
+     * contest a tier-1 slash (~24 hours). Also the tier-1 escrow
+     * release delay.
+     */
+    report_contest_window_blocks?: string;
+    /**
+     * max_pending_blocks is the auto-dismiss horizon for PENDING
+     * reports (~30 days).
+     */
+    max_pending_blocks?: string;
+    /**
+     * max_escalated_blocks is the auto-timeout horizon for ESCALATED
+     * reports awaiting jury verdict (~60 days). MUST be greater than
+     * max_pending_blocks.
+     */
+    max_escalated_blocks?: string;
+    /**
+     * report_refile_cooldown_blocks is the per-controller cooldown for
+     * re-filing a previously-dismissed allegation (~30 days). MUST be
+     * ≥ max_pending_blocks.
+     */
+    report_refile_cooldown_blocks?: string;
+    /**
+     * report_deposit_amount is the SPARK escrow required to file
+     * MsgReportOperator, in bond-denom micro-units (default 10 SPARK =
+     * 10_000_000). Wrapped into sdk.Coin with the chain's bond denom
+     * at the point of use.
+     */
+    report_deposit_amount?: string;
+    /**
+     * min_reporter_trust_level gates who can file reports, as an enum
+     * name (e.g. "TRUST_LEVEL_ESTABLISHED"). Empty = no gate.
+     */
+    min_reporter_trust_level?: string;
+    /**
+     * max_reports_per_reporter_per_operator_per_window is the
+     * sliding-window cap on filings by a single reporter against a
+     * single (operator, service_type) (default 3).
+     */
+    max_reports_per_reporter_per_operator_per_window?: number;
+    /**
+     * reporter_rate_limit_window_blocks is the window over which the
+     * above cap applies (~30 days).
+     */
+    reporter_rate_limit_window_blocks?: string;
+    /**
+     * endblocker_sweep_limit is the per-queue per-block cap on records
+     * processed by EndBlocker sweeps (default 100). Prevents unbounded
+     * per-block work.
+     */
+    endblocker_sweep_limit?: number;
+    /**
+     * max_metadata_bytes caps Operator.metadata size (default 4096;
+     * hard cap 65536).
+     */
+    max_metadata_bytes?: number;
+    /**
+     * max_reason_bytes caps Report.reason and similar free-form text
+     * (default 512; hard cap 4096).
+     */
+    max_reason_bytes?: number;
+    /**
+     * max_active_operators_per_address caps the number of live
+     * operator records a single address may hold across service types
+     * (default 16). Prevents reputation gaming via mass
+     * micro-registration (§6.6).
+     */
+    max_active_operators_per_address?: number;
+    /**
+     * reputation_grant_per_bond_block is the reputation accrued per
+     * SPARK-block of ACTIVE bond, applied at successful unbond claim
+     * and capped by the §6.6 anti-gaming rule.
+     */
+    reputation_grant_per_bond_block?: string;
+    /**
+     * default_pagination_limit is the default page size when a client
+     * omits pagination.limit on a paginated query (default 100).
+     */
+    default_pagination_limit?: number;
+    /**
+     * max_pagination_limit hard-caps pagination.limit to bound query
+     * gas (default 1000; absolute cap 10000).
+     */
+    max_pagination_limit?: number;
+    /**
+     * max_system_reports_per_caller_per_window caps how many distinct
+     * system reports a single allowlisted caller module (e.g.
+     * "federation") may open via OpenSystemReport within a rolling
+     * window of rate_limit_window_blocks. Idempotent re-calls (same
+     * dedupe_key) don't count against the cap. Default 50 — tunable
+     * from observed federation challenge volume post-launch.
+     */
+    max_system_reports_per_caller_per_window?: number;
+    /**
+     * rate_limit_window_blocks is the rolling window over which the
+     * above per-caller cap applies (~1 day at default block time).
+     * x/service has no native epoch concept, so this is an explicit
+     * block-count param rather than reusing season/shield epochs.
+     */
+    rate_limit_window_blocks?: string;
+}
+export interface ParamsAminoMsg {
+    type: "sparkdream/x/service/Params";
+    value: ParamsAmino;
+}
+/**
+ * Params defines the module-wide parameters for x/service. See
+ * x-service-spec.md §4.2 for full semantics and validation rules. All
+ * fields are x/gov-mutable via MsgUpdateParams unless hardened later
+ * via the x/mint immutable-parameter pattern (§4.2 high-impact
+ * hardening candidates).
+ *
+ * Per-service-type overrides for `default_*` fields live on
+ * ServiceTypeConfig (§3.2). The values here are the defaults that
+ * apply when a service type's override is zero.
+ *
+ * Bond-denom-valued amounts are stored as bare math.Int values; the
+ * keeper wraps them into sdk.Coin at the point of use via the identity
+ * keeper's BondDenom(ctx).
+ * @name Params
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Params
+ */
+export declare const Params: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    toAminoMsg(message: Params): ParamsAminoMsg;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};