@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.32

package/akash/{cert/v1beta3/cert.registry.d.ts → oracle/v1/service.registry.d.ts}

@@ -1,37 +1,37 @@
 import { TelescopeGeneratedType } from "../../../types";
 import { Registry } from "@cosmjs/proto-signing";
-import { MsgCreateCertificate, MsgRevokeCertificate } from "./cert";
+import { MsgAddPriceEntry, MsgUpdateParams } from "./msgs";
 export declare const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]>;
 export declare const load: (protoRegistry: Registry) => void;
 export declare const MessageComposer: {
     encoded: {
-        createCertificate(value: MsgCreateCertificate): {
+        addPriceEntry(value: MsgAddPriceEntry): {
             typeUrl: string;
             value: Uint8Array<ArrayBufferLike>;
         };
-        revokeCertificate(value: MsgRevokeCertificate): {
+        updateParams(value: MsgUpdateParams): {
             typeUrl: string;
             value: Uint8Array<ArrayBufferLike>;
         };
     };
     withTypeUrl: {
-        createCertificate(value: MsgCreateCertificate): {
+        addPriceEntry(value: MsgAddPriceEntry): {
             typeUrl: string;
-            value: MsgCreateCertificate;
+            value: MsgAddPriceEntry;
         };
-        revokeCertificate(value: MsgRevokeCertificate): {
+        updateParams(value: MsgUpdateParams): {
             typeUrl: string;
-            value: MsgRevokeCertificate;
+            value: MsgUpdateParams;
         };
     };
     fromPartial: {
-        createCertificate(value: MsgCreateCertificate): {
+        addPriceEntry(value: MsgAddPriceEntry): {
             typeUrl: string;
-            value: MsgCreateCertificate;
+            value: MsgAddPriceEntry;
         };
-        revokeCertificate(value: MsgRevokeCertificate): {
+        updateParams(value: MsgUpdateParams): {
             typeUrl: string;
-            value: MsgRevokeCertificate;
+            value: MsgUpdateParams;
         };
     };
 };

package/akash/oracle/v1/service.registry.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageComposer = exports.load = exports.registry = void 0;
+const msgs_1 = require("./msgs");
+exports.registry = [["/akash.oracle.v1.MsgAddPriceEntry", msgs_1.MsgAddPriceEntry], ["/akash.oracle.v1.MsgUpdateParams", msgs_1.MsgUpdateParams]];
+const load = (protoRegistry) => {
+    exports.registry.forEach(([typeUrl, mod]) => {
+        protoRegistry.register(typeUrl, mod);
+    });
+};
+exports.load = load;
+exports.MessageComposer = {
+    encoded: {
+        addPriceEntry(value) {
+            return {
+                typeUrl: "/akash.oracle.v1.MsgAddPriceEntry",
+                value: msgs_1.MsgAddPriceEntry.encode(value).finish()
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.oracle.v1.MsgUpdateParams",
+                value: msgs_1.MsgUpdateParams.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        addPriceEntry(value) {
+            return {
+                typeUrl: "/akash.oracle.v1.MsgAddPriceEntry",
+                value
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.oracle.v1.MsgUpdateParams",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        addPriceEntry(value) {
+            return {
+                typeUrl: "/akash.oracle.v1.MsgAddPriceEntry",
+                value: msgs_1.MsgAddPriceEntry.fromPartial(value)
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.oracle.v1.MsgUpdateParams",
+                value: msgs_1.MsgUpdateParams.fromPartial(value)
+            };
+        }
+    }
+};

package/akash/oracle/v1/service.rpc.msg.d.ts

@@ -0,0 +1,21 @@
+import { TxRpc } from "../../../types";
+import { MsgAddPriceEntry, MsgAddPriceEntryResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./msgs";
+/** Msg defines the oracle Msg service for managing price feeds */
+export interface Msg {
+    /** AddPriceEntry adds a new price entry for a denomination from an authorized source */
+    addPriceEntry(request: MsgAddPriceEntry): Promise<MsgAddPriceEntryResponse>;
+    /**
+     * UpdateParams defines a governance operation for updating the x/wasm module
+     * parameters. The authority is hard-coded to the x/gov module account.
+     *
+     * Since: akash v2.0.0
+     */
+    updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    addPriceEntry: (request: MsgAddPriceEntry) => Promise<MsgAddPriceEntryResponse>;
+    updateParams: (request: MsgUpdateParams) => Promise<MsgUpdateParamsResponse>;
+}
+export declare const createClientImpl: (rpc: TxRpc) => MsgClientImpl;

package/akash/oracle/v1/service.rpc.msg.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientImpl = exports.MsgClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const msgs_1 = require("./msgs");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* AddPriceEntry adds a new price entry for a denomination from an authorized source */
+    addPriceEntry = async (request) => {
+        const data = msgs_1.MsgAddPriceEntry.encode(request).finish();
+        const promise = this.rpc.request("akash.oracle.v1.Msg", "AddPriceEntry", data);
+        return promise.then(data => msgs_1.MsgAddPriceEntryResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* UpdateParams defines a governance operation for updating the x/wasm module
+     parameters. The authority is hard-coded to the x/gov module account.
+    
+     Since: akash v2.0.0 */
+    updateParams = async (request) => {
+        const data = msgs_1.MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("akash.oracle.v1.Msg", "UpdateParams", data);
+        return promise.then(data => msgs_1.MsgUpdateParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

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

@@ -0,0 +1,309 @@
+import { DataID, DataIDAmino, 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.v2
+ * @see proto type: akash.oracle.v2.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;
+    /**
+     * price is the decimal price value
+     */
+    price: string;
+    /**
+     * timestamp is when this price was recorded
+     */
+    timestamp: Date;
+}
+export interface EventPriceDataProtoMsg {
+    typeUrl: "/akash.oracle.v2.EventPriceData";
+    value: Uint8Array;
+}
+/**
+ * EventPriceData is emitted when new price data is added to the oracle
+ * @name EventPriceDataAmino
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.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;
+    /**
+     * price is the decimal price value
+     */
+    price: string;
+    /**
+     * timestamp is when this price was recorded
+     */
+    timestamp: string;
+}
+export interface EventPriceDataAminoMsg {
+    type: "/akash.oracle.v2.EventPriceData";
+    value: EventPriceDataAmino;
+}
+/**
+ * EventPriceStaleWarning is emitted when price has not been updated and is about to become stale
+ * @name EventPriceStaleWarning
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.EventPriceStaleWarning
+ */
+export interface EventPriceStaleWarning {
+    /**
+     * 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.v2.EventPriceStaleWarning";
+    value: Uint8Array;
+}
+/**
+ * EventPriceStaleWarning is emitted when price has not been updated and is about to become stale
+ * @name EventPriceStaleWarningAmino
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.EventPriceStaleWarning
+ */
+export interface EventPriceStaleWarningAmino {
+    /**
+     * 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.v2.EventPriceStaleWarning";
+    value: EventPriceStaleWarningAmino;
+}
+/**
+ * EventPriceStaled is emitted when a price has become stale
+ * @name EventPriceStaled
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.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.v2.EventPriceStaled";
+    value: Uint8Array;
+}
+/**
+ * EventPriceStaled is emitted when a price has become stale
+ * @name EventPriceStaledAmino
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.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.v2.EventPriceStaled";
+    value: EventPriceStaledAmino;
+}
+/**
+ * EventPriceRecovered is emitted when a stale price has started receiving updates again
+ * @name EventPriceRecovered
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.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.v2.EventPriceRecovered";
+    value: Uint8Array;
+}
+/**
+ * EventPriceRecovered is emitted when a stale price has started receiving updates again
+ * @name EventPriceRecoveredAmino
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.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.v2.EventPriceRecovered";
+    value: EventPriceRecoveredAmino;
+}
+/**
+ * EventAggregatedPrice is emitted when aggregated price has an update
+ * @name EventAggregatedPrice
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.EventAggregatedPrice
+ */
+export interface EventAggregatedPrice {
+    /**
+     * price is the aggregated price data
+     */
+    price: AggregatedPrice;
+}
+export interface EventAggregatedPriceProtoMsg {
+    typeUrl: "/akash.oracle.v2.EventAggregatedPrice";
+    value: Uint8Array;
+}
+/**
+ * EventAggregatedPrice is emitted when aggregated price has an update
+ * @name EventAggregatedPriceAmino
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.EventAggregatedPrice
+ */
+export interface EventAggregatedPriceAmino {
+    /**
+     * price is the aggregated price data
+     */
+    price: AggregatedPriceAmino;
+}
+export interface EventAggregatedPriceAminoMsg {
+    type: "/akash.oracle.v2.EventAggregatedPrice";
+    value: EventAggregatedPriceAmino;
+}
+/**
+ * EventPriceData is emitted when new price data is added to the oracle
+ * @name EventPriceData
+ * @package akash.oracle.v2
+ * @see proto type: akash.oracle.v2.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.v2
+ * @see proto type: akash.oracle.v2.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.v2
+ * @see proto type: akash.oracle.v2.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.v2
+ * @see proto type: akash.oracle.v2.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.v2
+ * @see proto type: akash.oracle.v2.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;
+};