@xpla/xplajs 1.7.0-beta.6 → 1.7.0-beta.7

package/dist/esm/xpla/reward/v1beta1/tx.js

@@ -1,301 +0,0 @@
-import { Coin } from "../../../cosmos/base/v1beta1/coin";
-import { Params } from "./reward";
-import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
-function createBaseMsgFundRewardPool() {
-    return {
-        amount: [],
-        depositor: ""
-    };
-}
-export const MsgFundRewardPool = {
-    typeUrl: "/xpla.reward.v1beta1.MsgFundRewardPool",
-    aminoType: "xpladev/MsgFundRewardPool",
-    is(o) {
-        return o && (o.$typeUrl === MsgFundRewardPool.typeUrl || Array.isArray(o.amount) && (!o.amount.length || Coin.is(o.amount[0])) && typeof o.depositor === "string");
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === MsgFundRewardPool.typeUrl || Array.isArray(o.amount) && (!o.amount.length || Coin.isAmino(o.amount[0])) && typeof o.depositor === "string");
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        for (const v of message.amount) {
-            Coin.encode(v, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.depositor !== "") {
-            writer.uint32(18).string(message.depositor);
-        }
-        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 = createBaseMsgFundRewardPool();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.amount.push(Coin.decode(reader, reader.uint32()));
-                    break;
-                case 2:
-                    message.depositor = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseMsgFundRewardPool();
-        message.amount = object.amount?.map(e => Coin.fromPartial(e)) || [];
-        message.depositor = object.depositor ?? "";
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseMsgFundRewardPool();
-        message.amount = object.amount?.map(e => Coin.fromAmino(e)) || [];
-        if (object.depositor !== undefined && object.depositor !== null) {
-            message.depositor = object.depositor;
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        if (message.amount) {
-            obj.amount = message.amount.map(e => e ? Coin.toAmino(e) : undefined);
-        }
-        else {
-            obj.amount = message.amount;
-        }
-        obj.depositor = message.depositor === "" ? undefined : message.depositor;
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgFundRewardPool.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "xpladev/MsgFundRewardPool",
-            value: MsgFundRewardPool.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgFundRewardPool.decode(message.value);
-    },
-    toProto(message) {
-        return MsgFundRewardPool.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/xpla.reward.v1beta1.MsgFundRewardPool",
-            value: MsgFundRewardPool.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgFundRewardPool.typeUrl, MsgFundRewardPool);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgFundRewardPool.aminoType, MsgFundRewardPool.typeUrl);
-function createBaseMsgFundRewardPoolResponse() {
-    return {};
-}
-export const MsgFundRewardPoolResponse = {
-    typeUrl: "/xpla.reward.v1beta1.MsgFundRewardPoolResponse",
-    is(o) {
-        return o && o.$typeUrl === MsgFundRewardPoolResponse.typeUrl;
-    },
-    isAmino(o) {
-        return o && o.$typeUrl === MsgFundRewardPoolResponse.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 = createBaseMsgFundRewardPoolResponse();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(_) {
-        const message = createBaseMsgFundRewardPoolResponse();
-        return message;
-    },
-    fromAmino(_) {
-        const message = createBaseMsgFundRewardPoolResponse();
-        return message;
-    },
-    toAmino(_) {
-        const obj = {};
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgFundRewardPoolResponse.fromAmino(object.value);
-    },
-    fromProtoMsg(message) {
-        return MsgFundRewardPoolResponse.decode(message.value);
-    },
-    toProto(message) {
-        return MsgFundRewardPoolResponse.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/xpla.reward.v1beta1.MsgFundRewardPoolResponse",
-            value: MsgFundRewardPoolResponse.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgFundRewardPoolResponse.typeUrl, MsgFundRewardPoolResponse);
-function createBaseMsgUpdateParams() {
-    return {
-        authority: "",
-        params: Params.fromPartial({})
-    };
-}
-export const MsgUpdateParams = {
-    typeUrl: "/xpla.reward.v1beta1.MsgUpdateParams",
-    aminoType: "xpladev/x/reward/MsgUpdateParams",
-    is(o) {
-        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.is(o.params));
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.isAmino(o.params));
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.authority !== "") {
-            writer.uint32(10).string(message.authority);
-        }
-        if (message.params !== undefined) {
-            Params.encode(message.params, 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 = createBaseMsgUpdateParams();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.authority = reader.string();
-                    break;
-                case 2:
-                    message.params = Params.decode(reader, reader.uint32());
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseMsgUpdateParams();
-        message.authority = object.authority ?? "";
-        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseMsgUpdateParams();
-        if (object.authority !== undefined && object.authority !== null) {
-            message.authority = object.authority;
-        }
-        if (object.params !== undefined && object.params !== null) {
-            message.params = Params.fromAmino(object.params);
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        obj.authority = message.authority === "" ? undefined : message.authority;
-        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgUpdateParams.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "xpladev/x/reward/MsgUpdateParams",
-            value: MsgUpdateParams.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgUpdateParams.decode(message.value);
-    },
-    toProto(message) {
-        return MsgUpdateParams.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/xpla.reward.v1beta1.MsgUpdateParams",
-            value: MsgUpdateParams.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
-function createBaseMsgUpdateParamsResponse() {
-    return {};
-}
-export const MsgUpdateParamsResponse = {
-    typeUrl: "/xpla.reward.v1beta1.MsgUpdateParamsResponse",
-    is(o) {
-        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
-    },
-    isAmino(o) {
-        return o && o.$typeUrl === MsgUpdateParamsResponse.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 = createBaseMsgUpdateParamsResponse();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(_) {
-        const message = createBaseMsgUpdateParamsResponse();
-        return message;
-    },
-    fromAmino(_) {
-        const message = createBaseMsgUpdateParamsResponse();
-        return message;
-    },
-    toAmino(_) {
-        const obj = {};
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgUpdateParamsResponse.fromAmino(object.value);
-    },
-    fromProtoMsg(message) {
-        return MsgUpdateParamsResponse.decode(message.value);
-    },
-    toProto(message) {
-        return MsgUpdateParamsResponse.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/xpla.reward.v1beta1.MsgUpdateParamsResponse",
-            value: MsgUpdateParamsResponse.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);

package/dist/esm/xpla/reward/v1beta1/tx.registry.js

@@ -1,2 +0,0 @@
-import { MsgFundRewardPool, MsgUpdateParams } from "./tx";
-export const registry = [["/xpla.reward.v1beta1.MsgFundRewardPool", MsgFundRewardPool], ["/xpla.reward.v1beta1.MsgUpdateParams", MsgUpdateParams]];

package/dist/esm/xpla/reward/v1beta1/tx.rpc.func.js

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

package/dist/esm/xpla/reward/v1beta1/tx.rpc.msg.js

@@ -1,26 +0,0 @@
-import { BinaryReader } from "../../../binary";
-import { MsgFundRewardPool, MsgFundRewardPoolResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx";
-export class MsgClientImpl {
-    rpc;
-    constructor(rpc) {
-        this.rpc = rpc;
-    }
-    /* MsgFundRewardPool defines a method to allow an account to directly
-     fund the reward pool. */
-    fundRewardPool = async (request) => {
-        const data = MsgFundRewardPool.encode(request).finish();
-        const promise = this.rpc.request("xpla.reward.v1beta1.Msg", "FundRewardPool", data);
-        return promise.then(data => MsgFundRewardPoolResponse.decode(new BinaryReader(data)));
-    };
-    /* UpdateParams defined a governance operation for updating the x/reward
-     module parameters. The authority is hard-coded to the Cosmos SDK x/gov
-     module account */
-    updateParams = async (request) => {
-        const data = MsgUpdateParams.encode(request).finish();
-        const promise = this.rpc.request("xpla.reward.v1beta1.Msg", "UpdateParams", data);
-        return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
-    };
-}
-export const createClientImpl = (rpc) => {
-    return new MsgClientImpl(rpc);
-};

package/dist/esm/xpla/rpc.query.js

@@ -1,125 +0,0 @@
-import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
-import { QueryClient } from "@cosmjs/stargate";
-export const createRPCQueryClient = async ({ rpcEndpoint }) => {
-    const tmClient = await Tendermint34Client.connect(rpcEndpoint);
-    const client = new QueryClient(tmClient);
-    return {
-        xpla: {
-            volunteer: {
-                v1beta1: (await import("./volunteer/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            reward: {
-                v1beta1: (await import("./reward/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            }
-        },
-        ibc: {
-            lightclients: {
-                wasm: {
-                    v1: (await import("../ibc/lightclients/wasm/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                }
-            },
-            core: {
-                connection: {
-                    v1: (await import("../ibc/core/connection/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                },
-                client: {
-                    v1: (await import("../ibc/core/client/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                },
-                channel: {
-                    v1: (await import("../ibc/core/channel/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                }
-            },
-            applications: {
-                transfer: {
-                    v1: (await import("../ibc/applications/transfer/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                },
-                interchain_accounts: {
-                    host: {
-                        v1: (await import("../ibc/applications/interchain_accounts/host/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                    },
-                    controller: {
-                        v1: (await import("../ibc/applications/interchain_accounts/controller/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                    }
-                },
-                fee: {
-                    v1: (await import("../ibc/applications/fee/v1/query.rpc.Query")).createRpcQueryExtension(client)
-                }
-            }
-        },
-        ethermint: {
-            feemarket: {
-                v1: (await import("../ethermint/feemarket/v1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            evm: {
-                v1: (await import("../ethermint/evm/v1/query.rpc.Query")).createRpcQueryExtension(client)
-            }
-        },
-        cosmwasm: {
-            wasm: {
-                v1: (await import("../cosmwasm/wasm/v1/query.rpc.Query")).createRpcQueryExtension(client)
-            }
-        },
-        cosmos: {
-            upgrade: {
-                v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            tx: {
-                v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client)
-            },
-            staking: {
-                v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            slashing: {
-                v1beta1: (await import("../cosmos/slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            params: {
-                v1beta1: (await import("../cosmos/params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            mint: {
-                v1beta1: (await import("../cosmos/mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            gov: {
-                v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client),
-                v1: (await import("../cosmos/gov/v1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            feegrant: {
-                v1beta1: (await import("../cosmos/feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            evidence: {
-                v1beta1: (await import("../cosmos/evidence/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            distribution: {
-                v1beta1: (await import("../cosmos/distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            consensus: {
-                v1: (await import("../cosmos/consensus/v1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            base: {
-                tendermint: {
-                    v1beta1: (await import("../cosmos/base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
-                },
-                node: {
-                    v1beta1: (await import("../cosmos/base/node/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
-                },
-                grpc: {
-                    v2: (await import("../cosmos/base/grpc/v2/service.rpc.Service")).createRpcQueryExtension(client)
-                }
-            },
-            bank: {
-                v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            autocli: {
-                v1: (await import("../cosmos/autocli/v1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            authz: {
-                v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            auth: {
-                v1beta1: (await import("../cosmos/auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
-            },
-            app: {
-                v1alpha1: (await import("../cosmos/app/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
-            }
-        }
-    };
-};

package/dist/esm/xpla/rpc.tx.js

@@ -1 +0,0 @@
-export const createRPCMsgClient = async ({ rpc }) => ({});

package/dist/esm/xpla/volunteer/v1beta1/genesis.js

@@ -1,76 +0,0 @@
-import { VolunteerValidator } from "./volunteervalidator";
-import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
-function createBaseGenesisState() {
-    return {
-        volunteerValidators: []
-    };
-}
-export const GenesisState = {
-    typeUrl: "/xpla.volunteer.v1beta1.GenesisState",
-    is(o) {
-        return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.volunteerValidators) && (!o.volunteerValidators.length || VolunteerValidator.is(o.volunteerValidators[0])));
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.volunteer_validators) && (!o.volunteer_validators.length || VolunteerValidator.isAmino(o.volunteer_validators[0])));
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        for (const v of message.volunteerValidators) {
-            VolunteerValidator.encode(v, 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 = createBaseGenesisState();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.volunteerValidators.push(VolunteerValidator.decode(reader, reader.uint32()));
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseGenesisState();
-        message.volunteerValidators = object.volunteerValidators?.map(e => VolunteerValidator.fromPartial(e)) || [];
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseGenesisState();
-        message.volunteerValidators = object.volunteer_validators?.map(e => VolunteerValidator.fromAmino(e)) || [];
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        if (message.volunteerValidators) {
-            obj.volunteer_validators = message.volunteerValidators.map(e => e ? VolunteerValidator.toAmino(e) : undefined);
-        }
-        else {
-            obj.volunteer_validators = message.volunteerValidators;
-        }
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return GenesisState.fromAmino(object.value);
-    },
-    fromProtoMsg(message) {
-        return GenesisState.decode(message.value);
-    },
-    toProto(message) {
-        return GenesisState.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/xpla.volunteer.v1beta1.GenesisState",
-            value: GenesisState.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);