@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.30

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

@@ -0,0 +1,1274 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@interchainjs/math";
+/** MintStatus indicates the current state of mint */
+export var MintStatus;
+(function (MintStatus) {
+    /** mint_status_unspecified - MINT_STATUS_UNSPECIFIED is the default value */
+    MintStatus[MintStatus["mint_status_unspecified"] = 0] = "mint_status_unspecified";
+    /** mint_status_healthy - MINT_STATUS_HEALTHY indicates normal operation (CR > warn threshold) */
+    MintStatus[MintStatus["mint_status_healthy"] = 1] = "mint_status_healthy";
+    /** mint_status_warning - MINT_STATUS_WARNING indicates CR is below warning threshold */
+    MintStatus[MintStatus["mint_status_warning"] = 2] = "mint_status_warning";
+    /** mint_status_halt_cr - MINT_STATUS_HALT_CR indicates CR is below halt threshold, mints paused */
+    MintStatus[MintStatus["mint_status_halt_cr"] = 3] = "mint_status_halt_cr";
+    /** mint_status_halt_oracle - MINT_STATUS_HALT_ORACLE indicates circuit breaker tripped due to unhealthy oracle price */
+    MintStatus[MintStatus["mint_status_halt_oracle"] = 4] = "mint_status_halt_oracle";
+    MintStatus[MintStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(MintStatus || (MintStatus = {}));
+export const MintStatusAmino = MintStatus;
+export function mintStatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "mint_status_unspecified":
+            return MintStatus.mint_status_unspecified;
+        case 1:
+        case "mint_status_healthy":
+            return MintStatus.mint_status_healthy;
+        case 2:
+        case "mint_status_warning":
+            return MintStatus.mint_status_warning;
+        case 3:
+        case "mint_status_halt_cr":
+            return MintStatus.mint_status_halt_cr;
+        case 4:
+        case "mint_status_halt_oracle":
+            return MintStatus.mint_status_halt_oracle;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return MintStatus.UNRECOGNIZED;
+    }
+}
+export function mintStatusToJSON(object) {
+    switch (object) {
+        case MintStatus.mint_status_unspecified:
+            return "mint_status_unspecified";
+        case MintStatus.mint_status_healthy:
+            return "mint_status_healthy";
+        case MintStatus.mint_status_warning:
+            return "mint_status_warning";
+        case MintStatus.mint_status_halt_cr:
+            return "mint_status_halt_cr";
+        case MintStatus.mint_status_halt_oracle:
+            return "mint_status_halt_oracle";
+        case MintStatus.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** LedgerRecordStatus indicates the current state of a burn/mint ledger record */
+export var LedgerRecordStatus;
+(function (LedgerRecordStatus) {
+    /**
+     * ledger_record_status_invalid - LEDGER_RECORD_STATUS_INVALID is the default/uninitialized value
+     * This status should never appear in a valid ledger record
+     */
+    LedgerRecordStatus[LedgerRecordStatus["ledger_record_status_invalid"] = 0] = "ledger_record_status_invalid";
+    /**
+     * ledger_record_status_pending - LEDGER_RECORD_STATUS_PENDING indicates a burn/mint operation has been initiated
+     * but not yet executed (e.g., waiting for oracle price or circuit breaker clearance)
+     */
+    LedgerRecordStatus[LedgerRecordStatus["ledger_record_status_pending"] = 1] = "ledger_record_status_pending";
+    /**
+     * ledger_record_status_executed - LEDGER_RECORD_STATUS_EXECUTED indicates the burn/mint operation has been
+     * successfully completed and tokens have been burned and minted
+     */
+    LedgerRecordStatus[LedgerRecordStatus["ledger_record_status_executed"] = 2] = "ledger_record_status_executed";
+    /**
+     * ledger_record_status_canceled - LEDGER_RECORD_STATUS_CANCELED indicates the burn/mint operation has encountered error and funds have been returned to the owner
+     * successfully completed and tokens have been burned and minted
+     */
+    LedgerRecordStatus[LedgerRecordStatus["ledger_record_status_canceled"] = 3] = "ledger_record_status_canceled";
+    LedgerRecordStatus[LedgerRecordStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(LedgerRecordStatus || (LedgerRecordStatus = {}));
+export const LedgerRecordStatusAmino = LedgerRecordStatus;
+export function ledgerRecordStatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "ledger_record_status_invalid":
+            return LedgerRecordStatus.ledger_record_status_invalid;
+        case 1:
+        case "ledger_record_status_pending":
+            return LedgerRecordStatus.ledger_record_status_pending;
+        case 2:
+        case "ledger_record_status_executed":
+            return LedgerRecordStatus.ledger_record_status_executed;
+        case 3:
+        case "ledger_record_status_canceled":
+            return LedgerRecordStatus.ledger_record_status_canceled;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return LedgerRecordStatus.UNRECOGNIZED;
+    }
+}
+export function ledgerRecordStatusToJSON(object) {
+    switch (object) {
+        case LedgerRecordStatus.ledger_record_status_invalid:
+            return "ledger_record_status_invalid";
+        case LedgerRecordStatus.ledger_record_status_pending:
+            return "ledger_record_status_pending";
+        case LedgerRecordStatus.ledger_record_status_executed:
+            return "ledger_record_status_executed";
+        case LedgerRecordStatus.ledger_record_status_canceled:
+            return "ledger_record_status_canceled";
+        case LedgerRecordStatus.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** BMCancelReason is an enum indicating reasons of failure for burn/mint request */
+export var LedgerCanceledRecord_BMCancelReason;
+(function (LedgerCanceledRecord_BMCancelReason) {
+    /** unknown - Prefix should start with 0 in enum. So declaring dummy state. */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["unknown"] = 0] = "unknown";
+    /** epsilon - BMCancelReasonEpsilon the result of conversion is below the smallest meaningful difference (10^-6) */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["epsilon"] = 1] = "epsilon";
+    /** zero_price - BMCancelReasonZeroPrice oracle price is zero */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["zero_price"] = 2] = "zero_price";
+    /** insufficient_funds - BMCancelReasonInsufficientFunds insufficient vault/supply funds */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["insufficient_funds"] = 3] = "insufficient_funds";
+    /** invalid_denom - BMCancelReasonInvalidDenom denomination is not registered */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["invalid_denom"] = 4] = "invalid_denom";
+    /** invalid_amount - BMCancelReasonInvalidAmount zero or invalid burn amount */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["invalid_amount"] = 5] = "invalid_amount";
+    /** minimum_mint - BMCancelReasonMinimumMint mint output below minimum threshold */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["minimum_mint"] = 6] = "minimum_mint";
+    /** mint_failed - BMCancelReasonMintFailed bank MintCoins operation failed */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["mint_failed"] = 7] = "mint_failed";
+    /** burn_failed - BMCancelReasonBurnFailed bank BurnCoins operation failed */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["burn_failed"] = 8] = "burn_failed";
+    /** max_attempts - BMCancelReasonMaxAttempts exceeded maximum pending processing attempts */
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["max_attempts"] = 9] = "max_attempts";
+    LedgerCanceledRecord_BMCancelReason[LedgerCanceledRecord_BMCancelReason["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(LedgerCanceledRecord_BMCancelReason || (LedgerCanceledRecord_BMCancelReason = {}));
+export const LedgerCanceledRecord_BMCancelReasonAmino = LedgerCanceledRecord_BMCancelReason;
+export function ledgerCanceledRecord_BMCancelReasonFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "unknown":
+            return LedgerCanceledRecord_BMCancelReason.unknown;
+        case 1:
+        case "epsilon":
+            return LedgerCanceledRecord_BMCancelReason.epsilon;
+        case 2:
+        case "zero_price":
+            return LedgerCanceledRecord_BMCancelReason.zero_price;
+        case 3:
+        case "insufficient_funds":
+            return LedgerCanceledRecord_BMCancelReason.insufficient_funds;
+        case 4:
+        case "invalid_denom":
+            return LedgerCanceledRecord_BMCancelReason.invalid_denom;
+        case 5:
+        case "invalid_amount":
+            return LedgerCanceledRecord_BMCancelReason.invalid_amount;
+        case 6:
+        case "minimum_mint":
+            return LedgerCanceledRecord_BMCancelReason.minimum_mint;
+        case 7:
+        case "mint_failed":
+            return LedgerCanceledRecord_BMCancelReason.mint_failed;
+        case 8:
+        case "burn_failed":
+            return LedgerCanceledRecord_BMCancelReason.burn_failed;
+        case 9:
+        case "max_attempts":
+            return LedgerCanceledRecord_BMCancelReason.max_attempts;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return LedgerCanceledRecord_BMCancelReason.UNRECOGNIZED;
+    }
+}
+export function ledgerCanceledRecord_BMCancelReasonToJSON(object) {
+    switch (object) {
+        case LedgerCanceledRecord_BMCancelReason.unknown:
+            return "unknown";
+        case LedgerCanceledRecord_BMCancelReason.epsilon:
+            return "epsilon";
+        case LedgerCanceledRecord_BMCancelReason.zero_price:
+            return "zero_price";
+        case LedgerCanceledRecord_BMCancelReason.insufficient_funds:
+            return "insufficient_funds";
+        case LedgerCanceledRecord_BMCancelReason.invalid_denom:
+            return "invalid_denom";
+        case LedgerCanceledRecord_BMCancelReason.invalid_amount:
+            return "invalid_amount";
+        case LedgerCanceledRecord_BMCancelReason.minimum_mint:
+            return "minimum_mint";
+        case LedgerCanceledRecord_BMCancelReason.mint_failed:
+            return "mint_failed";
+        case LedgerCanceledRecord_BMCancelReason.burn_failed:
+            return "burn_failed";
+        case LedgerCanceledRecord_BMCancelReason.max_attempts:
+            return "max_attempts";
+        case LedgerCanceledRecord_BMCancelReason.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseLedgerID() {
+    return {
+        height: BigInt(0),
+        sequence: BigInt(0)
+    };
+}
+/**
+ * LedgerID uniquely identifies a ledger entry by block height and sequence number
+ * @name LedgerID
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.LedgerID
+ */
+export const LedgerID = {
+    typeUrl: "/akash.bme.v1.LedgerID",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.height !== BigInt(0)) {
+            writer.uint32(8).int64(message.height);
+        }
+        if (message.sequence !== BigInt(0)) {
+            writer.uint32(16).int64(message.sequence);
+        }
+        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 = createBaseLedgerID();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.height = reader.int64();
+                    break;
+                case 2:
+                    message.sequence = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLedgerID();
+        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLedgerID();
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        if (object.sequence !== undefined && object.sequence !== null) {
+            message.sequence = BigInt(object.sequence);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.height = message.height ? message.height?.toString() : "0";
+        obj.sequence = message.sequence ? message.sequence?.toString() : "0";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LedgerID.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LedgerID.decode(message.value);
+    },
+    toProto(message) {
+        return LedgerID.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.LedgerID",
+            value: LedgerID.encode(message).finish()
+        };
+    }
+};
+function createBaseCollateralRatio() {
+    return {
+        ratio: "",
+        status: 0,
+        referencePrice: ""
+    };
+}
+/**
+ * CollateralRatio represents the current collateral ratio
+ * @name CollateralRatio
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.CollateralRatio
+ */
+export const CollateralRatio = {
+    typeUrl: "/akash.bme.v1.CollateralRatio",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.ratio !== "") {
+            writer.uint32(10).string(Decimal.fromUserInput(message.ratio, 18).atomics);
+        }
+        if (message.status !== 0) {
+            writer.uint32(16).int32(message.status);
+        }
+        if (message.referencePrice !== "") {
+            writer.uint32(26).string(Decimal.fromUserInput(message.referencePrice, 18).atomics);
+        }
+        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 = createBaseCollateralRatio();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.ratio = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                case 2:
+                    message.status = reader.int32();
+                    break;
+                case 3:
+                    message.referencePrice = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCollateralRatio();
+        message.ratio = object.ratio ?? "";
+        message.status = object.status ?? 0;
+        message.referencePrice = object.referencePrice ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCollateralRatio();
+        if (object.ratio !== undefined && object.ratio !== null) {
+            message.ratio = object.ratio;
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.reference_price !== undefined && object.reference_price !== null) {
+            message.referencePrice = object.reference_price;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.ratio = message.ratio === "" ? undefined : message.ratio;
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.reference_price = message.referencePrice === "" ? undefined : message.referencePrice;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CollateralRatio.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return CollateralRatio.decode(message.value);
+    },
+    toProto(message) {
+        return CollateralRatio.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.CollateralRatio",
+            value: CollateralRatio.encode(message).finish()
+        };
+    }
+};
+function createBaseState() {
+    return {
+        balances: [],
+        totalBurned: [],
+        totalMinted: [],
+        remintCredits: []
+    };
+}
+/**
+ * State tracks net burn metrics since BME start
+ * @name State
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.State
+ */
+export const State = {
+    typeUrl: "/akash.bme.v1.State",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.balances) {
+            Coin.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.totalBurned) {
+            Coin.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.totalMinted) {
+            Coin.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.remintCredits) {
+            Coin.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        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 = createBaseState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.balances.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.totalBurned.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.totalMinted.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.remintCredits.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseState();
+        message.balances = object.balances?.map(e => Coin.fromPartial(e)) || [];
+        message.totalBurned = object.totalBurned?.map(e => Coin.fromPartial(e)) || [];
+        message.totalMinted = object.totalMinted?.map(e => Coin.fromPartial(e)) || [];
+        message.remintCredits = object.remintCredits?.map(e => Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseState();
+        message.balances = object.balances?.map(e => Coin.fromAmino(e)) || [];
+        message.totalBurned = object.total_burned?.map(e => Coin.fromAmino(e)) || [];
+        message.totalMinted = object.total_minted?.map(e => Coin.fromAmino(e)) || [];
+        message.remintCredits = object.remint_credits?.map(e => Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.balances) {
+            obj.balances = message.balances.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.balances = message.balances;
+        }
+        if (message.totalBurned) {
+            obj.total_burned = message.totalBurned.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.total_burned = message.totalBurned;
+        }
+        if (message.totalMinted) {
+            obj.total_minted = message.totalMinted.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.total_minted = message.totalMinted;
+        }
+        if (message.remintCredits) {
+            obj.remint_credits = message.remintCredits.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.remint_credits = message.remintCredits;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return State.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return State.decode(message.value);
+    },
+    toProto(message) {
+        return State.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.State",
+            value: State.encode(message).finish()
+        };
+    }
+};
+function createBaseCoinPrice() {
+    return {
+        coin: Coin.fromPartial({}),
+        price: ""
+    };
+}
+/**
+ * CoinPrice represents a coin amount with its associated oracle price at a specific point in time
+ * @name CoinPrice
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.CoinPrice
+ */
+export const CoinPrice = {
+    typeUrl: "/akash.bme.v1.CoinPrice",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.coin !== undefined) {
+            Coin.encode(message.coin, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.price !== "") {
+            writer.uint32(18).string(Decimal.fromUserInput(message.price, 18).atomics);
+        }
+        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 = createBaseCoinPrice();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.coin = Coin.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.price = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCoinPrice();
+        message.coin = object.coin !== undefined && object.coin !== null ? Coin.fromPartial(object.coin) : undefined;
+        message.price = object.price ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCoinPrice();
+        if (object.coin !== undefined && object.coin !== null) {
+            message.coin = Coin.fromAmino(object.coin);
+        }
+        if (object.price !== undefined && object.price !== null) {
+            message.price = object.price;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.coin = message.coin ? Coin.toAmino(message.coin) : Coin.toAmino(Coin.fromPartial({}));
+        obj.price = message.price ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CoinPrice.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return CoinPrice.decode(message.value);
+    },
+    toProto(message) {
+        return CoinPrice.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.CoinPrice",
+            value: CoinPrice.encode(message).finish()
+        };
+    }
+};
+function createBaseBurnMintPair() {
+    return {
+        burned: CoinPrice.fromPartial({}),
+        minted: CoinPrice.fromPartial({})
+    };
+}
+/**
+ * BurnMintPair represents a pair of burn and mint operations with their respective prices
+ * @name BurnMintPair
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.BurnMintPair
+ */
+export const BurnMintPair = {
+    typeUrl: "/akash.bme.v1.BurnMintPair",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.burned !== undefined) {
+            CoinPrice.encode(message.burned, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.minted !== undefined) {
+            CoinPrice.encode(message.minted, writer.uint32(26).fork()).ldelim();
+        }
+        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 = createBaseBurnMintPair();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.burned = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.minted = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBurnMintPair();
+        message.burned = object.burned !== undefined && object.burned !== null ? CoinPrice.fromPartial(object.burned) : undefined;
+        message.minted = object.minted !== undefined && object.minted !== null ? CoinPrice.fromPartial(object.minted) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBurnMintPair();
+        if (object.burned !== undefined && object.burned !== null) {
+            message.burned = CoinPrice.fromAmino(object.burned);
+        }
+        if (object.minted !== undefined && object.minted !== null) {
+            message.minted = CoinPrice.fromAmino(object.minted);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.burned = message.burned ? CoinPrice.toAmino(message.burned) : CoinPrice.toAmino(CoinPrice.fromPartial({}));
+        obj.minted = message.minted ? CoinPrice.toAmino(message.minted) : CoinPrice.toAmino(CoinPrice.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return BurnMintPair.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return BurnMintPair.decode(message.value);
+    },
+    toProto(message) {
+        return BurnMintPair.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.BurnMintPair",
+            value: BurnMintPair.encode(message).finish()
+        };
+    }
+};
+function createBaseLedgerRecordID() {
+    return {
+        denom: "",
+        toDenom: "",
+        source: "",
+        height: BigInt(0),
+        sequence: BigInt(0)
+    };
+}
+/**
+ * LedgerRecordID
+ * @name LedgerRecordID
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.LedgerRecordID
+ */
+export const LedgerRecordID = {
+    typeUrl: "/akash.bme.v1.LedgerRecordID",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.toDenom !== "") {
+            writer.uint32(18).string(message.toDenom);
+        }
+        if (message.source !== "") {
+            writer.uint32(26).string(message.source);
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(32).int64(message.height);
+        }
+        if (message.sequence !== BigInt(0)) {
+            writer.uint32(40).int64(message.sequence);
+        }
+        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 = createBaseLedgerRecordID();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                case 2:
+                    message.toDenom = reader.string();
+                    break;
+                case 3:
+                    message.source = reader.string();
+                    break;
+                case 4:
+                    message.height = reader.int64();
+                    break;
+                case 5:
+                    message.sequence = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLedgerRecordID();
+        message.denom = object.denom ?? "";
+        message.toDenom = object.toDenom ?? "";
+        message.source = object.source ?? "";
+        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLedgerRecordID();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.to_denom !== undefined && object.to_denom !== null) {
+            message.toDenom = object.to_denom;
+        }
+        if (object.source !== undefined && object.source !== null) {
+            message.source = object.source;
+        }
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        if (object.sequence !== undefined && object.sequence !== null) {
+            message.sequence = BigInt(object.sequence);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.denom = message.denom ?? "";
+        obj.to_denom = message.toDenom ?? "";
+        obj.source = message.source ?? "";
+        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LedgerRecordID.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LedgerRecordID.decode(message.value);
+    },
+    toProto(message) {
+        return LedgerRecordID.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.LedgerRecordID",
+            value: LedgerRecordID.encode(message).finish()
+        };
+    }
+};
+function createBaseLedgerPendingRecord() {
+    return {
+        owner: "",
+        to: "",
+        coinsToBurn: Coin.fromPartial({}),
+        denomToMint: "",
+        attempts: 0
+    };
+}
+/**
+ * LedgerPendingRecord
+ * @name LedgerPendingRecord
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.LedgerPendingRecord
+ */
+export const LedgerPendingRecord = {
+    typeUrl: "/akash.bme.v1.LedgerPendingRecord",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.to !== "") {
+            writer.uint32(18).string(message.to);
+        }
+        if (message.coinsToBurn !== undefined) {
+            Coin.encode(message.coinsToBurn, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.denomToMint !== "") {
+            writer.uint32(34).string(message.denomToMint);
+        }
+        if (message.attempts !== 0) {
+            writer.uint32(40).uint32(message.attempts);
+        }
+        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 = createBaseLedgerPendingRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.to = reader.string();
+                    break;
+                case 3:
+                    message.coinsToBurn = Coin.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.denomToMint = reader.string();
+                    break;
+                case 5:
+                    message.attempts = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLedgerPendingRecord();
+        message.owner = object.owner ?? "";
+        message.to = object.to ?? "";
+        message.coinsToBurn = object.coinsToBurn !== undefined && object.coinsToBurn !== null ? Coin.fromPartial(object.coinsToBurn) : undefined;
+        message.denomToMint = object.denomToMint ?? "";
+        message.attempts = object.attempts ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLedgerPendingRecord();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.to !== undefined && object.to !== null) {
+            message.to = object.to;
+        }
+        if (object.coins_to_burn !== undefined && object.coins_to_burn !== null) {
+            message.coinsToBurn = Coin.fromAmino(object.coins_to_burn);
+        }
+        if (object.denom_to_mint !== undefined && object.denom_to_mint !== null) {
+            message.denomToMint = object.denom_to_mint;
+        }
+        if (object.attempts !== undefined && object.attempts !== null) {
+            message.attempts = object.attempts;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.to = message.to ?? "";
+        obj.coins_to_burn = message.coinsToBurn ? Coin.toAmino(message.coinsToBurn) : Coin.toAmino(Coin.fromPartial({}));
+        obj.denom_to_mint = message.denomToMint ?? "";
+        obj.attempts = message.attempts === 0 ? undefined : message.attempts;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LedgerPendingRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LedgerPendingRecord.decode(message.value);
+    },
+    toProto(message) {
+        return LedgerPendingRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.LedgerPendingRecord",
+            value: LedgerPendingRecord.encode(message).finish()
+        };
+    }
+};
+function createBaseLedgerCanceledRecord() {
+    return {
+        owner: "",
+        cancelReason: 0,
+        to: "",
+        coinsToBurn: Coin.fromPartial({}),
+        denomToMint: ""
+    };
+}
+/**
+ * LedgerCanceledRecord
+ * @name LedgerCanceledRecord
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.LedgerCanceledRecord
+ */
+export const LedgerCanceledRecord = {
+    typeUrl: "/akash.bme.v1.LedgerCanceledRecord",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.cancelReason !== 0) {
+            writer.uint32(16).int32(message.cancelReason);
+        }
+        if (message.to !== "") {
+            writer.uint32(26).string(message.to);
+        }
+        if (message.coinsToBurn !== undefined) {
+            Coin.encode(message.coinsToBurn, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.denomToMint !== "") {
+            writer.uint32(42).string(message.denomToMint);
+        }
+        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 = createBaseLedgerCanceledRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.cancelReason = reader.int32();
+                    break;
+                case 3:
+                    message.to = reader.string();
+                    break;
+                case 4:
+                    message.coinsToBurn = Coin.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.denomToMint = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLedgerCanceledRecord();
+        message.owner = object.owner ?? "";
+        message.cancelReason = object.cancelReason ?? 0;
+        message.to = object.to ?? "";
+        message.coinsToBurn = object.coinsToBurn !== undefined && object.coinsToBurn !== null ? Coin.fromPartial(object.coinsToBurn) : undefined;
+        message.denomToMint = object.denomToMint ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLedgerCanceledRecord();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.cancel_reason !== undefined && object.cancel_reason !== null) {
+            message.cancelReason = object.cancel_reason;
+        }
+        if (object.to !== undefined && object.to !== null) {
+            message.to = object.to;
+        }
+        if (object.coins_to_burn !== undefined && object.coins_to_burn !== null) {
+            message.coinsToBurn = Coin.fromAmino(object.coins_to_burn);
+        }
+        if (object.denom_to_mint !== undefined && object.denom_to_mint !== null) {
+            message.denomToMint = object.denom_to_mint;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.cancel_reason = message.cancelReason ?? 0;
+        obj.to = message.to ?? "";
+        obj.coins_to_burn = message.coinsToBurn ? Coin.toAmino(message.coinsToBurn) : Coin.toAmino(Coin.fromPartial({}));
+        obj.denom_to_mint = message.denomToMint ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LedgerCanceledRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LedgerCanceledRecord.decode(message.value);
+    },
+    toProto(message) {
+        return LedgerCanceledRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.LedgerCanceledRecord",
+            value: LedgerCanceledRecord.encode(message).finish()
+        };
+    }
+};
+function createBaseLedgerRecord() {
+    return {
+        burnedFrom: "",
+        mintedTo: "",
+        burner: "",
+        minter: "",
+        burned: undefined,
+        minted: undefined,
+        spread: Coin.fromPartial({}),
+        remintCreditIssued: undefined,
+        remintCreditAccrued: undefined
+    };
+}
+/**
+ * LedgerRecord stores information of burn/mint event of token A burn to mint token B
+ * @name LedgerRecord
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.LedgerRecord
+ */
+export const LedgerRecord = {
+    typeUrl: "/akash.bme.v1.LedgerRecord",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.burnedFrom !== "") {
+            writer.uint32(10).string(message.burnedFrom);
+        }
+        if (message.mintedTo !== "") {
+            writer.uint32(18).string(message.mintedTo);
+        }
+        if (message.burner !== "") {
+            writer.uint32(26).string(message.burner);
+        }
+        if (message.minter !== "") {
+            writer.uint32(34).string(message.minter);
+        }
+        if (message.burned !== undefined) {
+            CoinPrice.encode(message.burned, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.minted !== undefined) {
+            CoinPrice.encode(message.minted, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.spread !== undefined) {
+            Coin.encode(message.spread, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.remintCreditIssued !== undefined) {
+            CoinPrice.encode(message.remintCreditIssued, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.remintCreditAccrued !== undefined) {
+            CoinPrice.encode(message.remintCreditAccrued, writer.uint32(74).fork()).ldelim();
+        }
+        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 = createBaseLedgerRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.burnedFrom = reader.string();
+                    break;
+                case 2:
+                    message.mintedTo = reader.string();
+                    break;
+                case 3:
+                    message.burner = reader.string();
+                    break;
+                case 4:
+                    message.minter = reader.string();
+                    break;
+                case 5:
+                    message.burned = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.minted = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.spread = Coin.decode(reader, reader.uint32());
+                    break;
+                case 8:
+                    message.remintCreditIssued = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.remintCreditAccrued = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLedgerRecord();
+        message.burnedFrom = object.burnedFrom ?? "";
+        message.mintedTo = object.mintedTo ?? "";
+        message.burner = object.burner ?? "";
+        message.minter = object.minter ?? "";
+        message.burned = object.burned !== undefined && object.burned !== null ? CoinPrice.fromPartial(object.burned) : undefined;
+        message.minted = object.minted !== undefined && object.minted !== null ? CoinPrice.fromPartial(object.minted) : undefined;
+        message.spread = object.spread !== undefined && object.spread !== null ? Coin.fromPartial(object.spread) : undefined;
+        message.remintCreditIssued = object.remintCreditIssued !== undefined && object.remintCreditIssued !== null ? CoinPrice.fromPartial(object.remintCreditIssued) : undefined;
+        message.remintCreditAccrued = object.remintCreditAccrued !== undefined && object.remintCreditAccrued !== null ? CoinPrice.fromPartial(object.remintCreditAccrued) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLedgerRecord();
+        if (object.burned_from !== undefined && object.burned_from !== null) {
+            message.burnedFrom = object.burned_from;
+        }
+        if (object.minted_to !== undefined && object.minted_to !== null) {
+            message.mintedTo = object.minted_to;
+        }
+        if (object.burner !== undefined && object.burner !== null) {
+            message.burner = object.burner;
+        }
+        if (object.minter !== undefined && object.minter !== null) {
+            message.minter = object.minter;
+        }
+        if (object.burned !== undefined && object.burned !== null) {
+            message.burned = CoinPrice.fromAmino(object.burned);
+        }
+        if (object.minted !== undefined && object.minted !== null) {
+            message.minted = CoinPrice.fromAmino(object.minted);
+        }
+        if (object.spread !== undefined && object.spread !== null) {
+            message.spread = Coin.fromAmino(object.spread);
+        }
+        if (object.remint_credit_issued !== undefined && object.remint_credit_issued !== null) {
+            message.remintCreditIssued = CoinPrice.fromAmino(object.remint_credit_issued);
+        }
+        if (object.remint_credit_accrued !== undefined && object.remint_credit_accrued !== null) {
+            message.remintCreditAccrued = CoinPrice.fromAmino(object.remint_credit_accrued);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.burned_from = message.burnedFrom ?? "";
+        obj.minted_to = message.mintedTo ?? "";
+        obj.burner = message.burner ?? "";
+        obj.minter = message.minter ?? "";
+        obj.burned = message.burned ? CoinPrice.toAmino(message.burned) : CoinPrice.toAmino(CoinPrice.fromPartial({}));
+        obj.minted = message.minted ? CoinPrice.toAmino(message.minted) : CoinPrice.toAmino(CoinPrice.fromPartial({}));
+        obj.spread = message.spread ? Coin.toAmino(message.spread) : Coin.toAmino(Coin.fromPartial({}));
+        obj.remint_credit_issued = message.remintCreditIssued ? CoinPrice.toAmino(message.remintCreditIssued) : CoinPrice.toAmino(CoinPrice.fromPartial({}));
+        obj.remint_credit_accrued = message.remintCreditAccrued ? CoinPrice.toAmino(message.remintCreditAccrued) : CoinPrice.toAmino(CoinPrice.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LedgerRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LedgerRecord.decode(message.value);
+    },
+    toProto(message) {
+        return LedgerRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.LedgerRecord",
+            value: LedgerRecord.encode(message).finish()
+        };
+    }
+};
+function createBaseStatus() {
+    return {
+        status: 0,
+        previousStatus: 0,
+        epochHeightDiff: BigInt(0)
+    };
+}
+/**
+ * Status stores status of mint operations
+ * @name Status
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.Status
+ */
+export const Status = {
+    typeUrl: "/akash.bme.v1.Status",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.status !== 0) {
+            writer.uint32(8).int32(message.status);
+        }
+        if (message.previousStatus !== 0) {
+            writer.uint32(16).int32(message.previousStatus);
+        }
+        if (message.epochHeightDiff !== BigInt(0)) {
+            writer.uint32(24).int64(message.epochHeightDiff);
+        }
+        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 = createBaseStatus();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.status = reader.int32();
+                    break;
+                case 2:
+                    message.previousStatus = reader.int32();
+                    break;
+                case 3:
+                    message.epochHeightDiff = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseStatus();
+        message.status = object.status ?? 0;
+        message.previousStatus = object.previousStatus ?? 0;
+        message.epochHeightDiff = object.epochHeightDiff !== undefined && object.epochHeightDiff !== null ? BigInt(object.epochHeightDiff.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseStatus();
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.previous_status !== undefined && object.previous_status !== null) {
+            message.previousStatus = object.previous_status;
+        }
+        if (object.epoch_height_diff !== undefined && object.epoch_height_diff !== null) {
+            message.epochHeightDiff = BigInt(object.epoch_height_diff);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.previous_status = message.previousStatus === 0 ? undefined : message.previousStatus;
+        obj.epoch_height_diff = message.epochHeightDiff !== BigInt(0) ? message.epochHeightDiff?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Status.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Status.decode(message.value);
+    },
+    toProto(message) {
+        return Status.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.Status",
+            value: Status.encode(message).finish()
+        };
+    }
+};