@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.31

package/akash/market/v1beta5/resourcesoffer.d.ts

@@ -1,6 +1,218 @@
+import { DecCoin, DecCoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { Endpoint_Kind } from "../../base/resources/v1beta4/endpoint";
 import { Resources, ResourcesAmino } from "../../base/resources/v1beta4/resources";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
+/**
+ * StorageOfferPrice represents the price a provider is offering for a specific
+ * class of persistent storage. Providers may offer multiple storage classes
+ * (e.g., SSD, HDD, NVMe), each identified by name and priced independently.
+ * This type is used as a repeated field within OfferPrices to express
+ * per-class storage pricing in a bid.
+ * @name StorageOfferPrice
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.StorageOfferPrice
+ */
+export interface StorageOfferPrice {
+    /**
+     * Name holds an arbitrary name for the storage class (e.g., "default", "ssd", "hdd").
+     * This must match a storage class name from the corresponding resource specification.
+     */
+    name: string;
+    /**
+     * Price is the offered price per unit of this storage class, expressed as a
+     * DecCoin (decimal coin) to allow fractional pricing. When nil, no explicit
+     * price is set for this storage class.
+     */
+    price?: DecCoin;
+}
+export interface StorageOfferPriceProtoMsg {
+    typeUrl: "/akash.market.v1beta5.StorageOfferPrice";
+    value: Uint8Array;
+}
+/**
+ * StorageOfferPrice represents the price a provider is offering for a specific
+ * class of persistent storage. Providers may offer multiple storage classes
+ * (e.g., SSD, HDD, NVMe), each identified by name and priced independently.
+ * This type is used as a repeated field within OfferPrices to express
+ * per-class storage pricing in a bid.
+ * @name StorageOfferPriceAmino
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.StorageOfferPrice
+ */
+export interface StorageOfferPriceAmino {
+    /**
+     * Name holds an arbitrary name for the storage class (e.g., "default", "ssd", "hdd").
+     * This must match a storage class name from the corresponding resource specification.
+     */
+    name: string;
+    /**
+     * Price is the offered price per unit of this storage class, expressed as a
+     * DecCoin (decimal coin) to allow fractional pricing. When nil, no explicit
+     * price is set for this storage class.
+     */
+    price: DecCoinAmino;
+}
+export interface StorageOfferPriceAminoMsg {
+    type: "/akash.market.v1beta5.StorageOfferPrice";
+    value: StorageOfferPriceAmino;
+}
+/**
+ * EndpointOfferPrice represents the price a provider is offering for a specific
+ * kind of network endpoint. Providers may price each endpoint kind differently
+ * (e.g., a leased IP may cost more than a shared HTTP ingress). This type is
+ * used as a repeated field within OfferPrices to express per-kind endpoint
+ * pricing in a bid.
+ * @name EndpointOfferPrice
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.EndpointOfferPrice
+ */
+export interface EndpointOfferPrice {
+    /**
+     * Kind specifies the type of network endpoint being priced. Possible values:
+     *   - SHARED_HTTP (0): A Kubernetes Ingress endpoint.
+     *   - RANDOM_PORT (1): A Kubernetes NodePort endpoint.
+     *   - LEASED_IP   (2): A dedicated leased IP endpoint.
+     */
+    kind: Endpoint_Kind;
+    /**
+     * Price is the offered price per unit of this endpoint kind, expressed as a
+     * DecCoin (decimal coin) to allow fractional pricing. When nil, no explicit
+     * price is set for this endpoint kind.
+     */
+    price?: DecCoin;
+}
+export interface EndpointOfferPriceProtoMsg {
+    typeUrl: "/akash.market.v1beta5.EndpointOfferPrice";
+    value: Uint8Array;
+}
+/**
+ * EndpointOfferPrice represents the price a provider is offering for a specific
+ * kind of network endpoint. Providers may price each endpoint kind differently
+ * (e.g., a leased IP may cost more than a shared HTTP ingress). This type is
+ * used as a repeated field within OfferPrices to express per-kind endpoint
+ * pricing in a bid.
+ * @name EndpointOfferPriceAmino
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.EndpointOfferPrice
+ */
+export interface EndpointOfferPriceAmino {
+    /**
+     * Kind specifies the type of network endpoint being priced. Possible values:
+     *   - SHARED_HTTP (0): A Kubernetes Ingress endpoint.
+     *   - RANDOM_PORT (1): A Kubernetes NodePort endpoint.
+     *   - LEASED_IP   (2): A dedicated leased IP endpoint.
+     */
+    kind: Endpoint_Kind;
+    /**
+     * Price is the offered price per unit of this endpoint kind, expressed as a
+     * DecCoin (decimal coin) to allow fractional pricing. When nil, no explicit
+     * price is set for this endpoint kind.
+     */
+    price: DecCoinAmino;
+}
+export interface EndpointOfferPriceAminoMsg {
+    type: "/akash.market.v1beta5.EndpointOfferPrice";
+    value: EndpointOfferPriceAmino;
+}
+/**
+ * OfferPrices contains the complete pricing breakdown that a provider includes
+ * in a bid for a deployment resource group. Each field represents the price for
+ * a specific compute resource type. All price fields use DecCoin (decimal coin)
+ * to support fractional pricing denominated in any supported token.
+ *
+ * This message is embedded as a nullable field on ResourceOffer, which in turn
+ * is carried by Bid and MsgCreateBid messages. A nil OfferPrices on a
+ * ResourceOffer indicates that no per-resource pricing was specified.
+ *
+ * Field 1 is reserved for backward compatibility with a previously removed field.
+ * @name OfferPrices
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.OfferPrices
+ */
+export interface OfferPrices {
+    /**
+     * Cpu is the offered price for CPU resources. When nil, no explicit
+     * CPU price is set.
+     */
+    cpu?: DecCoin;
+    /**
+     * Memory is the offered price for memory resources. When nil, no explicit
+     * memory price is set.
+     */
+    memory?: DecCoin;
+    /**
+     * Storage is a list of per-class storage prices. Each entry corresponds to a
+     * named storage class (e.g., "default", "ssd") and its associated price.
+     * Multiple entries allow providers to price different storage tiers independently.
+     */
+    storage: StorageOfferPrice[];
+    /**
+     * Gpu is the offered price for GPU resources. When nil, no explicit
+     * GPU price is set.
+     */
+    gpu?: DecCoin;
+    /**
+     * Endpoints is a list of per-kind endpoint prices. Each entry corresponds to
+     * a network endpoint kind (SHARED_HTTP, RANDOM_PORT, or LEASED_IP) and its
+     * associated price. Multiple entries allow providers to price different
+     * endpoint types independently.
+     */
+    endpoints: EndpointOfferPrice[];
+}
+export interface OfferPricesProtoMsg {
+    typeUrl: "/akash.market.v1beta5.OfferPrices";
+    value: Uint8Array;
+}
+/**
+ * OfferPrices contains the complete pricing breakdown that a provider includes
+ * in a bid for a deployment resource group. Each field represents the price for
+ * a specific compute resource type. All price fields use DecCoin (decimal coin)
+ * to support fractional pricing denominated in any supported token.
+ *
+ * This message is embedded as a nullable field on ResourceOffer, which in turn
+ * is carried by Bid and MsgCreateBid messages. A nil OfferPrices on a
+ * ResourceOffer indicates that no per-resource pricing was specified.
+ *
+ * Field 1 is reserved for backward compatibility with a previously removed field.
+ * @name OfferPricesAmino
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.OfferPrices
+ */
+export interface OfferPricesAmino {
+    /**
+     * Cpu is the offered price for CPU resources. When nil, no explicit
+     * CPU price is set.
+     */
+    cpu: DecCoinAmino;
+    /**
+     * Memory is the offered price for memory resources. When nil, no explicit
+     * memory price is set.
+     */
+    memory: DecCoinAmino;
+    /**
+     * Storage is a list of per-class storage prices. Each entry corresponds to a
+     * named storage class (e.g., "default", "ssd") and its associated price.
+     * Multiple entries allow providers to price different storage tiers independently.
+     */
+    storage: StorageOfferPriceAmino[];
+    /**
+     * Gpu is the offered price for GPU resources. When nil, no explicit
+     * GPU price is set.
+     */
+    gpu: DecCoinAmino;
+    /**
+     * Endpoints is a list of per-kind endpoint prices. Each entry corresponds to
+     * a network endpoint kind (SHARED_HTTP, RANDOM_PORT, or LEASED_IP) and its
+     * associated price. Multiple entries allow providers to price different
+     * endpoint types independently.
+     */
+    endpoints: EndpointOfferPriceAmino[];
+}
+export interface OfferPricesAminoMsg {
+    type: "/akash.market.v1beta5.OfferPrices";
+    value: OfferPricesAmino;
+}
 /**
  * ResourceOffer describes resources that provider is offering
  * for deployment.
@@ -17,6 +229,10 @@ export interface ResourceOffer {
      * Count is the number of resources.
      */
     count: number;
+    /**
+     * Prices contains per-resource pricing details (CPU, memory, storage, GPU, endpoints) for this offer.
+     */
+    prices?: OfferPrices;
 }
 export interface ResourceOfferProtoMsg {
     typeUrl: "/akash.market.v1beta5.ResourceOffer";
@@ -38,11 +254,86 @@ export interface ResourceOfferAmino {
      * Count is the number of resources.
      */
     count: number;
+    /**
+     * Prices contains per-resource pricing details (CPU, memory, storage, GPU, endpoints) for this offer.
+     */
+    prices: OfferPricesAmino;
 }
 export interface ResourceOfferAminoMsg {
     type: "/akash.market.v1beta5.ResourceOffer";
     value: ResourceOfferAmino;
 }
+/**
+ * StorageOfferPrice represents the price a provider is offering for a specific
+ * class of persistent storage. Providers may offer multiple storage classes
+ * (e.g., SSD, HDD, NVMe), each identified by name and priced independently.
+ * This type is used as a repeated field within OfferPrices to express
+ * per-class storage pricing in a bid.
+ * @name StorageOfferPrice
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.StorageOfferPrice
+ */
+export declare const StorageOfferPrice: {
+    typeUrl: string;
+    encode(message: StorageOfferPrice, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): StorageOfferPrice;
+    fromPartial(object: DeepPartial<StorageOfferPrice>): StorageOfferPrice;
+    fromAmino(object: StorageOfferPriceAmino): StorageOfferPrice;
+    toAmino(message: StorageOfferPrice): StorageOfferPriceAmino;
+    fromAminoMsg(object: StorageOfferPriceAminoMsg): StorageOfferPrice;
+    fromProtoMsg(message: StorageOfferPriceProtoMsg): StorageOfferPrice;
+    toProto(message: StorageOfferPrice): Uint8Array;
+    toProtoMsg(message: StorageOfferPrice): StorageOfferPriceProtoMsg;
+};
+/**
+ * EndpointOfferPrice represents the price a provider is offering for a specific
+ * kind of network endpoint. Providers may price each endpoint kind differently
+ * (e.g., a leased IP may cost more than a shared HTTP ingress). This type is
+ * used as a repeated field within OfferPrices to express per-kind endpoint
+ * pricing in a bid.
+ * @name EndpointOfferPrice
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.EndpointOfferPrice
+ */
+export declare const EndpointOfferPrice: {
+    typeUrl: string;
+    encode(message: EndpointOfferPrice, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EndpointOfferPrice;
+    fromPartial(object: DeepPartial<EndpointOfferPrice>): EndpointOfferPrice;
+    fromAmino(object: EndpointOfferPriceAmino): EndpointOfferPrice;
+    toAmino(message: EndpointOfferPrice): EndpointOfferPriceAmino;
+    fromAminoMsg(object: EndpointOfferPriceAminoMsg): EndpointOfferPrice;
+    fromProtoMsg(message: EndpointOfferPriceProtoMsg): EndpointOfferPrice;
+    toProto(message: EndpointOfferPrice): Uint8Array;
+    toProtoMsg(message: EndpointOfferPrice): EndpointOfferPriceProtoMsg;
+};
+/**
+ * OfferPrices contains the complete pricing breakdown that a provider includes
+ * in a bid for a deployment resource group. Each field represents the price for
+ * a specific compute resource type. All price fields use DecCoin (decimal coin)
+ * to support fractional pricing denominated in any supported token.
+ *
+ * This message is embedded as a nullable field on ResourceOffer, which in turn
+ * is carried by Bid and MsgCreateBid messages. A nil OfferPrices on a
+ * ResourceOffer indicates that no per-resource pricing was specified.
+ *
+ * Field 1 is reserved for backward compatibility with a previously removed field.
+ * @name OfferPrices
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.OfferPrices
+ */
+export declare const OfferPrices: {
+    typeUrl: string;
+    encode(message: OfferPrices, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): OfferPrices;
+    fromPartial(object: DeepPartial<OfferPrices>): OfferPrices;
+    fromAmino(object: OfferPricesAmino): OfferPrices;
+    toAmino(message: OfferPrices): OfferPricesAmino;
+    fromAminoMsg(object: OfferPricesAminoMsg): OfferPrices;
+    fromProtoMsg(message: OfferPricesProtoMsg): OfferPrices;
+    toProto(message: OfferPrices): Uint8Array;
+    toProtoMsg(message: OfferPrices): OfferPricesProtoMsg;
+};
 /**
  * ResourceOffer describes resources that provider is offering
  * for deployment.

package/akash/market/v1beta5/resourcesoffer.js

@@ -1,13 +1,317 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceOffer = void 0;
+exports.ResourceOffer = exports.OfferPrices = exports.EndpointOfferPrice = exports.StorageOfferPrice = void 0;
 //@ts-nocheck
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
 const resources_1 = require("../../base/resources/v1beta4/resources");
 const binary_1 = require("../../../binary");
+function createBaseStorageOfferPrice() {
+    return {
+        name: "",
+        price: undefined
+    };
+}
+/**
+ * StorageOfferPrice represents the price a provider is offering for a specific
+ * class of persistent storage. Providers may offer multiple storage classes
+ * (e.g., SSD, HDD, NVMe), each identified by name and priced independently.
+ * This type is used as a repeated field within OfferPrices to express
+ * per-class storage pricing in a bid.
+ * @name StorageOfferPrice
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.StorageOfferPrice
+ */
+exports.StorageOfferPrice = {
+    typeUrl: "/akash.market.v1beta5.StorageOfferPrice",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.price !== undefined) {
+            coin_1.DecCoin.encode(message.price, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseStorageOfferPrice();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.price = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseStorageOfferPrice();
+        message.name = object.name ?? "";
+        message.price = object.price !== undefined && object.price !== null ? coin_1.DecCoin.fromPartial(object.price) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseStorageOfferPrice();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.price !== undefined && object.price !== null) {
+            message.price = coin_1.DecCoin.fromAmino(object.price);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name ?? "";
+        obj.price = message.price ? coin_1.DecCoin.toAmino(message.price) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.StorageOfferPrice.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.StorageOfferPrice.decode(message.value);
+    },
+    toProto(message) {
+        return exports.StorageOfferPrice.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.market.v1beta5.StorageOfferPrice",
+            value: exports.StorageOfferPrice.encode(message).finish()
+        };
+    }
+};
+function createBaseEndpointOfferPrice() {
+    return {
+        kind: 0,
+        price: undefined
+    };
+}
+/**
+ * EndpointOfferPrice represents the price a provider is offering for a specific
+ * kind of network endpoint. Providers may price each endpoint kind differently
+ * (e.g., a leased IP may cost more than a shared HTTP ingress). This type is
+ * used as a repeated field within OfferPrices to express per-kind endpoint
+ * pricing in a bid.
+ * @name EndpointOfferPrice
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.EndpointOfferPrice
+ */
+exports.EndpointOfferPrice = {
+    typeUrl: "/akash.market.v1beta5.EndpointOfferPrice",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.kind !== 0) {
+            writer.uint32(8).int32(message.kind);
+        }
+        if (message.price !== undefined) {
+            coin_1.DecCoin.encode(message.price, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBaseEndpointOfferPrice();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.kind = reader.int32();
+                    break;
+                case 2:
+                    message.price = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEndpointOfferPrice();
+        message.kind = object.kind ?? 0;
+        message.price = object.price !== undefined && object.price !== null ? coin_1.DecCoin.fromPartial(object.price) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEndpointOfferPrice();
+        if (object.kind !== undefined && object.kind !== null) {
+            message.kind = object.kind;
+        }
+        if (object.price !== undefined && object.price !== null) {
+            message.price = coin_1.DecCoin.fromAmino(object.price);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.kind = message.kind ?? 0;
+        obj.price = message.price ? coin_1.DecCoin.toAmino(message.price) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.EndpointOfferPrice.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.EndpointOfferPrice.decode(message.value);
+    },
+    toProto(message) {
+        return exports.EndpointOfferPrice.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.market.v1beta5.EndpointOfferPrice",
+            value: exports.EndpointOfferPrice.encode(message).finish()
+        };
+    }
+};
+function createBaseOfferPrices() {
+    return {
+        cpu: undefined,
+        memory: undefined,
+        storage: [],
+        gpu: undefined,
+        endpoints: []
+    };
+}
+/**
+ * OfferPrices contains the complete pricing breakdown that a provider includes
+ * in a bid for a deployment resource group. Each field represents the price for
+ * a specific compute resource type. All price fields use DecCoin (decimal coin)
+ * to support fractional pricing denominated in any supported token.
+ *
+ * This message is embedded as a nullable field on ResourceOffer, which in turn
+ * is carried by Bid and MsgCreateBid messages. A nil OfferPrices on a
+ * ResourceOffer indicates that no per-resource pricing was specified.
+ *
+ * Field 1 is reserved for backward compatibility with a previously removed field.
+ * @name OfferPrices
+ * @package akash.market.v1beta5
+ * @see proto type: akash.market.v1beta5.OfferPrices
+ */
+exports.OfferPrices = {
+    typeUrl: "/akash.market.v1beta5.OfferPrices",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.cpu !== undefined) {
+            coin_1.DecCoin.encode(message.cpu, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.memory !== undefined) {
+            coin_1.DecCoin.encode(message.memory, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.storage) {
+            exports.StorageOfferPrice.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.gpu !== undefined) {
+            coin_1.DecCoin.encode(message.gpu, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.endpoints) {
+            exports.EndpointOfferPrice.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        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 = createBaseOfferPrices();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    message.cpu = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.memory = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.storage.push(exports.StorageOfferPrice.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.gpu = coin_1.DecCoin.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.endpoints.push(exports.EndpointOfferPrice.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseOfferPrices();
+        message.cpu = object.cpu !== undefined && object.cpu !== null ? coin_1.DecCoin.fromPartial(object.cpu) : undefined;
+        message.memory = object.memory !== undefined && object.memory !== null ? coin_1.DecCoin.fromPartial(object.memory) : undefined;
+        message.storage = object.storage?.map(e => exports.StorageOfferPrice.fromPartial(e)) || [];
+        message.gpu = object.gpu !== undefined && object.gpu !== null ? coin_1.DecCoin.fromPartial(object.gpu) : undefined;
+        message.endpoints = object.endpoints?.map(e => exports.EndpointOfferPrice.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseOfferPrices();
+        if (object.cpu !== undefined && object.cpu !== null) {
+            message.cpu = coin_1.DecCoin.fromAmino(object.cpu);
+        }
+        if (object.memory !== undefined && object.memory !== null) {
+            message.memory = coin_1.DecCoin.fromAmino(object.memory);
+        }
+        message.storage = object.storage?.map(e => exports.StorageOfferPrice.fromAmino(e)) || [];
+        if (object.gpu !== undefined && object.gpu !== null) {
+            message.gpu = coin_1.DecCoin.fromAmino(object.gpu);
+        }
+        message.endpoints = object.endpoints?.map(e => exports.EndpointOfferPrice.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.cpu = message.cpu ? coin_1.DecCoin.toAmino(message.cpu) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        obj.memory = message.memory ? coin_1.DecCoin.toAmino(message.memory) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        if (message.storage) {
+            obj.storage = message.storage.map(e => e ? exports.StorageOfferPrice.toAmino(e) : undefined);
+        }
+        else {
+            obj.storage = message.storage;
+        }
+        obj.gpu = message.gpu ? coin_1.DecCoin.toAmino(message.gpu) : coin_1.DecCoin.toAmino(coin_1.DecCoin.fromPartial({}));
+        if (message.endpoints) {
+            obj.endpoints = message.endpoints.map(e => e ? exports.EndpointOfferPrice.toAmino(e) : undefined);
+        }
+        else {
+            obj.endpoints = message.endpoints;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.OfferPrices.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.OfferPrices.decode(message.value);
+    },
+    toProto(message) {
+        return exports.OfferPrices.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.market.v1beta5.OfferPrices",
+            value: exports.OfferPrices.encode(message).finish()
+        };
+    }
+};
 function createBaseResourceOffer() {
     return {
         resources: resources_1.Resources.fromPartial({}),
-        count: 0
+        count: 0,
+        prices: undefined
     };
 }
 /**
@@ -26,6 +330,9 @@ exports.ResourceOffer = {
         if (message.count !== 0) {
             writer.uint32(16).uint32(message.count);
         }
+        if (message.prices !== undefined) {
+            exports.OfferPrices.encode(message.prices, writer.uint32(26).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
@@ -41,6 +348,9 @@ exports.ResourceOffer = {
                 case 2:
                     message.count = reader.uint32();
                     break;
+                case 3:
+                    message.prices = exports.OfferPrices.decode(reader, reader.uint32());
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -52,6 +362,7 @@ exports.ResourceOffer = {
         const message = createBaseResourceOffer();
         message.resources = object.resources !== undefined && object.resources !== null ? resources_1.Resources.fromPartial(object.resources) : undefined;
         message.count = object.count ?? 0;
+        message.prices = object.prices !== undefined && object.prices !== null ? exports.OfferPrices.fromPartial(object.prices) : undefined;
         return message;
     },
     fromAmino(object) {
@@ -62,12 +373,16 @@ exports.ResourceOffer = {
         if (object.count !== undefined && object.count !== null) {
             message.count = object.count;
         }
+        if (object.prices !== undefined && object.prices !== null) {
+            message.prices = exports.OfferPrices.fromAmino(object.prices);
+        }
         return message;
     },
     toAmino(message) {
         const obj = {};
         obj.resources = message.resources ? resources_1.Resources.toAmino(message.resources) : resources_1.Resources.toAmino(resources_1.Resources.fromPartial({}));
         obj.count = message.count ?? 0;
+        obj.prices = message.prices ? exports.OfferPrices.toAmino(message.prices) : exports.OfferPrices.toAmino(exports.OfferPrices.fromPartial({}));
         return obj;
     },
     fromAminoMsg(object) {

package/akash/market/v1beta5/service.amino.d.ts

@@ -1,5 +1,5 @@
 import { MsgCreateBid, MsgCloseBid } from "./bidmsg";
-import { MsgWithdrawLease, MsgCreateLease, MsgCloseLease } from "./leasemsg";
+import { MsgWithdrawLease, MsgCreateLease, MsgCloseLease, MsgLeaseStartReclaim } from "./leasemsg";
 import { MsgUpdateParams } from "./paramsmsg";
 export declare const AminoConverter: {
     "/akash.market.v1beta5.MsgCreateBid": {
@@ -27,6 +27,11 @@ export declare const AminoConverter: {
         toAmino: (message: MsgCloseLease) => import("./leasemsg").MsgCloseLeaseAmino;
         fromAmino: (object: import("./leasemsg").MsgCloseLeaseAmino) => MsgCloseLease;
     };
+    "/akash.market.v1beta5.MsgLeaseStartReclaim": {
+        aminoType: string;
+        toAmino: (message: MsgLeaseStartReclaim) => import("./leasemsg").MsgLeaseStartReclaimAmino;
+        fromAmino: (object: import("./leasemsg").MsgLeaseStartReclaimAmino) => MsgLeaseStartReclaim;
+    };
     "/akash.market.v1beta5.MsgUpdateParams": {
         aminoType: string;
         toAmino: (message: MsgUpdateParams) => import("./paramsmsg").MsgUpdateParamsAmino;