@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/esm/sparkdream/futarchy/v1/query.js

@@ -0,0 +1,596 @@
+//@ts-nocheck
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Params } from "./params";
+import { Market } from "./market";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@interchainjs/math";
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * QueryParamsRequest is request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryParamsRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = 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 QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * QueryParamsResponse is response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryParamsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = 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.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryGetMarketRequest() {
+    return {
+        index: BigInt(0)
+    };
+}
+/**
+ * QueryGetMarketRequest defines the QueryGetMarketRequest message.
+ * @name QueryGetMarketRequest
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryGetMarketRequest
+ */
+export const QueryGetMarketRequest = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.index !== BigInt(0)) {
+            writer.uint32(8).uint64(message.index);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryGetMarketRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.index = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryGetMarketRequest();
+        message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryGetMarketRequest();
+        if (object.index !== undefined && object.index !== null) {
+            message.index = BigInt(object.index);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.index = message.index !== BigInt(0) ? message.index?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryGetMarketRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryGetMarketRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryGetMarketRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketRequest",
+            value: QueryGetMarketRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryGetMarketResponse() {
+    return {
+        market: Market.fromPartial({})
+    };
+}
+/**
+ * QueryGetMarketResponse defines the QueryGetMarketResponse message.
+ * @name QueryGetMarketResponse
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryGetMarketResponse
+ */
+export const QueryGetMarketResponse = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.market !== undefined) {
+            Market.encode(message.market, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryGetMarketResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.market = Market.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryGetMarketResponse();
+        message.market = object.market !== undefined && object.market !== null ? Market.fromPartial(object.market) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryGetMarketResponse();
+        if (object.market !== undefined && object.market !== null) {
+            message.market = Market.fromAmino(object.market);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.market = message.market ? Market.toAmino(message.market) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryGetMarketResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryGetMarketResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryGetMarketResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketResponse",
+            value: QueryGetMarketResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryAllMarketRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * QueryAllMarketRequest defines the QueryAllMarketRequest message.
+ * @name QueryAllMarketRequest
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryAllMarketRequest
+ */
+export const QueryAllMarketRequest = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryAllMarketRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryAllMarketRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAllMarketRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAllMarketRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryAllMarketRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryAllMarketRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryAllMarketRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryAllMarketRequest",
+            value: QueryAllMarketRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryAllMarketResponse() {
+    return {
+        market: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryAllMarketResponse defines the QueryAllMarketResponse message.
+ * @name QueryAllMarketResponse
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryAllMarketResponse
+ */
+export const QueryAllMarketResponse = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryAllMarketResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.market) {
+            Market.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryAllMarketResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.market.push(Market.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAllMarketResponse();
+        message.market = object.market?.map(e => Market.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAllMarketResponse();
+        message.market = object.market?.map(e => Market.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.market) {
+            obj.market = message.market.map(e => e ? Market.toAmino(e) : undefined);
+        }
+        else {
+            obj.market = message.market;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryAllMarketResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryAllMarketResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryAllMarketResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryAllMarketResponse",
+            value: QueryAllMarketResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryGetMarketPriceRequest() {
+    return {
+        marketId: BigInt(0),
+        isYes: false,
+        amount: ""
+    };
+}
+/**
+ * QueryGetMarketPriceRequest defines the request for market price query.
+ * @name QueryGetMarketPriceRequest
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryGetMarketPriceRequest
+ */
+export const QueryGetMarketPriceRequest = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketPriceRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.marketId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.marketId);
+        }
+        if (message.isYes === true) {
+            writer.uint32(16).bool(message.isYes);
+        }
+        if (message.amount !== "") {
+            writer.uint32(26).string(message.amount);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryGetMarketPriceRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.marketId = reader.uint64();
+                    break;
+                case 2:
+                    message.isYes = reader.bool();
+                    break;
+                case 3:
+                    message.amount = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryGetMarketPriceRequest();
+        message.marketId = object.marketId !== undefined && object.marketId !== null ? BigInt(object.marketId.toString()) : BigInt(0);
+        message.isYes = object.isYes ?? false;
+        message.amount = object.amount ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryGetMarketPriceRequest();
+        if (object.market_id !== undefined && object.market_id !== null) {
+            message.marketId = BigInt(object.market_id);
+        }
+        if (object.is_yes !== undefined && object.is_yes !== null) {
+            message.isYes = object.is_yes;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.market_id = message.marketId !== BigInt(0) ? message.marketId?.toString() : undefined;
+        obj.is_yes = message.isYes === false ? undefined : message.isYes;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryGetMarketPriceRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryGetMarketPriceRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryGetMarketPriceRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketPriceRequest",
+            value: QueryGetMarketPriceRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryGetMarketPriceResponse() {
+    return {
+        price: "",
+        sharesOut: ""
+    };
+}
+/**
+ * QueryGetMarketPriceResponse defines the response for market price query.
+ * @name QueryGetMarketPriceResponse
+ * @package sparkdream.futarchy.v1
+ * @see proto type: sparkdream.futarchy.v1.QueryGetMarketPriceResponse
+ */
+export const QueryGetMarketPriceResponse = {
+    typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketPriceResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.price !== "") {
+            writer.uint32(10).string(Decimal.fromUserInput(message.price, 18).atomics);
+        }
+        if (message.sharesOut !== "") {
+            writer.uint32(18).string(message.sharesOut);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryGetMarketPriceResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.price = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                case 2:
+                    message.sharesOut = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryGetMarketPriceResponse();
+        message.price = object.price ?? "";
+        message.sharesOut = object.sharesOut ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryGetMarketPriceResponse();
+        if (object.price !== undefined && object.price !== null) {
+            message.price = object.price;
+        }
+        if (object.shares_out !== undefined && object.shares_out !== null) {
+            message.sharesOut = object.shares_out;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.price = message.price === "" ? undefined : message.price;
+        obj.shares_out = message.sharesOut === "" ? undefined : message.sharesOut;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryGetMarketPriceResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryGetMarketPriceResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryGetMarketPriceResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.futarchy.v1.QueryGetMarketPriceResponse",
+            value: QueryGetMarketPriceResponse.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/futarchy/v1/query.lcd.js

@@ -0,0 +1,45 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/futarchy/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* ListMarket Queries a list of Market items. */
+    getMarket = async (params) => {
+        const endpoint = `sparkdream/futarchy/v1/market/${params.index}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListMarket defines the ListMarket RPC. */
+    listMarket = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/futarchy/v1/market`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetMarketPrice queries the current price for a market outcome. */
+    getMarketPrice = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.isYes !== "undefined") {
+            options.params.is_yes = params.isYes;
+        }
+        if (typeof params?.amount !== "undefined") {
+            options.params.amount = params.amount;
+        }
+        const endpoint = `sparkdream/futarchy/v1/market/${params.marketId}/price`;
+        return await this.req.get(endpoint, options);
+    };
+}

package/esm/sparkdream/futarchy/v1/query.rpc.Query.js

@@ -0,0 +1,53 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryGetMarketRequest, QueryGetMarketResponse, QueryAllMarketRequest, QueryAllMarketResponse, QueryGetMarketPriceRequest, QueryGetMarketPriceResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.futarchy.v1.Query", "Params", data);
+        return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+    };
+    /* ListMarket Queries a list of Market items. */
+    getMarket = async (request) => {
+        const data = QueryGetMarketRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.futarchy.v1.Query", "GetMarket", data);
+        return promise.then(data => QueryGetMarketResponse.decode(new BinaryReader(data)));
+    };
+    /* ListMarket defines the ListMarket RPC. */
+    listMarket = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QueryAllMarketRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.futarchy.v1.Query", "ListMarket", data);
+        return promise.then(data => QueryAllMarketResponse.decode(new BinaryReader(data)));
+    };
+    /* GetMarketPrice queries the current price for a market outcome. */
+    getMarketPrice = async (request) => {
+        const data = QueryGetMarketPriceRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.futarchy.v1.Query", "GetMarketPrice", data);
+        return promise.then(data => QueryGetMarketPriceResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        getMarket(request) {
+            return queryService.getMarket(request);
+        },
+        listMarket(request) {
+            return queryService.listMarket(request);
+        },
+        getMarketPrice(request) {
+            return queryService.getMarketPrice(request);
+        }
+    };
+};