@xpla/xplajs 1.7.0 → 1.8.0-rc.1

package/esm/cosmos/nft/v1beta1/query.lcd.js

@@ -1,63 +0,0 @@
-import { setPaginationParams } from "../../../helpers";
-export class LCDQueryClient {
-    req;
-    constructor({ requestClient }) {
-        this.req = requestClient;
-    }
-    /* Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 */
-    balance = async (params) => {
-        const endpoint = `cosmos/nft/v1beta1/balance/${params.owner}/${params.classId}`;
-        return await this.req.get(endpoint);
-    };
-    /* Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 */
-    owner = async (params) => {
-        const endpoint = `cosmos/nft/v1beta1/owner/${params.classId}/${params.id}`;
-        return await this.req.get(endpoint);
-    };
-    /* Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. */
-    supply = async (params) => {
-        const endpoint = `cosmos/nft/v1beta1/supply/${params.classId}`;
-        return await this.req.get(endpoint);
-    };
-    /* NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in
-     ERC721Enumerable */
-    nFTs = async (params) => {
-        const options = {
-            params: {}
-        };
-        if (typeof params?.classId !== "undefined") {
-            options.params.class_id = params.classId;
-        }
-        if (typeof params?.owner !== "undefined") {
-            options.params.owner = params.owner;
-        }
-        if (typeof params?.pagination !== "undefined") {
-            setPaginationParams(options, params.pagination);
-        }
-        const endpoint = `cosmos/nft/v1beta1/nfts`;
-        return await this.req.get(endpoint, options);
-    };
-    /* NFT queries an NFT based on its class and id. */
-    nFT = async (params) => {
-        const endpoint = `cosmos/nft/v1beta1/nfts/${params.classId}/${params.id}`;
-        return await this.req.get(endpoint);
-    };
-    /* Class queries an NFT class based on its id */
-    class = async (params) => {
-        const endpoint = `cosmos/nft/v1beta1/classes/${params.classId}`;
-        return await this.req.get(endpoint);
-    };
-    /* Classes queries all NFT classes */
-    classes = async (params = {
-        pagination: undefined
-    }) => {
-        const options = {
-            params: {}
-        };
-        if (typeof params?.pagination !== "undefined") {
-            setPaginationParams(options, params.pagination);
-        }
-        const endpoint = `cosmos/nft/v1beta1/classes`;
-        return await this.req.get(endpoint, options);
-    };
-}

package/esm/cosmos/nft/v1beta1/query.rpc.Query.js

@@ -1,81 +0,0 @@
-import { BinaryReader } from "../../../binary";
-import { createProtobufRpcClient } from "@cosmjs/stargate";
-import { QueryBalanceRequest, QueryBalanceResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryNFTsRequest, QueryNFTsResponse, QueryNFTRequest, QueryNFTResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse } from "./query";
-export class QueryClientImpl {
-    rpc;
-    constructor(rpc) {
-        this.rpc = rpc;
-    }
-    /* Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 */
-    balance = async (request) => {
-        const data = QueryBalanceRequest.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Balance", data);
-        return promise.then(data => QueryBalanceResponse.decode(new BinaryReader(data)));
-    };
-    /* Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 */
-    owner = async (request) => {
-        const data = QueryOwnerRequest.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Owner", data);
-        return promise.then(data => QueryOwnerResponse.decode(new BinaryReader(data)));
-    };
-    /* Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. */
-    supply = async (request) => {
-        const data = QuerySupplyRequest.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Supply", data);
-        return promise.then(data => QuerySupplyResponse.decode(new BinaryReader(data)));
-    };
-    /* NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in
-     ERC721Enumerable */
-    nFTs = async (request) => {
-        const data = QueryNFTsRequest.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "NFTs", data);
-        return promise.then(data => QueryNFTsResponse.decode(new BinaryReader(data)));
-    };
-    /* NFT queries an NFT based on its class and id. */
-    nFT = async (request) => {
-        const data = QueryNFTRequest.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "NFT", data);
-        return promise.then(data => QueryNFTResponse.decode(new BinaryReader(data)));
-    };
-    /* Class queries an NFT class based on its id */
-    class = async (request) => {
-        const data = QueryClassRequest.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Class", data);
-        return promise.then(data => QueryClassResponse.decode(new BinaryReader(data)));
-    };
-    /* Classes queries all NFT classes */
-    classes = async (request = {
-        pagination: undefined
-    }) => {
-        const data = QueryClassesRequest.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Query", "Classes", data);
-        return promise.then(data => QueryClassesResponse.decode(new BinaryReader(data)));
-    };
-}
-export const createRpcQueryExtension = (base) => {
-    const rpc = createProtobufRpcClient(base);
-    const queryService = new QueryClientImpl(rpc);
-    return {
-        balance(request) {
-            return queryService.balance(request);
-        },
-        owner(request) {
-            return queryService.owner(request);
-        },
-        supply(request) {
-            return queryService.supply(request);
-        },
-        nFTs(request) {
-            return queryService.nFTs(request);
-        },
-        nFT(request) {
-            return queryService.nFT(request);
-        },
-        class(request) {
-            return queryService.class(request);
-        },
-        classes(request) {
-            return queryService.classes(request);
-        }
-    };
-};

package/esm/cosmos/nft/v1beta1/query.rpc.func.js

@@ -1,51 +0,0 @@
-import { buildQuery } from "../../../helper-func-types";
-import { QueryBalanceRequest, QueryBalanceResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryNFTsRequest, QueryNFTsResponse, QueryNFTRequest, QueryNFTResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse } from "./query";
-export const createGetBalance = (clientResolver) => buildQuery({
-    encode: QueryBalanceRequest.encode,
-    decode: QueryBalanceResponse.decode,
-    service: "cosmos.nft.v1beta1.Query",
-    method: "Balance",
-    clientResolver
-});
-export const createGetOwner = (clientResolver) => buildQuery({
-    encode: QueryOwnerRequest.encode,
-    decode: QueryOwnerResponse.decode,
-    service: "cosmos.nft.v1beta1.Query",
-    method: "Owner",
-    clientResolver
-});
-export const createGetSupply = (clientResolver) => buildQuery({
-    encode: QuerySupplyRequest.encode,
-    decode: QuerySupplyResponse.decode,
-    service: "cosmos.nft.v1beta1.Query",
-    method: "Supply",
-    clientResolver
-});
-export const createGetNFTs = (clientResolver) => buildQuery({
-    encode: QueryNFTsRequest.encode,
-    decode: QueryNFTsResponse.decode,
-    service: "cosmos.nft.v1beta1.Query",
-    method: "NFTs",
-    clientResolver
-});
-export const createGetNFT = (clientResolver) => buildQuery({
-    encode: QueryNFTRequest.encode,
-    decode: QueryNFTResponse.decode,
-    service: "cosmos.nft.v1beta1.Query",
-    method: "NFT",
-    clientResolver
-});
-export const createGetClass = (clientResolver) => buildQuery({
-    encode: QueryClassRequest.encode,
-    decode: QueryClassResponse.decode,
-    service: "cosmos.nft.v1beta1.Query",
-    method: "Class",
-    clientResolver
-});
-export const createGetClasses = (clientResolver) => buildQuery({
-    encode: QueryClassesRequest.encode,
-    decode: QueryClassesResponse.decode,
-    service: "cosmos.nft.v1beta1.Query",
-    method: "Classes",
-    clientResolver
-});

package/esm/cosmos/nft/v1beta1/tx.amino.js

@@ -1,8 +0,0 @@
-import { MsgSend } from "./tx";
-export const AminoConverter = {
-    "/cosmos.nft.v1beta1.MsgSend": {
-        aminoType: "cosmos-sdk/MsgNFTSend",
-        toAmino: MsgSend.toAmino,
-        fromAmino: MsgSend.fromAmino
-    }
-};

package/esm/cosmos/nft/v1beta1/tx.js

@@ -1,181 +0,0 @@
-import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
-function createBaseMsgSend() {
-    return {
-        classId: "",
-        id: "",
-        sender: "",
-        receiver: ""
-    };
-}
-export const MsgSend = {
-    typeUrl: "/cosmos.nft.v1beta1.MsgSend",
-    aminoType: "cosmos-sdk/MsgNFTSend",
-    is(o) {
-        return o && (o.$typeUrl === MsgSend.typeUrl || typeof o.classId === "string" && typeof o.id === "string" && typeof o.sender === "string" && typeof o.receiver === "string");
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === MsgSend.typeUrl || typeof o.class_id === "string" && typeof o.id === "string" && typeof o.sender === "string" && typeof o.receiver === "string");
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.classId !== "") {
-            writer.uint32(10).string(message.classId);
-        }
-        if (message.id !== "") {
-            writer.uint32(18).string(message.id);
-        }
-        if (message.sender !== "") {
-            writer.uint32(26).string(message.sender);
-        }
-        if (message.receiver !== "") {
-            writer.uint32(34).string(message.receiver);
-        }
-        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 = createBaseMsgSend();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.classId = reader.string();
-                    break;
-                case 2:
-                    message.id = reader.string();
-                    break;
-                case 3:
-                    message.sender = reader.string();
-                    break;
-                case 4:
-                    message.receiver = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseMsgSend();
-        message.classId = object.classId ?? "";
-        message.id = object.id ?? "";
-        message.sender = object.sender ?? "";
-        message.receiver = object.receiver ?? "";
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseMsgSend();
-        if (object.class_id !== undefined && object.class_id !== null) {
-            message.classId = object.class_id;
-        }
-        if (object.id !== undefined && object.id !== null) {
-            message.id = object.id;
-        }
-        if (object.sender !== undefined && object.sender !== null) {
-            message.sender = object.sender;
-        }
-        if (object.receiver !== undefined && object.receiver !== null) {
-            message.receiver = object.receiver;
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        obj.class_id = message.classId === "" ? undefined : message.classId;
-        obj.id = message.id === "" ? undefined : message.id;
-        obj.sender = message.sender === "" ? undefined : message.sender;
-        obj.receiver = message.receiver === "" ? undefined : message.receiver;
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgSend.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/MsgNFTSend",
-            value: MsgSend.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgSend.decode(message.value);
-    },
-    toProto(message) {
-        return MsgSend.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.nft.v1beta1.MsgSend",
-            value: MsgSend.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgSend.typeUrl, MsgSend);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSend.aminoType, MsgSend.typeUrl);
-function createBaseMsgSendResponse() {
-    return {};
-}
-export const MsgSendResponse = {
-    typeUrl: "/cosmos.nft.v1beta1.MsgSendResponse",
-    aminoType: "cosmos-sdk/MsgSendResponse",
-    is(o) {
-        return o && o.$typeUrl === MsgSendResponse.typeUrl;
-    },
-    isAmino(o) {
-        return o && o.$typeUrl === MsgSendResponse.typeUrl;
-    },
-    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 = createBaseMsgSendResponse();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(_) {
-        const message = createBaseMsgSendResponse();
-        return message;
-    },
-    fromAmino(_) {
-        const message = createBaseMsgSendResponse();
-        return message;
-    },
-    toAmino(_) {
-        const obj = {};
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgSendResponse.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/MsgSendResponse",
-            value: MsgSendResponse.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgSendResponse.decode(message.value);
-    },
-    toProto(message) {
-        return MsgSendResponse.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.nft.v1beta1.MsgSendResponse",
-            value: MsgSendResponse.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgSendResponse.typeUrl, MsgSendResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSendResponse.aminoType, MsgSendResponse.typeUrl);

package/esm/cosmos/nft/v1beta1/tx.registry.js

@@ -1,2 +0,0 @@
-import { MsgSend } from "./tx";
-export const registry = [["/cosmos.nft.v1beta1.MsgSend", MsgSend]];

package/esm/cosmos/nft/v1beta1/tx.rpc.func.js

@@ -1,9 +0,0 @@
-import { buildTx } from "../../../helper-func-types";
-import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
-import { MsgSend } from "./tx";
-export const createSend = (clientResolver) => buildTx({
-    clientResolver,
-    typeUrl: MsgSend.typeUrl,
-    encoders: toEncoders(MsgSend),
-    converters: toConverters(MsgSend)
-});

package/esm/cosmos/nft/v1beta1/tx.rpc.msg.js

@@ -1,17 +0,0 @@
-import { BinaryReader } from "../../../binary";
-import { MsgSend, MsgSendResponse } from "./tx";
-export class MsgClientImpl {
-    rpc;
-    constructor(rpc) {
-        this.rpc = rpc;
-    }
-    /* Send defines a method to send a nft from one account to another account. */
-    send = async (request) => {
-        const data = MsgSend.encode(request).finish();
-        const promise = this.rpc.request("cosmos.nft.v1beta1.Msg", "Send", data);
-        return promise.then(data => MsgSendResponse.decode(new BinaryReader(data)));
-    };
-}
-export const createClientImpl = (rpc) => {
-    return new MsgClientImpl(rpc);
-};

package/esm/cosmos/orm/module/v1alpha1/module.js

@@ -1,67 +0,0 @@
-import { BinaryReader, BinaryWriter } from "../../../../binary";
-import { GlobalDecoderRegistry } from "../../../../registry";
-function createBaseModule() {
-    return {};
-}
-export const Module = {
-    typeUrl: "/cosmos.orm.module.v1alpha1.Module",
-    aminoType: "cosmos-sdk/Module",
-    is(o) {
-        return o && o.$typeUrl === Module.typeUrl;
-    },
-    isAmino(o) {
-        return o && o.$typeUrl === Module.typeUrl;
-    },
-    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 = createBaseModule();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(_) {
-        const message = createBaseModule();
-        return message;
-    },
-    fromAmino(_) {
-        const message = createBaseModule();
-        return message;
-    },
-    toAmino(_) {
-        const obj = {};
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return Module.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/Module",
-            value: Module.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return Module.decode(message.value);
-    },
-    toProto(message) {
-        return Module.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.orm.module.v1alpha1.Module",
-            value: Module.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(Module.typeUrl, Module);
-GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);