@iconlake/client 0.1.2 → 0.1.3

package/dist/cosmos.staking.v1beta1/types/cosmos/query/v1/query.js

@@ -1,2 +0,0 @@
-/* eslint-disable */
-export const protobufPackage = "cosmos.query.v1";

package/dist/cosmos.staking.v1beta1/types/cosmos/staking/v1beta1/authz.js

@@ -1,184 +0,0 @@
-/* eslint-disable */
-import _m0 from "protobufjs/minimal";
-import { Coin } from "../../base/v1beta1/coin";
-export const protobufPackage = "cosmos.staking.v1beta1";
-/**
- * AuthorizationType defines the type of staking module authorization type
- *
- * Since: cosmos-sdk 0.43
- */
-export var AuthorizationType;
-(function (AuthorizationType) {
-    /** AUTHORIZATION_TYPE_UNSPECIFIED - AUTHORIZATION_TYPE_UNSPECIFIED specifies an unknown authorization type */
-    AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_UNSPECIFIED"] = 0] = "AUTHORIZATION_TYPE_UNSPECIFIED";
-    /** AUTHORIZATION_TYPE_DELEGATE - AUTHORIZATION_TYPE_DELEGATE defines an authorization type for Msg/Delegate */
-    AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_DELEGATE"] = 1] = "AUTHORIZATION_TYPE_DELEGATE";
-    /** AUTHORIZATION_TYPE_UNDELEGATE - AUTHORIZATION_TYPE_UNDELEGATE defines an authorization type for Msg/Undelegate */
-    AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_UNDELEGATE"] = 2] = "AUTHORIZATION_TYPE_UNDELEGATE";
-    /** AUTHORIZATION_TYPE_REDELEGATE - AUTHORIZATION_TYPE_REDELEGATE defines an authorization type for Msg/BeginRedelegate */
-    AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_REDELEGATE"] = 3] = "AUTHORIZATION_TYPE_REDELEGATE";
-    AuthorizationType[AuthorizationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(AuthorizationType || (AuthorizationType = {}));
-export function authorizationTypeFromJSON(object) {
-    switch (object) {
-        case 0:
-        case "AUTHORIZATION_TYPE_UNSPECIFIED":
-            return AuthorizationType.AUTHORIZATION_TYPE_UNSPECIFIED;
-        case 1:
-        case "AUTHORIZATION_TYPE_DELEGATE":
-            return AuthorizationType.AUTHORIZATION_TYPE_DELEGATE;
-        case 2:
-        case "AUTHORIZATION_TYPE_UNDELEGATE":
-            return AuthorizationType.AUTHORIZATION_TYPE_UNDELEGATE;
-        case 3:
-        case "AUTHORIZATION_TYPE_REDELEGATE":
-            return AuthorizationType.AUTHORIZATION_TYPE_REDELEGATE;
-        case -1:
-        case "UNRECOGNIZED":
-        default:
-            return AuthorizationType.UNRECOGNIZED;
-    }
-}
-export function authorizationTypeToJSON(object) {
-    switch (object) {
-        case AuthorizationType.AUTHORIZATION_TYPE_UNSPECIFIED:
-            return "AUTHORIZATION_TYPE_UNSPECIFIED";
-        case AuthorizationType.AUTHORIZATION_TYPE_DELEGATE:
-            return "AUTHORIZATION_TYPE_DELEGATE";
-        case AuthorizationType.AUTHORIZATION_TYPE_UNDELEGATE:
-            return "AUTHORIZATION_TYPE_UNDELEGATE";
-        case AuthorizationType.AUTHORIZATION_TYPE_REDELEGATE:
-            return "AUTHORIZATION_TYPE_REDELEGATE";
-        case AuthorizationType.UNRECOGNIZED:
-        default:
-            return "UNRECOGNIZED";
-    }
-}
-function createBaseStakeAuthorization() {
-    return { maxTokens: undefined, allowList: undefined, denyList: undefined, authorizationType: 0 };
-}
-export const StakeAuthorization = {
-    encode(message, writer = _m0.Writer.create()) {
-        if (message.maxTokens !== undefined) {
-            Coin.encode(message.maxTokens, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.allowList !== undefined) {
-            StakeAuthorization_Validators.encode(message.allowList, writer.uint32(18).fork()).ldelim();
-        }
-        if (message.denyList !== undefined) {
-            StakeAuthorization_Validators.encode(message.denyList, writer.uint32(26).fork()).ldelim();
-        }
-        if (message.authorizationType !== 0) {
-            writer.uint32(32).int32(message.authorizationType);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseStakeAuthorization();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.maxTokens = Coin.decode(reader, reader.uint32());
-                    break;
-                case 2:
-                    message.allowList = StakeAuthorization_Validators.decode(reader, reader.uint32());
-                    break;
-                case 3:
-                    message.denyList = StakeAuthorization_Validators.decode(reader, reader.uint32());
-                    break;
-                case 4:
-                    message.authorizationType = reader.int32();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            maxTokens: isSet(object.maxTokens) ? Coin.fromJSON(object.maxTokens) : undefined,
-            allowList: isSet(object.allowList) ? StakeAuthorization_Validators.fromJSON(object.allowList) : undefined,
-            denyList: isSet(object.denyList) ? StakeAuthorization_Validators.fromJSON(object.denyList) : undefined,
-            authorizationType: isSet(object.authorizationType) ? authorizationTypeFromJSON(object.authorizationType) : 0,
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        message.maxTokens !== undefined && (obj.maxTokens = message.maxTokens ? Coin.toJSON(message.maxTokens) : undefined);
-        message.allowList !== undefined
-            && (obj.allowList = message.allowList ? StakeAuthorization_Validators.toJSON(message.allowList) : undefined);
-        message.denyList !== undefined
-            && (obj.denyList = message.denyList ? StakeAuthorization_Validators.toJSON(message.denyList) : undefined);
-        message.authorizationType !== undefined
-            && (obj.authorizationType = authorizationTypeToJSON(message.authorizationType));
-        return obj;
-    },
-    fromPartial(object) {
-        const message = createBaseStakeAuthorization();
-        message.maxTokens = (object.maxTokens !== undefined && object.maxTokens !== null)
-            ? Coin.fromPartial(object.maxTokens)
-            : undefined;
-        message.allowList = (object.allowList !== undefined && object.allowList !== null)
-            ? StakeAuthorization_Validators.fromPartial(object.allowList)
-            : undefined;
-        message.denyList = (object.denyList !== undefined && object.denyList !== null)
-            ? StakeAuthorization_Validators.fromPartial(object.denyList)
-            : undefined;
-        message.authorizationType = object.authorizationType ?? 0;
-        return message;
-    },
-};
-function createBaseStakeAuthorization_Validators() {
-    return { address: [] };
-}
-export const StakeAuthorization_Validators = {
-    encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.address) {
-            writer.uint32(10).string(v);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseStakeAuthorization_Validators();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.address.push(reader.string());
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return { address: Array.isArray(object?.address) ? object.address.map((e) => String(e)) : [] };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.address) {
-            obj.address = message.address.map((e) => e);
-        }
-        else {
-            obj.address = [];
-        }
-        return obj;
-    },
-    fromPartial(object) {
-        const message = createBaseStakeAuthorization_Validators();
-        message.address = object.address?.map((e) => e) || [];
-        return message;
-    },
-};
-function isSet(value) {
-    return value !== null && value !== undefined;
-}

package/dist/cosmos.staking.v1beta1/types/cosmos/staking/v1beta1/genesis.js

@@ -1,259 +0,0 @@
-/* eslint-disable */
-import Long from "long";
-import _m0 from "protobufjs/minimal";
-import { Delegation, Params, Redelegation, UnbondingDelegation, Validator } from "./staking";
-export const protobufPackage = "cosmos.staking.v1beta1";
-function createBaseGenesisState() {
-    return {
-        params: undefined,
-        lastTotalPower: new Uint8Array(),
-        lastValidatorPowers: [],
-        validators: [],
-        delegations: [],
-        unbondingDelegations: [],
-        redelegations: [],
-        exported: false,
-    };
-}
-export const GenesisState = {
-    encode(message, writer = _m0.Writer.create()) {
-        if (message.params !== undefined) {
-            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.lastTotalPower.length !== 0) {
-            writer.uint32(18).bytes(message.lastTotalPower);
-        }
-        for (const v of message.lastValidatorPowers) {
-            LastValidatorPower.encode(v, writer.uint32(26).fork()).ldelim();
-        }
-        for (const v of message.validators) {
-            Validator.encode(v, writer.uint32(34).fork()).ldelim();
-        }
-        for (const v of message.delegations) {
-            Delegation.encode(v, writer.uint32(42).fork()).ldelim();
-        }
-        for (const v of message.unbondingDelegations) {
-            UnbondingDelegation.encode(v, writer.uint32(50).fork()).ldelim();
-        }
-        for (const v of message.redelegations) {
-            Redelegation.encode(v, writer.uint32(58).fork()).ldelim();
-        }
-        if (message.exported === true) {
-            writer.uint32(64).bool(message.exported);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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.params = Params.decode(reader, reader.uint32());
-                    break;
-                case 2:
-                    message.lastTotalPower = reader.bytes();
-                    break;
-                case 3:
-                    message.lastValidatorPowers.push(LastValidatorPower.decode(reader, reader.uint32()));
-                    break;
-                case 4:
-                    message.validators.push(Validator.decode(reader, reader.uint32()));
-                    break;
-                case 5:
-                    message.delegations.push(Delegation.decode(reader, reader.uint32()));
-                    break;
-                case 6:
-                    message.unbondingDelegations.push(UnbondingDelegation.decode(reader, reader.uint32()));
-                    break;
-                case 7:
-                    message.redelegations.push(Redelegation.decode(reader, reader.uint32()));
-                    break;
-                case 8:
-                    message.exported = reader.bool();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            params: isSet(object.params) ? Params.fromJSON(object.params) : undefined,
-            lastTotalPower: isSet(object.lastTotalPower) ? bytesFromBase64(object.lastTotalPower) : new Uint8Array(),
-            lastValidatorPowers: Array.isArray(object?.lastValidatorPowers)
-                ? object.lastValidatorPowers.map((e) => LastValidatorPower.fromJSON(e))
-                : [],
-            validators: Array.isArray(object?.validators) ? object.validators.map((e) => Validator.fromJSON(e)) : [],
-            delegations: Array.isArray(object?.delegations) ? object.delegations.map((e) => Delegation.fromJSON(e)) : [],
-            unbondingDelegations: Array.isArray(object?.unbondingDelegations)
-                ? object.unbondingDelegations.map((e) => UnbondingDelegation.fromJSON(e))
-                : [],
-            redelegations: Array.isArray(object?.redelegations)
-                ? object.redelegations.map((e) => Redelegation.fromJSON(e))
-                : [],
-            exported: isSet(object.exported) ? Boolean(object.exported) : false,
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined);
-        message.lastTotalPower !== undefined
-            && (obj.lastTotalPower = base64FromBytes(message.lastTotalPower !== undefined ? message.lastTotalPower : new Uint8Array()));
-        if (message.lastValidatorPowers) {
-            obj.lastValidatorPowers = message.lastValidatorPowers.map((e) => e ? LastValidatorPower.toJSON(e) : undefined);
-        }
-        else {
-            obj.lastValidatorPowers = [];
-        }
-        if (message.validators) {
-            obj.validators = message.validators.map((e) => e ? Validator.toJSON(e) : undefined);
-        }
-        else {
-            obj.validators = [];
-        }
-        if (message.delegations) {
-            obj.delegations = message.delegations.map((e) => e ? Delegation.toJSON(e) : undefined);
-        }
-        else {
-            obj.delegations = [];
-        }
-        if (message.unbondingDelegations) {
-            obj.unbondingDelegations = message.unbondingDelegations.map((e) => e ? UnbondingDelegation.toJSON(e) : undefined);
-        }
-        else {
-            obj.unbondingDelegations = [];
-        }
-        if (message.redelegations) {
-            obj.redelegations = message.redelegations.map((e) => e ? Redelegation.toJSON(e) : undefined);
-        }
-        else {
-            obj.redelegations = [];
-        }
-        message.exported !== undefined && (obj.exported = message.exported);
-        return obj;
-    },
-    fromPartial(object) {
-        const message = createBaseGenesisState();
-        message.params = (object.params !== undefined && object.params !== null)
-            ? Params.fromPartial(object.params)
-            : undefined;
-        message.lastTotalPower = object.lastTotalPower ?? new Uint8Array();
-        message.lastValidatorPowers = object.lastValidatorPowers?.map((e) => LastValidatorPower.fromPartial(e)) || [];
-        message.validators = object.validators?.map((e) => Validator.fromPartial(e)) || [];
-        message.delegations = object.delegations?.map((e) => Delegation.fromPartial(e)) || [];
-        message.unbondingDelegations = object.unbondingDelegations?.map((e) => UnbondingDelegation.fromPartial(e)) || [];
-        message.redelegations = object.redelegations?.map((e) => Redelegation.fromPartial(e)) || [];
-        message.exported = object.exported ?? false;
-        return message;
-    },
-};
-function createBaseLastValidatorPower() {
-    return { address: "", power: 0 };
-}
-export const LastValidatorPower = {
-    encode(message, writer = _m0.Writer.create()) {
-        if (message.address !== "") {
-            writer.uint32(10).string(message.address);
-        }
-        if (message.power !== 0) {
-            writer.uint32(16).int64(message.power);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseLastValidatorPower();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.address = reader.string();
-                    break;
-                case 2:
-                    message.power = longToNumber(reader.int64());
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            address: isSet(object.address) ? String(object.address) : "",
-            power: isSet(object.power) ? Number(object.power) : 0,
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        message.address !== undefined && (obj.address = message.address);
-        message.power !== undefined && (obj.power = Math.round(message.power));
-        return obj;
-    },
-    fromPartial(object) {
-        const message = createBaseLastValidatorPower();
-        message.address = object.address ?? "";
-        message.power = object.power ?? 0;
-        return message;
-    },
-};
-var globalThis = (() => {
-    if (typeof globalThis !== "undefined") {
-        return globalThis;
-    }
-    if (typeof self !== "undefined") {
-        return self;
-    }
-    if (typeof window !== "undefined") {
-        return window;
-    }
-    if (typeof global !== "undefined") {
-        return global;
-    }
-    throw "Unable to locate global object";
-})();
-function bytesFromBase64(b64) {
-    if (globalThis.Buffer) {
-        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-    }
-    else {
-        const bin = globalThis.atob(b64);
-        const arr = new Uint8Array(bin.length);
-        for (let i = 0; i < bin.length; ++i) {
-            arr[i] = bin.charCodeAt(i);
-        }
-        return arr;
-    }
-}
-function base64FromBytes(arr) {
-    if (globalThis.Buffer) {
-        return globalThis.Buffer.from(arr).toString("base64");
-    }
-    else {
-        const bin = [];
-        arr.forEach((byte) => {
-            bin.push(String.fromCharCode(byte));
-        });
-        return globalThis.btoa(bin.join(""));
-    }
-}
-function longToNumber(long) {
-    if (long.gt(Number.MAX_SAFE_INTEGER)) {
-        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
-    }
-    return long.toNumber();
-}
-if (_m0.util.Long !== Long) {
-    _m0.util.Long = Long;
-    _m0.configure();
-}
-function isSet(value) {
-    return value !== null && value !== undefined;
-}