@xpla/xplajs 1.7.0-beta.0

package/src/cosmos/vesting/v1beta1/tx.js

@@ -0,0 +1,553 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgCreatePeriodicVestingAccountResponse = exports.MsgCreatePeriodicVestingAccount = exports.MsgCreatePermanentLockedAccountResponse = exports.MsgCreatePermanentLockedAccount = exports.MsgCreateVestingAccountResponse = exports.MsgCreateVestingAccount = void 0;
+const coin_1 = require("../../base/v1beta1/coin");
+const vesting_1 = require("./vesting");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseMsgCreateVestingAccount() {
+    return {
+        fromAddress: "",
+        toAddress: "",
+        amount: [],
+        endTime: BigInt(0),
+        delayed: false
+    };
+}
+exports.MsgCreateVestingAccount = {
+    typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccount",
+    aminoType: "cosmos-sdk/MsgCreateVestingAccount",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgCreateVestingAccount.typeUrl || typeof o.fromAddress === "string" && typeof o.toAddress === "string" && Array.isArray(o.amount) && (!o.amount.length || coin_1.Coin.is(o.amount[0])) && typeof o.endTime === "bigint" && typeof o.delayed === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgCreateVestingAccount.typeUrl || typeof o.from_address === "string" && typeof o.to_address === "string" && Array.isArray(o.amount) && (!o.amount.length || coin_1.Coin.isAmino(o.amount[0])) && typeof o.end_time === "bigint" && typeof o.delayed === "boolean");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.fromAddress !== "") {
+            writer.uint32(10).string(message.fromAddress);
+        }
+        if (message.toAddress !== "") {
+            writer.uint32(18).string(message.toAddress);
+        }
+        for (const v of message.amount) {
+            coin_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.endTime !== BigInt(0)) {
+            writer.uint32(32).int64(message.endTime);
+        }
+        if (message.delayed === true) {
+            writer.uint32(40).bool(message.delayed);
+        }
+        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 = createBaseMsgCreateVestingAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.fromAddress = reader.string();
+                    break;
+                case 2:
+                    message.toAddress = reader.string();
+                    break;
+                case 3:
+                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.endTime = reader.int64();
+                    break;
+                case 5:
+                    message.delayed = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateVestingAccount();
+        message.fromAddress = object.fromAddress ?? "";
+        message.toAddress = object.toAddress ?? "";
+        message.amount = object.amount?.map(e => coin_1.Coin.fromPartial(e)) || [];
+        message.endTime = object.endTime !== undefined && object.endTime !== null ? BigInt(object.endTime.toString()) : BigInt(0);
+        message.delayed = object.delayed ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateVestingAccount();
+        if (object.from_address !== undefined && object.from_address !== null) {
+            message.fromAddress = object.from_address;
+        }
+        if (object.to_address !== undefined && object.to_address !== null) {
+            message.toAddress = object.to_address;
+        }
+        message.amount = object.amount?.map(e => coin_1.Coin.fromAmino(e)) || [];
+        if (object.end_time !== undefined && object.end_time !== null) {
+            message.endTime = BigInt(object.end_time);
+        }
+        if (object.delayed !== undefined && object.delayed !== null) {
+            message.delayed = object.delayed;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.from_address = message.fromAddress === "" ? undefined : message.fromAddress;
+        obj.to_address = message.toAddress === "" ? undefined : message.toAddress;
+        if (message.amount) {
+            obj.amount = message.amount.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.amount = message.amount;
+        }
+        obj.end_time = message.endTime !== BigInt(0) ? message.endTime?.toString() : undefined;
+        obj.delayed = message.delayed === false ? undefined : message.delayed;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgCreateVestingAccount.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgCreateVestingAccount",
+            value: exports.MsgCreateVestingAccount.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgCreateVestingAccount.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgCreateVestingAccount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccount",
+            value: exports.MsgCreateVestingAccount.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgCreateVestingAccount.typeUrl, exports.MsgCreateVestingAccount);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgCreateVestingAccount.aminoType, exports.MsgCreateVestingAccount.typeUrl);
+function createBaseMsgCreateVestingAccountResponse() {
+    return {};
+}
+exports.MsgCreateVestingAccountResponse = {
+    typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccountResponse",
+    aminoType: "cosmos-sdk/MsgCreateVestingAccountResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.MsgCreateVestingAccountResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MsgCreateVestingAccountResponse.typeUrl;
+    },
+    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 = createBaseMsgCreateVestingAccountResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCreateVestingAccountResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCreateVestingAccountResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgCreateVestingAccountResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgCreateVestingAccountResponse",
+            value: exports.MsgCreateVestingAccountResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgCreateVestingAccountResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgCreateVestingAccountResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccountResponse",
+            value: exports.MsgCreateVestingAccountResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgCreateVestingAccountResponse.typeUrl, exports.MsgCreateVestingAccountResponse);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgCreateVestingAccountResponse.aminoType, exports.MsgCreateVestingAccountResponse.typeUrl);
+function createBaseMsgCreatePermanentLockedAccount() {
+    return {
+        fromAddress: "",
+        toAddress: "",
+        amount: []
+    };
+}
+exports.MsgCreatePermanentLockedAccount = {
+    typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount",
+    aminoType: "cosmos-sdk/MsgCreatePermLockedAccount",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgCreatePermanentLockedAccount.typeUrl || typeof o.fromAddress === "string" && typeof o.toAddress === "string" && Array.isArray(o.amount) && (!o.amount.length || coin_1.Coin.is(o.amount[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgCreatePermanentLockedAccount.typeUrl || typeof o.from_address === "string" && typeof o.to_address === "string" && Array.isArray(o.amount) && (!o.amount.length || coin_1.Coin.isAmino(o.amount[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.fromAddress !== "") {
+            writer.uint32(10).string(message.fromAddress);
+        }
+        if (message.toAddress !== "") {
+            writer.uint32(18).string(message.toAddress);
+        }
+        for (const v of message.amount) {
+            coin_1.Coin.encode(v, writer.uint32(26).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 = createBaseMsgCreatePermanentLockedAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.fromAddress = reader.string();
+                    break;
+                case 2:
+                    message.toAddress = reader.string();
+                    break;
+                case 3:
+                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreatePermanentLockedAccount();
+        message.fromAddress = object.fromAddress ?? "";
+        message.toAddress = object.toAddress ?? "";
+        message.amount = object.amount?.map(e => coin_1.Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreatePermanentLockedAccount();
+        if (object.from_address !== undefined && object.from_address !== null) {
+            message.fromAddress = object.from_address;
+        }
+        if (object.to_address !== undefined && object.to_address !== null) {
+            message.toAddress = object.to_address;
+        }
+        message.amount = object.amount?.map(e => coin_1.Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.from_address = message.fromAddress === "" ? undefined : message.fromAddress;
+        obj.to_address = message.toAddress === "" ? undefined : message.toAddress;
+        if (message.amount) {
+            obj.amount = message.amount.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.amount = message.amount;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgCreatePermanentLockedAccount.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgCreatePermLockedAccount",
+            value: exports.MsgCreatePermanentLockedAccount.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgCreatePermanentLockedAccount.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgCreatePermanentLockedAccount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount",
+            value: exports.MsgCreatePermanentLockedAccount.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgCreatePermanentLockedAccount.typeUrl, exports.MsgCreatePermanentLockedAccount);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgCreatePermanentLockedAccount.aminoType, exports.MsgCreatePermanentLockedAccount.typeUrl);
+function createBaseMsgCreatePermanentLockedAccountResponse() {
+    return {};
+}
+exports.MsgCreatePermanentLockedAccountResponse = {
+    typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccountResponse",
+    aminoType: "cosmos-sdk/MsgCreatePermanentLockedAccountResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.MsgCreatePermanentLockedAccountResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MsgCreatePermanentLockedAccountResponse.typeUrl;
+    },
+    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 = createBaseMsgCreatePermanentLockedAccountResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCreatePermanentLockedAccountResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCreatePermanentLockedAccountResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgCreatePermanentLockedAccountResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgCreatePermanentLockedAccountResponse",
+            value: exports.MsgCreatePermanentLockedAccountResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgCreatePermanentLockedAccountResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgCreatePermanentLockedAccountResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccountResponse",
+            value: exports.MsgCreatePermanentLockedAccountResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgCreatePermanentLockedAccountResponse.typeUrl, exports.MsgCreatePermanentLockedAccountResponse);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgCreatePermanentLockedAccountResponse.aminoType, exports.MsgCreatePermanentLockedAccountResponse.typeUrl);
+function createBaseMsgCreatePeriodicVestingAccount() {
+    return {
+        fromAddress: "",
+        toAddress: "",
+        startTime: BigInt(0),
+        vestingPeriods: []
+    };
+}
+exports.MsgCreatePeriodicVestingAccount = {
+    typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccount",
+    aminoType: "cosmos-sdk/MsgCreatePeriodVestAccount",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgCreatePeriodicVestingAccount.typeUrl || typeof o.fromAddress === "string" && typeof o.toAddress === "string" && typeof o.startTime === "bigint" && Array.isArray(o.vestingPeriods) && (!o.vestingPeriods.length || vesting_1.Period.is(o.vestingPeriods[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgCreatePeriodicVestingAccount.typeUrl || typeof o.from_address === "string" && typeof o.to_address === "string" && typeof o.start_time === "bigint" && Array.isArray(o.vesting_periods) && (!o.vesting_periods.length || vesting_1.Period.isAmino(o.vesting_periods[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.fromAddress !== "") {
+            writer.uint32(10).string(message.fromAddress);
+        }
+        if (message.toAddress !== "") {
+            writer.uint32(18).string(message.toAddress);
+        }
+        if (message.startTime !== BigInt(0)) {
+            writer.uint32(24).int64(message.startTime);
+        }
+        for (const v of message.vestingPeriods) {
+            vesting_1.Period.encode(v, writer.uint32(34).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 = createBaseMsgCreatePeriodicVestingAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.fromAddress = reader.string();
+                    break;
+                case 2:
+                    message.toAddress = reader.string();
+                    break;
+                case 3:
+                    message.startTime = reader.int64();
+                    break;
+                case 4:
+                    message.vestingPeriods.push(vesting_1.Period.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreatePeriodicVestingAccount();
+        message.fromAddress = object.fromAddress ?? "";
+        message.toAddress = object.toAddress ?? "";
+        message.startTime = object.startTime !== undefined && object.startTime !== null ? BigInt(object.startTime.toString()) : BigInt(0);
+        message.vestingPeriods = object.vestingPeriods?.map(e => vesting_1.Period.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreatePeriodicVestingAccount();
+        if (object.from_address !== undefined && object.from_address !== null) {
+            message.fromAddress = object.from_address;
+        }
+        if (object.to_address !== undefined && object.to_address !== null) {
+            message.toAddress = object.to_address;
+        }
+        if (object.start_time !== undefined && object.start_time !== null) {
+            message.startTime = BigInt(object.start_time);
+        }
+        message.vestingPeriods = object.vesting_periods?.map(e => vesting_1.Period.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.from_address = message.fromAddress === "" ? undefined : message.fromAddress;
+        obj.to_address = message.toAddress === "" ? undefined : message.toAddress;
+        obj.start_time = message.startTime !== BigInt(0) ? message.startTime?.toString() : undefined;
+        if (message.vestingPeriods) {
+            obj.vesting_periods = message.vestingPeriods.map(e => e ? vesting_1.Period.toAmino(e) : undefined);
+        }
+        else {
+            obj.vesting_periods = message.vestingPeriods;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgCreatePeriodicVestingAccount.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgCreatePeriodVestAccount",
+            value: exports.MsgCreatePeriodicVestingAccount.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgCreatePeriodicVestingAccount.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgCreatePeriodicVestingAccount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccount",
+            value: exports.MsgCreatePeriodicVestingAccount.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgCreatePeriodicVestingAccount.typeUrl, exports.MsgCreatePeriodicVestingAccount);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgCreatePeriodicVestingAccount.aminoType, exports.MsgCreatePeriodicVestingAccount.typeUrl);
+function createBaseMsgCreatePeriodicVestingAccountResponse() {
+    return {};
+}
+exports.MsgCreatePeriodicVestingAccountResponse = {
+    typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccountResponse",
+    aminoType: "cosmos-sdk/MsgCreatePeriodicVestingAccountResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.MsgCreatePeriodicVestingAccountResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MsgCreatePeriodicVestingAccountResponse.typeUrl;
+    },
+    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 = createBaseMsgCreatePeriodicVestingAccountResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCreatePeriodicVestingAccountResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCreatePeriodicVestingAccountResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgCreatePeriodicVestingAccountResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgCreatePeriodicVestingAccountResponse",
+            value: exports.MsgCreatePeriodicVestingAccountResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgCreatePeriodicVestingAccountResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgCreatePeriodicVestingAccountResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccountResponse",
+            value: exports.MsgCreatePeriodicVestingAccountResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgCreatePeriodicVestingAccountResponse.typeUrl, exports.MsgCreatePeriodicVestingAccountResponse);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgCreatePeriodicVestingAccountResponse.aminoType, exports.MsgCreatePeriodicVestingAccountResponse.typeUrl);

package/src/cosmos/vesting/v1beta1/tx.registry.ts

@@ -0,0 +1,3 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { MsgCreateVestingAccount, MsgCreatePermanentLockedAccount, MsgCreatePeriodicVestingAccount } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.vesting.v1beta1.MsgCreateVestingAccount", MsgCreateVestingAccount], ["/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount", MsgCreatePermanentLockedAccount], ["/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccount", MsgCreatePeriodicVestingAccount]];

package/src/cosmos/vesting/v1beta1/tx.rpc.func.d.ts

@@ -0,0 +1,5 @@
+import { SigningClientResolver } from "../../../helper-func-types";
+import { MsgCreateVestingAccount, MsgCreatePermanentLockedAccount, MsgCreatePeriodicVestingAccount } from "./tx";
+export declare const createCreateVestingAccount: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgCreateVestingAccount, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createCreatePermanentLockedAccount: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgCreatePermanentLockedAccount, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createCreatePeriodicVestingAccount: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgCreatePeriodicVestingAccount, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;

package/src/cosmos/vesting/v1beta1/tx.rpc.func.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCreatePeriodicVestingAccount = exports.createCreatePermanentLockedAccount = exports.createCreateVestingAccount = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const utils_1 = require("@interchainjs/cosmos/utils");
+const tx_1 = require("./tx");
+const createCreateVestingAccount = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgCreateVestingAccount.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgCreateVestingAccount),
+    converters: (0, utils_1.toConverters)(tx_1.MsgCreateVestingAccount)
+});
+exports.createCreateVestingAccount = createCreateVestingAccount;
+const createCreatePermanentLockedAccount = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgCreatePermanentLockedAccount.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgCreatePermanentLockedAccount),
+    converters: (0, utils_1.toConverters)(tx_1.MsgCreatePermanentLockedAccount)
+});
+exports.createCreatePermanentLockedAccount = createCreatePermanentLockedAccount;
+const createCreatePeriodicVestingAccount = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgCreatePeriodicVestingAccount.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgCreatePeriodicVestingAccount),
+    converters: (0, utils_1.toConverters)(tx_1.MsgCreatePeriodicVestingAccount)
+});
+exports.createCreatePeriodicVestingAccount = createCreatePeriodicVestingAccount;

package/src/cosmos/vesting/v1beta1/tx.rpc.func.ts

@@ -0,0 +1,21 @@
+import { buildTx, SigningClientResolver } from "../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgCreateVestingAccount, MsgCreatePermanentLockedAccount, MsgCreatePeriodicVestingAccount } from "./tx";
+export const createCreateVestingAccount = (clientResolver?: SigningClientResolver) => buildTx<MsgCreateVestingAccount>({
+  clientResolver,
+  typeUrl: MsgCreateVestingAccount.typeUrl,
+  encoders: toEncoders(MsgCreateVestingAccount),
+  converters: toConverters(MsgCreateVestingAccount)
+});
+export const createCreatePermanentLockedAccount = (clientResolver?: SigningClientResolver) => buildTx<MsgCreatePermanentLockedAccount>({
+  clientResolver,
+  typeUrl: MsgCreatePermanentLockedAccount.typeUrl,
+  encoders: toEncoders(MsgCreatePermanentLockedAccount),
+  converters: toConverters(MsgCreatePermanentLockedAccount)
+});
+export const createCreatePeriodicVestingAccount = (clientResolver?: SigningClientResolver) => buildTx<MsgCreatePeriodicVestingAccount>({
+  clientResolver,
+  typeUrl: MsgCreatePeriodicVestingAccount.typeUrl,
+  encoders: toEncoders(MsgCreatePeriodicVestingAccount),
+  converters: toConverters(MsgCreatePeriodicVestingAccount)
+});

package/src/cosmos/vesting/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,59 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { MsgCreateVestingAccount, MsgCreateVestingAccountResponse, MsgCreatePermanentLockedAccount, MsgCreatePermanentLockedAccountResponse, MsgCreatePeriodicVestingAccount, MsgCreatePeriodicVestingAccountResponse } from "./tx";
+/** Msg defines the bank Msg service. */
+export interface Msg {
+  /**
+   * CreateVestingAccount defines a method that enables creating a vesting
+   * account.
+   */
+  createVestingAccount(request: MsgCreateVestingAccount): Promise<MsgCreateVestingAccountResponse>;
+  /**
+   * CreatePermanentLockedAccount defines a method that enables creating a permanent
+   * locked account.
+   * 
+   * Since: cosmos-sdk 0.46
+   */
+  createPermanentLockedAccount(request: MsgCreatePermanentLockedAccount): Promise<MsgCreatePermanentLockedAccountResponse>;
+  /**
+   * CreatePeriodicVestingAccount defines a method that enables creating a
+   * periodic vesting account.
+   * 
+   * Since: cosmos-sdk 0.46
+   */
+  createPeriodicVestingAccount(request: MsgCreatePeriodicVestingAccount): Promise<MsgCreatePeriodicVestingAccountResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* CreateVestingAccount defines a method that enables creating a vesting
+   account. */
+  createVestingAccount = async (request: MsgCreateVestingAccount): Promise<MsgCreateVestingAccountResponse> => {
+    const data = MsgCreateVestingAccount.encode(request).finish();
+    const promise = this.rpc.request("cosmos.vesting.v1beta1.Msg", "CreateVestingAccount", data);
+    return promise.then(data => MsgCreateVestingAccountResponse.decode(new BinaryReader(data)));
+  };
+  /* CreatePermanentLockedAccount defines a method that enables creating a permanent
+   locked account.
+  
+   Since: cosmos-sdk 0.46 */
+  createPermanentLockedAccount = async (request: MsgCreatePermanentLockedAccount): Promise<MsgCreatePermanentLockedAccountResponse> => {
+    const data = MsgCreatePermanentLockedAccount.encode(request).finish();
+    const promise = this.rpc.request("cosmos.vesting.v1beta1.Msg", "CreatePermanentLockedAccount", data);
+    return promise.then(data => MsgCreatePermanentLockedAccountResponse.decode(new BinaryReader(data)));
+  };
+  /* CreatePeriodicVestingAccount defines a method that enables creating a
+   periodic vesting account.
+  
+   Since: cosmos-sdk 0.46 */
+  createPeriodicVestingAccount = async (request: MsgCreatePeriodicVestingAccount): Promise<MsgCreatePeriodicVestingAccountResponse> => {
+    const data = MsgCreatePeriodicVestingAccount.encode(request).finish();
+    const promise = this.rpc.request("cosmos.vesting.v1beta1.Msg", "CreatePeriodicVestingAccount", data);
+    return promise.then(data => MsgCreatePeriodicVestingAccountResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createClientImpl = (rpc: TxRpc) => {
+  return new MsgClientImpl(rpc);
+};