@sparkdreamnft/sparkdreamjs 0.0.29 → 0.0.31

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

@@ -0,0 +1,204 @@
+import { Params, ParamsAmino } from "./params";
+import { AggregatedPrice, AggregatedPriceAmino, PriceHealth, PriceHealthAmino } from "./prices";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsRequest
+ */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/akash.oracle.v1.QueryParamsRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequestAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsRequest
+ */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "/akash.oracle.v1.QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsResponse
+ */
+export interface QueryParamsResponse {
+    /**
+     * params defines the parameters of the module.
+     */
+    params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/akash.oracle.v1.QueryParamsResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponseAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsResponse
+ */
+export interface QueryParamsResponseAmino {
+    /**
+     * params defines the parameters of the module.
+     */
+    params: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "/akash.oracle.v1.QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+/**
+ * QueryAggregatedPriceRequest is the request type for aggregated price.
+ * @name QueryAggregatedPriceRequest
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceRequest
+ */
+export interface QueryAggregatedPriceRequest {
+    /**
+     * denom is the asset denomination
+     */
+    denom: string;
+}
+export interface QueryAggregatedPriceRequestProtoMsg {
+    typeUrl: "/akash.oracle.v1.QueryAggregatedPriceRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryAggregatedPriceRequest is the request type for aggregated price.
+ * @name QueryAggregatedPriceRequestAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceRequest
+ */
+export interface QueryAggregatedPriceRequestAmino {
+    /**
+     * denom is the asset denomination
+     */
+    denom?: string;
+}
+export interface QueryAggregatedPriceRequestAminoMsg {
+    type: "/akash.oracle.v1.QueryAggregatedPriceRequest";
+    value: QueryAggregatedPriceRequestAmino;
+}
+/**
+ * QueryAggregatedPriceResponse is the response type for aggregated price.
+ * @name QueryAggregatedPriceResponse
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceResponse
+ */
+export interface QueryAggregatedPriceResponse {
+    /**
+     * aggregated_price is the aggregated price data
+     */
+    aggregatedPrice: AggregatedPrice;
+    /**
+     * price_health is the health status for the price feed
+     */
+    priceHealth: PriceHealth;
+}
+export interface QueryAggregatedPriceResponseProtoMsg {
+    typeUrl: "/akash.oracle.v1.QueryAggregatedPriceResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryAggregatedPriceResponse is the response type for aggregated price.
+ * @name QueryAggregatedPriceResponseAmino
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceResponse
+ */
+export interface QueryAggregatedPriceResponseAmino {
+    /**
+     * aggregated_price is the aggregated price data
+     */
+    aggregated_price: AggregatedPriceAmino;
+    /**
+     * price_health is the health status for the price feed
+     */
+    price_health: PriceHealthAmino;
+}
+export interface QueryAggregatedPriceResponseAminoMsg {
+    type: "/akash.oracle.v1.QueryAggregatedPriceResponse";
+    value: QueryAggregatedPriceResponseAmino;
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsRequest
+ */
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+};
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsResponse
+ */
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+};
+/**
+ * QueryAggregatedPriceRequest is the request type for aggregated price.
+ * @name QueryAggregatedPriceRequest
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceRequest
+ */
+export declare const QueryAggregatedPriceRequest: {
+    typeUrl: string;
+    encode(message: QueryAggregatedPriceRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregatedPriceRequest;
+    fromPartial(object: DeepPartial<QueryAggregatedPriceRequest>): QueryAggregatedPriceRequest;
+    fromAmino(object: QueryAggregatedPriceRequestAmino): QueryAggregatedPriceRequest;
+    toAmino(message: QueryAggregatedPriceRequest): QueryAggregatedPriceRequestAmino;
+    fromAminoMsg(object: QueryAggregatedPriceRequestAminoMsg): QueryAggregatedPriceRequest;
+    fromProtoMsg(message: QueryAggregatedPriceRequestProtoMsg): QueryAggregatedPriceRequest;
+    toProto(message: QueryAggregatedPriceRequest): Uint8Array;
+    toProtoMsg(message: QueryAggregatedPriceRequest): QueryAggregatedPriceRequestProtoMsg;
+};
+/**
+ * QueryAggregatedPriceResponse is the response type for aggregated price.
+ * @name QueryAggregatedPriceResponse
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceResponse
+ */
+export declare const QueryAggregatedPriceResponse: {
+    typeUrl: string;
+    encode(message: QueryAggregatedPriceResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregatedPriceResponse;
+    fromPartial(object: DeepPartial<QueryAggregatedPriceResponse>): QueryAggregatedPriceResponse;
+    fromAmino(object: QueryAggregatedPriceResponseAmino): QueryAggregatedPriceResponse;
+    toAmino(message: QueryAggregatedPriceResponse): QueryAggregatedPriceResponseAmino;
+    fromAminoMsg(object: QueryAggregatedPriceResponseAminoMsg): QueryAggregatedPriceResponse;
+    fromProtoMsg(message: QueryAggregatedPriceResponseProtoMsg): QueryAggregatedPriceResponse;
+    toProto(message: QueryAggregatedPriceResponse): Uint8Array;
+    toProtoMsg(message: QueryAggregatedPriceResponse): QueryAggregatedPriceResponseProtoMsg;
+};

package/akash/oracle/v1/query.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryAggregatedPriceResponse = exports.QueryAggregatedPriceRequest = exports.QueryParamsResponse = exports.QueryParamsRequest = void 0;
+//@ts-nocheck
+const params_1 = require("./params");
+const prices_1 = require("./prices");
+const binary_1 = require("../../../binary");
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsRequest
+ */
+exports.QueryParamsRequest = {
+    typeUrl: "/akash.oracle.v1.QueryParamsRequest",
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.oracle.v1.QueryParamsRequest",
+            value: exports.QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: params_1.Params.fromPartial({})
+    };
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryParamsResponse
+ */
+exports.QueryParamsResponse = {
+    typeUrl: "/akash.oracle.v1.QueryParamsResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(10).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 = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = params_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? params_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : params_1.Params.toAmino(params_1.Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.oracle.v1.QueryParamsResponse",
+            value: exports.QueryParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryAggregatedPriceRequest() {
+    return {
+        denom: ""
+    };
+}
+/**
+ * QueryAggregatedPriceRequest is the request type for aggregated price.
+ * @name QueryAggregatedPriceRequest
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceRequest
+ */
+exports.QueryAggregatedPriceRequest = {
+    typeUrl: "/akash.oracle.v1.QueryAggregatedPriceRequest",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        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 = createBaseQueryAggregatedPriceRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAggregatedPriceRequest();
+        message.denom = object.denom ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAggregatedPriceRequest();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryAggregatedPriceRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryAggregatedPriceRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryAggregatedPriceRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.oracle.v1.QueryAggregatedPriceRequest",
+            value: exports.QueryAggregatedPriceRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryAggregatedPriceResponse() {
+    return {
+        aggregatedPrice: prices_1.AggregatedPrice.fromPartial({}),
+        priceHealth: prices_1.PriceHealth.fromPartial({})
+    };
+}
+/**
+ * QueryAggregatedPriceResponse is the response type for aggregated price.
+ * @name QueryAggregatedPriceResponse
+ * @package akash.oracle.v1
+ * @see proto type: akash.oracle.v1.QueryAggregatedPriceResponse
+ */
+exports.QueryAggregatedPriceResponse = {
+    typeUrl: "/akash.oracle.v1.QueryAggregatedPriceResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.aggregatedPrice !== undefined) {
+            prices_1.AggregatedPrice.encode(message.aggregatedPrice, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.priceHealth !== undefined) {
+            prices_1.PriceHealth.encode(message.priceHealth, 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 = createBaseQueryAggregatedPriceResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.aggregatedPrice = prices_1.AggregatedPrice.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.priceHealth = prices_1.PriceHealth.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAggregatedPriceResponse();
+        message.aggregatedPrice = object.aggregatedPrice !== undefined && object.aggregatedPrice !== null ? prices_1.AggregatedPrice.fromPartial(object.aggregatedPrice) : undefined;
+        message.priceHealth = object.priceHealth !== undefined && object.priceHealth !== null ? prices_1.PriceHealth.fromPartial(object.priceHealth) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAggregatedPriceResponse();
+        if (object.aggregated_price !== undefined && object.aggregated_price !== null) {
+            message.aggregatedPrice = prices_1.AggregatedPrice.fromAmino(object.aggregated_price);
+        }
+        if (object.price_health !== undefined && object.price_health !== null) {
+            message.priceHealth = prices_1.PriceHealth.fromAmino(object.price_health);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.aggregated_price = message.aggregatedPrice ? prices_1.AggregatedPrice.toAmino(message.aggregatedPrice) : prices_1.AggregatedPrice.toAmino(prices_1.AggregatedPrice.fromPartial({}));
+        obj.price_health = message.priceHealth ? prices_1.PriceHealth.toAmino(message.priceHealth) : prices_1.PriceHealth.toAmino(prices_1.PriceHealth.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryAggregatedPriceResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryAggregatedPriceResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryAggregatedPriceResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.oracle.v1.QueryAggregatedPriceResponse",
+            value: exports.QueryAggregatedPriceResponse.encode(message).finish()
+        };
+    }
+};

package/akash/oracle/v1/query.lcd.d.ts

@@ -0,0 +1,12 @@
+import { QueryPricesRequest, QueryPricesResponse } from "./prices";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryAggregatedPriceRequest, QueryAggregatedPriceResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    prices: (params: QueryPricesRequest) => Promise<QueryPricesResponse>;
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    aggregatedPrice: (params: QueryAggregatedPriceRequest) => Promise<QueryAggregatedPriceResponse>;
+}

package/akash/oracle/v1/query.lcd.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+const helpers_1 = require("../../../helpers");
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Prices query prices for specific denom */
+    prices = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.filters !== "undefined") {
+            options.params.filters = params.filters;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `akash/oracle/v1/prices`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Params returns the total set of oracle parameters. */
+    params = async (_params = {}) => {
+        const endpoint = `akash/oracle/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* AggregatedPrice queries the aggregated price for a given denom. */
+    aggregatedPrice = async (params) => {
+        const endpoint = `akash/oracle/v1/aggregated_price/${params.denom}`;
+        return await this.req.get(endpoint);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/akash/oracle/v1/query.rpc.Query.d.ts

@@ -0,0 +1,25 @@
+import { QueryPricesRequest, QueryPricesResponse } from "./prices";
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryAggregatedPriceRequest, QueryAggregatedPriceResponse } from "./query";
+/** Query defines the gRPC querier service of the oracle package. */
+export interface Query {
+    /** Prices query prices for specific denom */
+    prices(request: QueryPricesRequest): Promise<QueryPricesResponse>;
+    /** Params returns the total set of oracle parameters. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** AggregatedPrice queries the aggregated price for a given denom. */
+    aggregatedPrice(request: QueryAggregatedPriceRequest): Promise<QueryAggregatedPriceResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    prices: (request: QueryPricesRequest) => Promise<QueryPricesResponse>;
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    aggregatedPrice: (request: QueryAggregatedPriceRequest) => Promise<QueryAggregatedPriceResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    prices(request: QueryPricesRequest): Promise<QueryPricesResponse>;
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    aggregatedPrice(request: QueryAggregatedPriceRequest): Promise<QueryAggregatedPriceResponse>;
+};

package/akash/oracle/v1/query.rpc.Query.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+//@ts-nocheck
+const prices_1 = require("./prices");
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Prices query prices for specific denom */
+    prices = async (request) => {
+        const data = prices_1.QueryPricesRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.oracle.v1.Query", "Prices", data);
+        return promise.then(data => prices_1.QueryPricesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Params returns the total set of oracle parameters. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.oracle.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* AggregatedPrice queries the aggregated price for a given denom. */
+    aggregatedPrice = async (request) => {
+        const data = query_1.QueryAggregatedPriceRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.oracle.v1.Query", "AggregatedPrice", data);
+        return promise.then(data => query_1.QueryAggregatedPriceResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        prices(request) {
+            return queryService.prices(request);
+        },
+        params(request) {
+            return queryService.params(request);
+        },
+        aggregatedPrice(request) {
+            return queryService.aggregatedPrice(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/akash/oracle/v1/service.amino.d.ts

@@ -0,0 +1,13 @@
+import { MsgAddPriceEntry, MsgUpdateParams } from "./msgs";
+export declare const AminoConverter: {
+    "/akash.oracle.v1.MsgAddPriceEntry": {
+        aminoType: string;
+        toAmino: (message: MsgAddPriceEntry) => import("./msgs").MsgAddPriceEntryAmino;
+        fromAmino: (object: import("./msgs").MsgAddPriceEntryAmino) => MsgAddPriceEntry;
+    };
+    "/akash.oracle.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./msgs").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./msgs").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const msgs_1 = require("./msgs");
+exports.AminoConverter = {
+    "/akash.oracle.v1.MsgAddPriceEntry": {
+        aminoType: "/akash.oracle.v1.MsgAddPriceEntry",
+        toAmino: msgs_1.MsgAddPriceEntry.toAmino,
+        fromAmino: msgs_1.MsgAddPriceEntry.fromAmino
+    },
+    "/akash.oracle.v1.MsgUpdateParams": {
+        aminoType: "/akash.oracle.v1.MsgUpdateParams",
+        toAmino: msgs_1.MsgUpdateParams.toAmino,
+        fromAmino: msgs_1.MsgUpdateParams.fromAmino
+    }
+};

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

@@ -0,0 +1 @@
+export {};

package/akash/oracle/v1/service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });