injectivejs 1.4.0 → 1.6.0

package/esm/injective/permissions/v1beta1/permissions.js

@@ -0,0 +1,601 @@
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** each Action enum value should be a power of two */
+export var Action;
+(function (Action) {
+    Action[Action["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    Action[Action["MINT"] = 1] = "MINT";
+    Action[Action["RECEIVE"] = 2] = "RECEIVE";
+    Action[Action["BURN"] = 4] = "BURN";
+    Action[Action["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Action || (Action = {}));
+export const ActionAmino = Action;
+export function actionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "UNSPECIFIED":
+            return Action.UNSPECIFIED;
+        case 1:
+        case "MINT":
+            return Action.MINT;
+        case 2:
+        case "RECEIVE":
+            return Action.RECEIVE;
+        case 4:
+        case "BURN":
+            return Action.BURN;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Action.UNRECOGNIZED;
+    }
+}
+export function actionToJSON(object) {
+    switch (object) {
+        case Action.UNSPECIFIED:
+            return "UNSPECIFIED";
+        case Action.MINT:
+            return "MINT";
+        case Action.RECEIVE:
+            return "RECEIVE";
+        case Action.BURN:
+            return "BURN";
+        case Action.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseNamespace() {
+    return {
+        denom: "",
+        wasmHook: "",
+        mintsPaused: false,
+        sendsPaused: false,
+        burnsPaused: false,
+        rolePermissions: [],
+        addressRoles: []
+    };
+}
+export const Namespace = {
+    typeUrl: "/injective.permissions.v1beta1.Namespace",
+    is(o) {
+        return o && (o.$typeUrl === Namespace.typeUrl || typeof o.denom === "string" && typeof o.wasmHook === "string" && typeof o.mintsPaused === "boolean" && typeof o.sendsPaused === "boolean" && typeof o.burnsPaused === "boolean" && Array.isArray(o.rolePermissions) && (!o.rolePermissions.length || Role.is(o.rolePermissions[0])) && Array.isArray(o.addressRoles) && (!o.addressRoles.length || AddressRoles.is(o.addressRoles[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Namespace.typeUrl || typeof o.denom === "string" && typeof o.wasm_hook === "string" && typeof o.mints_paused === "boolean" && typeof o.sends_paused === "boolean" && typeof o.burns_paused === "boolean" && Array.isArray(o.role_permissions) && (!o.role_permissions.length || Role.isAmino(o.role_permissions[0])) && Array.isArray(o.address_roles) && (!o.address_roles.length || AddressRoles.isAmino(o.address_roles[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.wasmHook !== "") {
+            writer.uint32(18).string(message.wasmHook);
+        }
+        if (message.mintsPaused === true) {
+            writer.uint32(24).bool(message.mintsPaused);
+        }
+        if (message.sendsPaused === true) {
+            writer.uint32(32).bool(message.sendsPaused);
+        }
+        if (message.burnsPaused === true) {
+            writer.uint32(40).bool(message.burnsPaused);
+        }
+        for (const v of message.rolePermissions) {
+            Role.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.addressRoles) {
+            AddressRoles.encode(v, writer.uint32(58).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 = createBaseNamespace();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                case 2:
+                    message.wasmHook = reader.string();
+                    break;
+                case 3:
+                    message.mintsPaused = reader.bool();
+                    break;
+                case 4:
+                    message.sendsPaused = reader.bool();
+                    break;
+                case 5:
+                    message.burnsPaused = reader.bool();
+                    break;
+                case 6:
+                    message.rolePermissions.push(Role.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.addressRoles.push(AddressRoles.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseNamespace();
+        message.denom = object.denom ?? "";
+        message.wasmHook = object.wasmHook ?? "";
+        message.mintsPaused = object.mintsPaused ?? false;
+        message.sendsPaused = object.sendsPaused ?? false;
+        message.burnsPaused = object.burnsPaused ?? false;
+        message.rolePermissions = object.rolePermissions?.map(e => Role.fromPartial(e)) || [];
+        message.addressRoles = object.addressRoles?.map(e => AddressRoles.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseNamespace();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.wasm_hook !== undefined && object.wasm_hook !== null) {
+            message.wasmHook = object.wasm_hook;
+        }
+        if (object.mints_paused !== undefined && object.mints_paused !== null) {
+            message.mintsPaused = object.mints_paused;
+        }
+        if (object.sends_paused !== undefined && object.sends_paused !== null) {
+            message.sendsPaused = object.sends_paused;
+        }
+        if (object.burns_paused !== undefined && object.burns_paused !== null) {
+            message.burnsPaused = object.burns_paused;
+        }
+        message.rolePermissions = object.role_permissions?.map(e => Role.fromAmino(e)) || [];
+        message.addressRoles = object.address_roles?.map(e => AddressRoles.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        obj.wasm_hook = message.wasmHook === "" ? undefined : message.wasmHook;
+        obj.mints_paused = message.mintsPaused === false ? undefined : message.mintsPaused;
+        obj.sends_paused = message.sendsPaused === false ? undefined : message.sendsPaused;
+        obj.burns_paused = message.burnsPaused === false ? undefined : message.burnsPaused;
+        if (message.rolePermissions) {
+            obj.role_permissions = message.rolePermissions.map(e => e ? Role.toAmino(e) : undefined);
+        }
+        else {
+            obj.role_permissions = message.rolePermissions;
+        }
+        if (message.addressRoles) {
+            obj.address_roles = message.addressRoles.map(e => e ? AddressRoles.toAmino(e) : undefined);
+        }
+        else {
+            obj.address_roles = message.addressRoles;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Namespace.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Namespace.decode(message.value);
+    },
+    toProto(message) {
+        return Namespace.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.Namespace",
+            value: Namespace.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Namespace.typeUrl, Namespace);
+function createBaseAddressRoles() {
+    return {
+        address: "",
+        roles: []
+    };
+}
+export const AddressRoles = {
+    typeUrl: "/injective.permissions.v1beta1.AddressRoles",
+    is(o) {
+        return o && (o.$typeUrl === AddressRoles.typeUrl || typeof o.address === "string" && Array.isArray(o.roles) && (!o.roles.length || typeof o.roles[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === AddressRoles.typeUrl || typeof o.address === "string" && Array.isArray(o.roles) && (!o.roles.length || typeof o.roles[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        for (const v of message.roles) {
+            writer.uint32(18).string(v);
+        }
+        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 = createBaseAddressRoles();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.roles.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAddressRoles();
+        message.address = object.address ?? "";
+        message.roles = object.roles?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAddressRoles();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        message.roles = object.roles?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        if (message.roles) {
+            obj.roles = message.roles.map(e => e);
+        }
+        else {
+            obj.roles = message.roles;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return AddressRoles.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return AddressRoles.decode(message.value);
+    },
+    toProto(message) {
+        return AddressRoles.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.AddressRoles",
+            value: AddressRoles.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(AddressRoles.typeUrl, AddressRoles);
+function createBaseRole() {
+    return {
+        role: "",
+        permissions: 0
+    };
+}
+export const Role = {
+    typeUrl: "/injective.permissions.v1beta1.Role",
+    is(o) {
+        return o && (o.$typeUrl === Role.typeUrl || typeof o.role === "string" && typeof o.permissions === "number");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Role.typeUrl || typeof o.role === "string" && typeof o.permissions === "number");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.role !== "") {
+            writer.uint32(10).string(message.role);
+        }
+        if (message.permissions !== 0) {
+            writer.uint32(16).uint32(message.permissions);
+        }
+        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 = createBaseRole();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.role = reader.string();
+                    break;
+                case 2:
+                    message.permissions = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRole();
+        message.role = object.role ?? "";
+        message.permissions = object.permissions ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRole();
+        if (object.role !== undefined && object.role !== null) {
+            message.role = object.role;
+        }
+        if (object.permissions !== undefined && object.permissions !== null) {
+            message.permissions = object.permissions;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.role = message.role === "" ? undefined : message.role;
+        obj.permissions = message.permissions === 0 ? undefined : message.permissions;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Role.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Role.decode(message.value);
+    },
+    toProto(message) {
+        return Role.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.Role",
+            value: Role.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Role.typeUrl, Role);
+function createBaseRoleIDs() {
+    return {
+        roleIds: []
+    };
+}
+export const RoleIDs = {
+    typeUrl: "/injective.permissions.v1beta1.RoleIDs",
+    is(o) {
+        return o && (o.$typeUrl === RoleIDs.typeUrl || Array.isArray(o.roleIds) && (!o.roleIds.length || typeof o.roleIds[0] === "number"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === RoleIDs.typeUrl || Array.isArray(o.role_ids) && (!o.role_ids.length || typeof o.role_ids[0] === "number"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.roleIds) {
+            writer.uint32(v);
+        }
+        writer.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 = createBaseRoleIDs();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.roleIds.push(reader.uint32());
+                        }
+                    }
+                    else {
+                        message.roleIds.push(reader.uint32());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRoleIDs();
+        message.roleIds = object.roleIds?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRoleIDs();
+        message.roleIds = object.role_ids?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.roleIds) {
+            obj.role_ids = message.roleIds.map(e => e);
+        }
+        else {
+            obj.role_ids = message.roleIds;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RoleIDs.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return RoleIDs.decode(message.value);
+    },
+    toProto(message) {
+        return RoleIDs.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.RoleIDs",
+            value: RoleIDs.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(RoleIDs.typeUrl, RoleIDs);
+function createBaseVoucher() {
+    return {
+        coins: []
+    };
+}
+export const Voucher = {
+    typeUrl: "/injective.permissions.v1beta1.Voucher",
+    is(o) {
+        return o && (o.$typeUrl === Voucher.typeUrl || Array.isArray(o.coins) && (!o.coins.length || Coin.is(o.coins[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Voucher.typeUrl || Array.isArray(o.coins) && (!o.coins.length || Coin.isAmino(o.coins[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.coins) {
+            Coin.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 = createBaseVoucher();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.coins.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseVoucher();
+        message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseVoucher();
+        message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.coins) {
+            obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.coins = message.coins;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Voucher.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Voucher.decode(message.value);
+    },
+    toProto(message) {
+        return Voucher.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.Voucher",
+            value: Voucher.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Voucher.typeUrl, Voucher);
+function createBaseAddressVoucher() {
+    return {
+        address: "",
+        voucher: undefined
+    };
+}
+export const AddressVoucher = {
+    typeUrl: "/injective.permissions.v1beta1.AddressVoucher",
+    is(o) {
+        return o && (o.$typeUrl === AddressVoucher.typeUrl || typeof o.address === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === AddressVoucher.typeUrl || typeof o.address === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.voucher !== undefined) {
+            Voucher.encode(message.voucher, 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 = createBaseAddressVoucher();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.voucher = Voucher.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAddressVoucher();
+        message.address = object.address ?? "";
+        message.voucher = object.voucher !== undefined && object.voucher !== null ? Voucher.fromPartial(object.voucher) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAddressVoucher();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.voucher !== undefined && object.voucher !== null) {
+            message.voucher = Voucher.fromAmino(object.voucher);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.voucher = message.voucher ? Voucher.toAmino(message.voucher) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return AddressVoucher.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return AddressVoucher.decode(message.value);
+    },
+    toProto(message) {
+        return AddressVoucher.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.AddressVoucher",
+            value: AddressVoucher.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(AddressVoucher.typeUrl, AddressVoucher);