@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.31

package/akash/market/v2beta1/service.rpc.msg.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientImpl = exports.MsgClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const bidmsg_1 = require("./bidmsg");
+const leasemsg_1 = require("./leasemsg");
+const paramsmsg_1 = require("./paramsmsg");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* CreateBid defines a method to create a bid given proper inputs. */
+    createBid = async (request) => {
+        const data = bidmsg_1.MsgCreateBid.encode(request).finish();
+        const promise = this.rpc.request("akash.market.v2beta1.Msg", "CreateBid", data);
+        return promise.then(data => bidmsg_1.MsgCreateBidResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* CloseBid defines a method to close a bid given proper inputs. */
+    closeBid = async (request) => {
+        const data = bidmsg_1.MsgCloseBid.encode(request).finish();
+        const promise = this.rpc.request("akash.market.v2beta1.Msg", "CloseBid", data);
+        return promise.then(data => bidmsg_1.MsgCloseBidResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* WithdrawLease withdraws accrued funds from the lease payment */
+    withdrawLease = async (request) => {
+        const data = leasemsg_1.MsgWithdrawLease.encode(request).finish();
+        const promise = this.rpc.request("akash.market.v2beta1.Msg", "WithdrawLease", data);
+        return promise.then(data => leasemsg_1.MsgWithdrawLeaseResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* CreateLease creates a new lease */
+    createLease = async (request) => {
+        const data = leasemsg_1.MsgCreateLease.encode(request).finish();
+        const promise = this.rpc.request("akash.market.v2beta1.Msg", "CreateLease", data);
+        return promise.then(data => leasemsg_1.MsgCreateLeaseResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* CloseLease defines a method to close an order given proper inputs. */
+    closeLease = async (request) => {
+        const data = leasemsg_1.MsgCloseLease.encode(request).finish();
+        const promise = this.rpc.request("akash.market.v2beta1.Msg", "CloseLease", data);
+        return promise.then(data => leasemsg_1.MsgCloseLeaseResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* UpdateParams defines a governance operation for updating the x/market module
+     parameters. The authority is hard-coded to the x/gov module account.
+    
+     Since: akash v1.0.0 */
+    updateParams = async (request) => {
+        const data = paramsmsg_1.MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("akash.market.v2beta1.Msg", "UpdateParams", data);
+        return promise.then(data => paramsmsg_1.MsgUpdateParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/akash/market/v2beta1/types.d.ts

@@ -0,0 +1,28 @@
+/** LeaseClosedReason indicates reason bid was closed */
+export declare enum LeaseClosedReason {
+    /**
+     * lease_closed_invalid - LeaseClosedReasonInvalid represents the default zero value for LeaseClosedReason.
+     * This value indicates an uninitialized or invalid lease closure reason and should not
+     * be used
+     */
+    lease_closed_invalid = 0,
+    /** lease_closed_owner - values between 1..9999 indicate owner‑initiated close */
+    lease_closed_owner = 1,
+    /**
+     * lease_closed_reason_unstable - values between 10000..19999 are indicating provider initiated close
+     * lease_closed_reason_unstable lease workloads have been unstable
+     */
+    lease_closed_reason_unstable = 10000,
+    /** lease_closed_reason_decommission - lease_closed_reason_decommission provider is being decommissioned */
+    lease_closed_reason_decommission = 10001,
+    /** lease_closed_reason_unspecified - lease_closed_reason_unspecified provider did not specify reason */
+    lease_closed_reason_unspecified = 10002,
+    /** lease_closed_reason_manifest_timeout - lease_closed_reason_manifest_timeout provider closed leases due to manifest not received */
+    lease_closed_reason_manifest_timeout = 10003,
+    /** lease_closed_reason_insufficient_funds - values between 20000..29999 indicate network‑initiated close */
+    lease_closed_reason_insufficient_funds = 20000,
+    UNRECOGNIZED = -1
+}
+export declare const LeaseClosedReasonAmino: typeof LeaseClosedReason;
+export declare function leaseClosedReasonFromJSON(object: any): LeaseClosedReason;
+export declare function leaseClosedReasonToJSON(object: LeaseClosedReason): string;

package/akash/market/v2beta1/types.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaseClosedReasonAmino = exports.LeaseClosedReason = void 0;
+exports.leaseClosedReasonFromJSON = leaseClosedReasonFromJSON;
+exports.leaseClosedReasonToJSON = leaseClosedReasonToJSON;
+//@ts-nocheck
+/** LeaseClosedReason indicates reason bid was closed */
+var LeaseClosedReason;
+(function (LeaseClosedReason) {
+    /**
+     * lease_closed_invalid - LeaseClosedReasonInvalid represents the default zero value for LeaseClosedReason.
+     * This value indicates an uninitialized or invalid lease closure reason and should not
+     * be used
+     */
+    LeaseClosedReason[LeaseClosedReason["lease_closed_invalid"] = 0] = "lease_closed_invalid";
+    /** lease_closed_owner - values between 1..9999 indicate owner‑initiated close */
+    LeaseClosedReason[LeaseClosedReason["lease_closed_owner"] = 1] = "lease_closed_owner";
+    /**
+     * lease_closed_reason_unstable - values between 10000..19999 are indicating provider initiated close
+     * lease_closed_reason_unstable lease workloads have been unstable
+     */
+    LeaseClosedReason[LeaseClosedReason["lease_closed_reason_unstable"] = 10000] = "lease_closed_reason_unstable";
+    /** lease_closed_reason_decommission - lease_closed_reason_decommission provider is being decommissioned */
+    LeaseClosedReason[LeaseClosedReason["lease_closed_reason_decommission"] = 10001] = "lease_closed_reason_decommission";
+    /** lease_closed_reason_unspecified - lease_closed_reason_unspecified provider did not specify reason */
+    LeaseClosedReason[LeaseClosedReason["lease_closed_reason_unspecified"] = 10002] = "lease_closed_reason_unspecified";
+    /** lease_closed_reason_manifest_timeout - lease_closed_reason_manifest_timeout provider closed leases due to manifest not received */
+    LeaseClosedReason[LeaseClosedReason["lease_closed_reason_manifest_timeout"] = 10003] = "lease_closed_reason_manifest_timeout";
+    /** lease_closed_reason_insufficient_funds - values between 20000..29999 indicate network‑initiated close */
+    LeaseClosedReason[LeaseClosedReason["lease_closed_reason_insufficient_funds"] = 20000] = "lease_closed_reason_insufficient_funds";
+    LeaseClosedReason[LeaseClosedReason["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(LeaseClosedReason || (exports.LeaseClosedReason = LeaseClosedReason = {}));
+exports.LeaseClosedReasonAmino = LeaseClosedReason;
+function leaseClosedReasonFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "lease_closed_invalid":
+            return LeaseClosedReason.lease_closed_invalid;
+        case 1:
+        case "lease_closed_owner":
+            return LeaseClosedReason.lease_closed_owner;
+        case 10000:
+        case "lease_closed_reason_unstable":
+            return LeaseClosedReason.lease_closed_reason_unstable;
+        case 10001:
+        case "lease_closed_reason_decommission":
+            return LeaseClosedReason.lease_closed_reason_decommission;
+        case 10002:
+        case "lease_closed_reason_unspecified":
+            return LeaseClosedReason.lease_closed_reason_unspecified;
+        case 10003:
+        case "lease_closed_reason_manifest_timeout":
+            return LeaseClosedReason.lease_closed_reason_manifest_timeout;
+        case 20000:
+        case "lease_closed_reason_insufficient_funds":
+            return LeaseClosedReason.lease_closed_reason_insufficient_funds;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return LeaseClosedReason.UNRECOGNIZED;
+    }
+}
+function leaseClosedReasonToJSON(object) {
+    switch (object) {
+        case LeaseClosedReason.lease_closed_invalid:
+            return "lease_closed_invalid";
+        case LeaseClosedReason.lease_closed_owner:
+            return "lease_closed_owner";
+        case LeaseClosedReason.lease_closed_reason_unstable:
+            return "lease_closed_reason_unstable";
+        case LeaseClosedReason.lease_closed_reason_decommission:
+            return "lease_closed_reason_decommission";
+        case LeaseClosedReason.lease_closed_reason_unspecified:
+            return "lease_closed_reason_unspecified";
+        case LeaseClosedReason.lease_closed_reason_manifest_timeout:
+            return "lease_closed_reason_manifest_timeout";
+        case LeaseClosedReason.lease_closed_reason_insufficient_funds:
+            return "lease_closed_reason_insufficient_funds";
+        case LeaseClosedReason.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/akash/oracle/v1/events.d.ts

@@ -0,0 +1,303 @@
+import { DataID, DataIDAmino, PriceDataState, PriceDataStateAmino, AggregatedPrice, AggregatedPriceAmino } from "./prices";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * EventPriceData is emitted when new price data is added to the oracle
+ * @name EventPriceData
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceData
+ */
+export interface EventPriceData {
+    /**
+     * source is the address of the price source (oracle provider)
+     */
+    source: string;
+    /**
+     * id identifies the price pair (denom and base_denom)
+     */
+    id: DataID;
+    /**
+     * data contains the price value and timestamp
+     */
+    data: PriceDataState;
+}
+export interface EventPriceDataProtoMsg {
+    typeUrl: "/akash.oracle.v1.EventPriceData";
+    value: Uint8Array;
+}
+/**
+ * EventPriceData is emitted when new price data is added to the oracle
+ * @name EventPriceDataAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceData
+ */
+export interface EventPriceDataAmino {
+    /**
+     * source is the address of the price source (oracle provider)
+     */
+    source: string;
+    /**
+     * id identifies the price pair (denom and base_denom)
+     */
+    id: DataIDAmino;
+    /**
+     * data contains the price value and timestamp
+     */
+    data: PriceDataStateAmino;
+}
+export interface EventPriceDataAminoMsg {
+    type: "/akash.oracle.v1.EventPriceData";
+    value: EventPriceDataAmino;
+}
+/**
+ * EventPriceStaleWarning is emitted when price has not been updated and is about to become stale
+ * @name EventPriceStaleWarning
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceStaleWarning
+ */
+export interface EventPriceStaleWarning {
+    /**
+     * source is the address of the price source
+     */
+    source: string;
+    /**
+     * id identifies the price pair
+     */
+    id: DataID;
+    /**
+     * last_height is the block height when the price was last updated
+     */
+    lastHeight: bigint;
+    /**
+     * blocks_to_stall is the number of blocks until the price becomes stale
+     */
+    blocksToStall: bigint;
+}
+export interface EventPriceStaleWarningProtoMsg {
+    typeUrl: "/akash.oracle.v1.EventPriceStaleWarning";
+    value: Uint8Array;
+}
+/**
+ * EventPriceStaleWarning is emitted when price has not been updated and is about to become stale
+ * @name EventPriceStaleWarningAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceStaleWarning
+ */
+export interface EventPriceStaleWarningAmino {
+    /**
+     * source is the address of the price source
+     */
+    source: string;
+    /**
+     * id identifies the price pair
+     */
+    id: DataIDAmino;
+    /**
+     * last_height is the block height when the price was last updated
+     */
+    last_height: string;
+    /**
+     * blocks_to_stall is the number of blocks until the price becomes stale
+     */
+    blocks_to_stall: string;
+}
+export interface EventPriceStaleWarningAminoMsg {
+    type: "/akash.oracle.v1.EventPriceStaleWarning";
+    value: EventPriceStaleWarningAmino;
+}
+/**
+ * EventPriceStaled is emitted when a price has become stale
+ * @name EventPriceStaled
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceStaled
+ */
+export interface EventPriceStaled {
+    /**
+     * id identifies the price pair
+     */
+    id: DataID;
+    /**
+     * last_height is the block height when the price was last updated before becoming stale
+     */
+    lastHeight: bigint;
+}
+export interface EventPriceStaledProtoMsg {
+    typeUrl: "/akash.oracle.v1.EventPriceStaled";
+    value: Uint8Array;
+}
+/**
+ * EventPriceStaled is emitted when a price has become stale
+ * @name EventPriceStaledAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceStaled
+ */
+export interface EventPriceStaledAmino {
+    /**
+     * id identifies the price pair
+     */
+    id: DataIDAmino;
+    /**
+     * last_height is the block height when the price was last updated before becoming stale
+     */
+    last_height: string;
+}
+export interface EventPriceStaledAminoMsg {
+    type: "/akash.oracle.v1.EventPriceStaled";
+    value: EventPriceStaledAmino;
+}
+/**
+ * EventPriceRecovered is emitted when a stale price has started receiving updates again
+ * @name EventPriceRecovered
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceRecovered
+ */
+export interface EventPriceRecovered {
+    /**
+     * id identifies the price pair
+     */
+    id: DataID;
+    /**
+     * height is the block height when the price recovery was detected
+     */
+    height: bigint;
+}
+export interface EventPriceRecoveredProtoMsg {
+    typeUrl: "/akash.oracle.v1.EventPriceRecovered";
+    value: Uint8Array;
+}
+/**
+ * EventPriceRecovered is emitted when a stale price has started receiving updates again
+ * @name EventPriceRecoveredAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceRecovered
+ */
+export interface EventPriceRecoveredAmino {
+    /**
+     * id identifies the price pair
+     */
+    id: DataIDAmino;
+    /**
+     * height is the block height when the price recovery was detected
+     */
+    height: string;
+}
+export interface EventPriceRecoveredAminoMsg {
+    type: "/akash.oracle.v1.EventPriceRecovered";
+    value: EventPriceRecoveredAmino;
+}
+/**
+ * EventAggregatedPrice is emitted when aggregated price has an update
+ * @name EventAggregatedPrice
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventAggregatedPrice
+ */
+export interface EventAggregatedPrice {
+    price: AggregatedPrice;
+}
+export interface EventAggregatedPriceProtoMsg {
+    typeUrl: "/akash.oracle.v1.EventAggregatedPrice";
+    value: Uint8Array;
+}
+/**
+ * EventAggregatedPrice is emitted when aggregated price has an update
+ * @name EventAggregatedPriceAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventAggregatedPrice
+ */
+export interface EventAggregatedPriceAmino {
+    price: AggregatedPriceAmino;
+}
+export interface EventAggregatedPriceAminoMsg {
+    type: "/akash.oracle.v1.EventAggregatedPrice";
+    value: EventAggregatedPriceAmino;
+}
+/**
+ * EventPriceData is emitted when new price data is added to the oracle
+ * @name EventPriceData
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceData
+ */
+export declare const EventPriceData: {
+    typeUrl: string;
+    encode(message: EventPriceData, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventPriceData;
+    fromPartial(object: DeepPartial<EventPriceData>): EventPriceData;
+    fromAmino(object: EventPriceDataAmino): EventPriceData;
+    toAmino(message: EventPriceData): EventPriceDataAmino;
+    fromAminoMsg(object: EventPriceDataAminoMsg): EventPriceData;
+    fromProtoMsg(message: EventPriceDataProtoMsg): EventPriceData;
+    toProto(message: EventPriceData): Uint8Array;
+    toProtoMsg(message: EventPriceData): EventPriceDataProtoMsg;
+};
+/**
+ * EventPriceStaleWarning is emitted when price has not been updated and is about to become stale
+ * @name EventPriceStaleWarning
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceStaleWarning
+ */
+export declare const EventPriceStaleWarning: {
+    typeUrl: string;
+    encode(message: EventPriceStaleWarning, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventPriceStaleWarning;
+    fromPartial(object: DeepPartial<EventPriceStaleWarning>): EventPriceStaleWarning;
+    fromAmino(object: EventPriceStaleWarningAmino): EventPriceStaleWarning;
+    toAmino(message: EventPriceStaleWarning): EventPriceStaleWarningAmino;
+    fromAminoMsg(object: EventPriceStaleWarningAminoMsg): EventPriceStaleWarning;
+    fromProtoMsg(message: EventPriceStaleWarningProtoMsg): EventPriceStaleWarning;
+    toProto(message: EventPriceStaleWarning): Uint8Array;
+    toProtoMsg(message: EventPriceStaleWarning): EventPriceStaleWarningProtoMsg;
+};
+/**
+ * EventPriceStaled is emitted when a price has become stale
+ * @name EventPriceStaled
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceStaled
+ */
+export declare const EventPriceStaled: {
+    typeUrl: string;
+    encode(message: EventPriceStaled, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventPriceStaled;
+    fromPartial(object: DeepPartial<EventPriceStaled>): EventPriceStaled;
+    fromAmino(object: EventPriceStaledAmino): EventPriceStaled;
+    toAmino(message: EventPriceStaled): EventPriceStaledAmino;
+    fromAminoMsg(object: EventPriceStaledAminoMsg): EventPriceStaled;
+    fromProtoMsg(message: EventPriceStaledProtoMsg): EventPriceStaled;
+    toProto(message: EventPriceStaled): Uint8Array;
+    toProtoMsg(message: EventPriceStaled): EventPriceStaledProtoMsg;
+};
+/**
+ * EventPriceRecovered is emitted when a stale price has started receiving updates again
+ * @name EventPriceRecovered
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventPriceRecovered
+ */
+export declare const EventPriceRecovered: {
+    typeUrl: string;
+    encode(message: EventPriceRecovered, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventPriceRecovered;
+    fromPartial(object: DeepPartial<EventPriceRecovered>): EventPriceRecovered;
+    fromAmino(object: EventPriceRecoveredAmino): EventPriceRecovered;
+    toAmino(message: EventPriceRecovered): EventPriceRecoveredAmino;
+    fromAminoMsg(object: EventPriceRecoveredAminoMsg): EventPriceRecovered;
+    fromProtoMsg(message: EventPriceRecoveredProtoMsg): EventPriceRecovered;
+    toProto(message: EventPriceRecovered): Uint8Array;
+    toProtoMsg(message: EventPriceRecovered): EventPriceRecoveredProtoMsg;
+};
+/**
+ * EventAggregatedPrice is emitted when aggregated price has an update
+ * @name EventAggregatedPrice
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.EventAggregatedPrice
+ */
+export declare const EventAggregatedPrice: {
+    typeUrl: string;
+    encode(message: EventAggregatedPrice, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventAggregatedPrice;
+    fromPartial(object: DeepPartial<EventAggregatedPrice>): EventAggregatedPrice;
+    fromAmino(object: EventAggregatedPriceAmino): EventAggregatedPrice;
+    toAmino(message: EventAggregatedPrice): EventAggregatedPriceAmino;
+    fromAminoMsg(object: EventAggregatedPriceAminoMsg): EventAggregatedPrice;
+    fromProtoMsg(message: EventAggregatedPriceProtoMsg): EventAggregatedPrice;
+    toProto(message: EventAggregatedPrice): Uint8Array;
+    toProtoMsg(message: EventAggregatedPrice): EventAggregatedPriceProtoMsg;
+};