@sparkdreamnft/sparkdreamjs 0.0.29 → 0.0.30

package/cosmos_proto/bundle.d.ts

@@ -1,31 +1,31 @@
-import * as _113 from "./cosmos";
+import * as _121 from "./cosmos";
 export declare const cosmos_proto: {
-    scalarTypeFromJSON(object: any): _113.ScalarType;
-    scalarTypeToJSON(object: _113.ScalarType): string;
-    ScalarType: typeof _113.ScalarType;
-    ScalarTypeAmino: typeof _113.ScalarType;
+    scalarTypeFromJSON(object: any): _121.ScalarType;
+    scalarTypeToJSON(object: _121.ScalarType): string;
+    ScalarType: typeof _121.ScalarType;
+    ScalarTypeAmino: typeof _121.ScalarType;
     InterfaceDescriptor: {
         typeUrl: string;
-        encode(message: _113.InterfaceDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.InterfaceDescriptor;
-        fromPartial(object: import("../helpers").DeepPartial<_113.InterfaceDescriptor>): _113.InterfaceDescriptor;
-        fromAmino(object: _113.InterfaceDescriptorAmino): _113.InterfaceDescriptor;
-        toAmino(message: _113.InterfaceDescriptor): _113.InterfaceDescriptorAmino;
-        fromAminoMsg(object: _113.InterfaceDescriptorAminoMsg): _113.InterfaceDescriptor;
-        fromProtoMsg(message: _113.InterfaceDescriptorProtoMsg): _113.InterfaceDescriptor;
-        toProto(message: _113.InterfaceDescriptor): Uint8Array;
-        toProtoMsg(message: _113.InterfaceDescriptor): _113.InterfaceDescriptorProtoMsg;
+        encode(message: _121.InterfaceDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _121.InterfaceDescriptor;
+        fromPartial(object: import("../helpers").DeepPartial<_121.InterfaceDescriptor>): _121.InterfaceDescriptor;
+        fromAmino(object: _121.InterfaceDescriptorAmino): _121.InterfaceDescriptor;
+        toAmino(message: _121.InterfaceDescriptor): _121.InterfaceDescriptorAmino;
+        fromAminoMsg(object: _121.InterfaceDescriptorAminoMsg): _121.InterfaceDescriptor;
+        fromProtoMsg(message: _121.InterfaceDescriptorProtoMsg): _121.InterfaceDescriptor;
+        toProto(message: _121.InterfaceDescriptor): Uint8Array;
+        toProtoMsg(message: _121.InterfaceDescriptor): _121.InterfaceDescriptorProtoMsg;
     };
     ScalarDescriptor: {
         typeUrl: string;
-        encode(message: _113.ScalarDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.ScalarDescriptor;
-        fromPartial(object: import("../helpers").DeepPartial<_113.ScalarDescriptor>): _113.ScalarDescriptor;
-        fromAmino(object: _113.ScalarDescriptorAmino): _113.ScalarDescriptor;
-        toAmino(message: _113.ScalarDescriptor): _113.ScalarDescriptorAmino;
-        fromAminoMsg(object: _113.ScalarDescriptorAminoMsg): _113.ScalarDescriptor;
-        fromProtoMsg(message: _113.ScalarDescriptorProtoMsg): _113.ScalarDescriptor;
-        toProto(message: _113.ScalarDescriptor): Uint8Array;
-        toProtoMsg(message: _113.ScalarDescriptor): _113.ScalarDescriptorProtoMsg;
+        encode(message: _121.ScalarDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _121.ScalarDescriptor;
+        fromPartial(object: import("../helpers").DeepPartial<_121.ScalarDescriptor>): _121.ScalarDescriptor;
+        fromAmino(object: _121.ScalarDescriptorAmino): _121.ScalarDescriptor;
+        toAmino(message: _121.ScalarDescriptor): _121.ScalarDescriptorAmino;
+        fromAminoMsg(object: _121.ScalarDescriptorAminoMsg): _121.ScalarDescriptor;
+        fromProtoMsg(message: _121.ScalarDescriptorProtoMsg): _121.ScalarDescriptor;
+        toProto(message: _121.ScalarDescriptor): Uint8Array;
+        toProtoMsg(message: _121.ScalarDescriptor): _121.ScalarDescriptorProtoMsg;
     };
 };

package/cosmos_proto/bundle.js

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosmos_proto = void 0;
 //@ts-nocheck
-const _113 = __importStar(require("./cosmos"));
+const _121 = __importStar(require("./cosmos"));
 exports.cosmos_proto = {
-    ..._113
+    ..._121
 };

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

@@ -0,0 +1,497 @@
+//@ts-nocheck
+import { LedgerRecordID, CoinPrice } from "./types";
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@interchainjs/math";
+function createBaseEventMintStatusChange() {
+    return {
+        previousStatus: 0,
+        newStatus: 0,
+        collateralRatio: ""
+    };
+}
+/**
+ * EventCircuitBreakerStatusChange is emitted when circuit breaker status changes
+ * @name EventMintStatusChange
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.EventMintStatusChange
+ */
+export const EventMintStatusChange = {
+    typeUrl: "/akash.bme.v1.EventMintStatusChange",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.previousStatus !== 0) {
+            writer.uint32(8).int32(message.previousStatus);
+        }
+        if (message.newStatus !== 0) {
+            writer.uint32(16).int32(message.newStatus);
+        }
+        if (message.collateralRatio !== "") {
+            writer.uint32(26).string(Decimal.fromUserInput(message.collateralRatio, 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 = createBaseEventMintStatusChange();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.previousStatus = reader.int32();
+                    break;
+                case 2:
+                    message.newStatus = reader.int32();
+                    break;
+                case 3:
+                    message.collateralRatio = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventMintStatusChange();
+        message.previousStatus = object.previousStatus ?? 0;
+        message.newStatus = object.newStatus ?? 0;
+        message.collateralRatio = object.collateralRatio ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEventMintStatusChange();
+        if (object.previous_status !== undefined && object.previous_status !== null) {
+            message.previousStatus = object.previous_status;
+        }
+        if (object.new_status !== undefined && object.new_status !== null) {
+            message.newStatus = object.new_status;
+        }
+        if (object.collateral_ratio !== undefined && object.collateral_ratio !== null) {
+            message.collateralRatio = object.collateral_ratio;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.previous_status = message.previousStatus === 0 ? undefined : message.previousStatus;
+        obj.new_status = message.newStatus === 0 ? undefined : message.newStatus;
+        obj.collateral_ratio = message.collateralRatio === "" ? undefined : message.collateralRatio;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return EventMintStatusChange.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return EventMintStatusChange.decode(message.value);
+    },
+    toProto(message) {
+        return EventMintStatusChange.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.EventMintStatusChange",
+            value: EventMintStatusChange.encode(message).finish()
+        };
+    }
+};
+function createBaseEventVaultFunded() {
+    return {
+        amount: Coin.fromPartial({}),
+        source: "",
+        newVaultBalance: Coin.fromPartial({})
+    };
+}
+/**
+ * EventVaultFunded is emitted when the vault is seeded with AKT
+ * @name EventVaultFunded
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.EventVaultFunded
+ */
+export const EventVaultFunded = {
+    typeUrl: "/akash.bme.v1.EventVaultFunded",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.source !== "") {
+            writer.uint32(18).string(message.source);
+        }
+        if (message.newVaultBalance !== undefined) {
+            Coin.encode(message.newVaultBalance, 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 = createBaseEventVaultFunded();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.source = reader.string();
+                    break;
+                case 3:
+                    message.newVaultBalance = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventVaultFunded();
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        message.source = object.source ?? "";
+        message.newVaultBalance = object.newVaultBalance !== undefined && object.newVaultBalance !== null ? Coin.fromPartial(object.newVaultBalance) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEventVaultFunded();
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        if (object.source !== undefined && object.source !== null) {
+            message.source = object.source;
+        }
+        if (object.new_vault_balance !== undefined && object.new_vault_balance !== null) {
+            message.newVaultBalance = Coin.fromAmino(object.new_vault_balance);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        obj.source = message.source === "" ? undefined : message.source;
+        obj.new_vault_balance = message.newVaultBalance ? Coin.toAmino(message.newVaultBalance) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return EventVaultFunded.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return EventVaultFunded.decode(message.value);
+    },
+    toProto(message) {
+        return EventVaultFunded.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.EventVaultFunded",
+            value: EventVaultFunded.encode(message).finish()
+        };
+    }
+};
+function createBaseEventLedgerRecordExecuted() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        burnedFrom: "",
+        mintedTo: "",
+        burner: "",
+        minter: "",
+        burned: undefined,
+        minted: undefined,
+        spread: Coin.fromPartial({}),
+        remintCreditIssued: undefined,
+        remintCreditAccrued: undefined
+    };
+}
+/**
+ * EventLedgerRecordExecuted emitted information of burn/mint event of token A burn to mint token B
+ * @name EventLedgerRecordExecuted
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.EventLedgerRecordExecuted
+ */
+export const EventLedgerRecordExecuted = {
+    typeUrl: "/akash.bme.v1.EventLedgerRecordExecuted",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            LedgerRecordID.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.burnedFrom !== "") {
+            writer.uint32(18).string(message.burnedFrom);
+        }
+        if (message.mintedTo !== "") {
+            writer.uint32(26).string(message.mintedTo);
+        }
+        if (message.burner !== "") {
+            writer.uint32(34).string(message.burner);
+        }
+        if (message.minter !== "") {
+            writer.uint32(42).string(message.minter);
+        }
+        if (message.burned !== undefined) {
+            CoinPrice.encode(message.burned, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.minted !== undefined) {
+            CoinPrice.encode(message.minted, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.spread !== undefined) {
+            Coin.encode(message.spread, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.remintCreditIssued !== undefined) {
+            CoinPrice.encode(message.remintCreditIssued, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.remintCreditAccrued !== undefined) {
+            CoinPrice.encode(message.remintCreditAccrued, writer.uint32(82).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 = createBaseEventLedgerRecordExecuted();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = LedgerRecordID.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.burnedFrom = reader.string();
+                    break;
+                case 3:
+                    message.mintedTo = reader.string();
+                    break;
+                case 4:
+                    message.burner = reader.string();
+                    break;
+                case 5:
+                    message.minter = reader.string();
+                    break;
+                case 6:
+                    message.burned = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.minted = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                case 8:
+                    message.spread = Coin.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.remintCreditIssued = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                case 10:
+                    message.remintCreditAccrued = CoinPrice.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventLedgerRecordExecuted();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        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 = createBaseEventLedgerRecordExecuted();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        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.id = message.id ? LedgerRecordID.toAmino(message.id) : LedgerRecordID.toAmino(LedgerRecordID.fromPartial({}));
+        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 EventLedgerRecordExecuted.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return EventLedgerRecordExecuted.decode(message.value);
+    },
+    toProto(message) {
+        return EventLedgerRecordExecuted.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.EventLedgerRecordExecuted",
+            value: EventLedgerRecordExecuted.encode(message).finish()
+        };
+    }
+};
+function createBaseEventLedgerRecordCanceled() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        cancelReason: 0,
+        owner: "",
+        to: "",
+        coinsToBurn: Coin.fromPartial({}),
+        denomToMint: ""
+    };
+}
+/**
+ * EventLedgerRecordCanceled emitted information of unsuccessful burn/mint event
+ * @name EventLedgerRecordCanceled
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.EventLedgerRecordCanceled
+ */
+export const EventLedgerRecordCanceled = {
+    typeUrl: "/akash.bme.v1.EventLedgerRecordCanceled",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            LedgerRecordID.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.cancelReason !== 0) {
+            writer.uint32(16).int32(message.cancelReason);
+        }
+        if (message.owner !== "") {
+            writer.uint32(26).string(message.owner);
+        }
+        if (message.to !== "") {
+            writer.uint32(34).string(message.to);
+        }
+        if (message.coinsToBurn !== undefined) {
+            Coin.encode(message.coinsToBurn, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.denomToMint !== "") {
+            writer.uint32(50).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 = createBaseEventLedgerRecordCanceled();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = LedgerRecordID.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.cancelReason = reader.int32();
+                    break;
+                case 3:
+                    message.owner = reader.string();
+                    break;
+                case 4:
+                    message.to = reader.string();
+                    break;
+                case 5:
+                    message.coinsToBurn = Coin.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.denomToMint = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEventLedgerRecordCanceled();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        message.cancelReason = object.cancelReason ?? 0;
+        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 ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEventLedgerRecordCanceled();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        if (object.cancel_reason !== undefined && object.cancel_reason !== null) {
+            message.cancelReason = object.cancel_reason;
+        }
+        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;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? LedgerRecordID.toAmino(message.id) : LedgerRecordID.toAmino(LedgerRecordID.fromPartial({}));
+        obj.cancel_reason = message.cancelReason ?? 0;
+        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 ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return EventLedgerRecordCanceled.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return EventLedgerRecordCanceled.decode(message.value);
+    },
+    toProto(message) {
+        return EventLedgerRecordCanceled.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.EventLedgerRecordCanceled",
+            value: EventLedgerRecordCanceled.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,107 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseLedgerRecordFilters() {
+    return {
+        source: "",
+        denom: "",
+        toDenom: "",
+        status: ""
+    };
+}
+/**
+ * LedgerRecordFilters defines filters used to filter ledger records
+ * @name LedgerRecordFilters
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.LedgerRecordFilters
+ */
+export const LedgerRecordFilters = {
+    typeUrl: "/akash.bme.v1.LedgerRecordFilters",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.source !== "") {
+            writer.uint32(10).string(message.source);
+        }
+        if (message.denom !== "") {
+            writer.uint32(18).string(message.denom);
+        }
+        if (message.toDenom !== "") {
+            writer.uint32(26).string(message.toDenom);
+        }
+        if (message.status !== "") {
+            writer.uint32(34).string(message.status);
+        }
+        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 = createBaseLedgerRecordFilters();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.source = reader.string();
+                    break;
+                case 2:
+                    message.denom = reader.string();
+                    break;
+                case 3:
+                    message.toDenom = reader.string();
+                    break;
+                case 4:
+                    message.status = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLedgerRecordFilters();
+        message.source = object.source ?? "";
+        message.denom = object.denom ?? "";
+        message.toDenom = object.toDenom ?? "";
+        message.status = object.status ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLedgerRecordFilters();
+        if (object.source !== undefined && object.source !== null) {
+            message.source = object.source;
+        }
+        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.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.source = message.source ?? "";
+        obj.denom = message.denom ?? "";
+        obj.to_denom = message.toDenom ?? "";
+        obj.status = message.status ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LedgerRecordFilters.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LedgerRecordFilters.decode(message.value);
+    },
+    toProto(message) {
+        return LedgerRecordFilters.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.LedgerRecordFilters",
+            value: LedgerRecordFilters.encode(message).finish()
+        };
+    }
+};