@sparkdreamnft/sparkdreamjs 0.0.29 → 0.0.30

package/esm/akash/bme/v1/params.js

@@ -0,0 +1,171 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseParams() {
+    return {
+        circuitBreakerWarnThreshold: 0,
+        circuitBreakerHaltThreshold: 0,
+        minEpochBlocks: BigInt(0),
+        epochBlocksBackoffPercent: 0,
+        mintSpreadBps: 0,
+        settleSpreadBps: 0,
+        maxEndblockerRecords: 0,
+        minMint: [],
+        maxPendingAttempts: 0
+    };
+}
+/**
+ * Params defines the parameters for the BME module
+ * @name Params
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.Params
+ */
+export const Params = {
+    typeUrl: "/akash.bme.v1.Params",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.circuitBreakerWarnThreshold !== 0) {
+            writer.uint32(8).uint32(message.circuitBreakerWarnThreshold);
+        }
+        if (message.circuitBreakerHaltThreshold !== 0) {
+            writer.uint32(16).uint32(message.circuitBreakerHaltThreshold);
+        }
+        if (message.minEpochBlocks !== BigInt(0)) {
+            writer.uint32(24).int64(message.minEpochBlocks);
+        }
+        if (message.epochBlocksBackoffPercent !== 0) {
+            writer.uint32(32).uint32(message.epochBlocksBackoffPercent);
+        }
+        if (message.mintSpreadBps !== 0) {
+            writer.uint32(48).uint32(message.mintSpreadBps);
+        }
+        if (message.settleSpreadBps !== 0) {
+            writer.uint32(56).uint32(message.settleSpreadBps);
+        }
+        if (message.maxEndblockerRecords !== 0) {
+            writer.uint32(64).uint32(message.maxEndblockerRecords);
+        }
+        for (const v of message.minMint) {
+            Coin.encode(v, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.maxPendingAttempts !== 0) {
+            writer.uint32(80).uint32(message.maxPendingAttempts);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.circuitBreakerWarnThreshold = reader.uint32();
+                    break;
+                case 2:
+                    message.circuitBreakerHaltThreshold = reader.uint32();
+                    break;
+                case 3:
+                    message.minEpochBlocks = reader.int64();
+                    break;
+                case 4:
+                    message.epochBlocksBackoffPercent = reader.uint32();
+                    break;
+                case 6:
+                    message.mintSpreadBps = reader.uint32();
+                    break;
+                case 7:
+                    message.settleSpreadBps = reader.uint32();
+                    break;
+                case 8:
+                    message.maxEndblockerRecords = reader.uint32();
+                    break;
+                case 9:
+                    message.minMint.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                case 10:
+                    message.maxPendingAttempts = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.circuitBreakerWarnThreshold = object.circuitBreakerWarnThreshold ?? 0;
+        message.circuitBreakerHaltThreshold = object.circuitBreakerHaltThreshold ?? 0;
+        message.minEpochBlocks = object.minEpochBlocks !== undefined && object.minEpochBlocks !== null ? BigInt(object.minEpochBlocks.toString()) : BigInt(0);
+        message.epochBlocksBackoffPercent = object.epochBlocksBackoffPercent ?? 0;
+        message.mintSpreadBps = object.mintSpreadBps ?? 0;
+        message.settleSpreadBps = object.settleSpreadBps ?? 0;
+        message.maxEndblockerRecords = object.maxEndblockerRecords ?? 0;
+        message.minMint = object.minMint?.map(e => Coin.fromPartial(e)) || [];
+        message.maxPendingAttempts = object.maxPendingAttempts ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        if (object.circuit_breaker_warn_threshold !== undefined && object.circuit_breaker_warn_threshold !== null) {
+            message.circuitBreakerWarnThreshold = object.circuit_breaker_warn_threshold;
+        }
+        if (object.circuit_breaker_halt_threshold !== undefined && object.circuit_breaker_halt_threshold !== null) {
+            message.circuitBreakerHaltThreshold = object.circuit_breaker_halt_threshold;
+        }
+        if (object.min_epoch_blocks !== undefined && object.min_epoch_blocks !== null) {
+            message.minEpochBlocks = BigInt(object.min_epoch_blocks);
+        }
+        if (object.epoch_blocks_backoff_percent !== undefined && object.epoch_blocks_backoff_percent !== null) {
+            message.epochBlocksBackoffPercent = object.epoch_blocks_backoff_percent;
+        }
+        if (object.mint_spread_bps !== undefined && object.mint_spread_bps !== null) {
+            message.mintSpreadBps = object.mint_spread_bps;
+        }
+        if (object.settle_spread_bps !== undefined && object.settle_spread_bps !== null) {
+            message.settleSpreadBps = object.settle_spread_bps;
+        }
+        if (object.max_endblocker_records !== undefined && object.max_endblocker_records !== null) {
+            message.maxEndblockerRecords = object.max_endblocker_records;
+        }
+        message.minMint = object.min_mint?.map(e => Coin.fromAmino(e)) || [];
+        if (object.max_pending_attempts !== undefined && object.max_pending_attempts !== null) {
+            message.maxPendingAttempts = object.max_pending_attempts;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.circuit_breaker_warn_threshold = message.circuitBreakerWarnThreshold === 0 ? undefined : message.circuitBreakerWarnThreshold;
+        obj.circuit_breaker_halt_threshold = message.circuitBreakerHaltThreshold === 0 ? undefined : message.circuitBreakerHaltThreshold;
+        obj.min_epoch_blocks = message.minEpochBlocks !== BigInt(0) ? message.minEpochBlocks?.toString() : undefined;
+        obj.epoch_blocks_backoff_percent = message.epochBlocksBackoffPercent === 0 ? undefined : message.epochBlocksBackoffPercent;
+        obj.mint_spread_bps = message.mintSpreadBps === 0 ? undefined : message.mintSpreadBps;
+        obj.settle_spread_bps = message.settleSpreadBps === 0 ? undefined : message.settleSpreadBps;
+        obj.max_endblocker_records = message.maxEndblockerRecords === 0 ? undefined : message.maxEndblockerRecords;
+        if (message.minMint) {
+            obj.min_mint = message.minMint.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.min_mint = message.minMint;
+        }
+        obj.max_pending_attempts = message.maxPendingAttempts === 0 ? undefined : message.maxPendingAttempts;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Params.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Params.decode(message.value);
+    },
+    toProto(message) {
+        return Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.Params",
+            value: Params.encode(message).finish()
+        };
+    }
+};