@super-protocol/sdk-js 0.10.2-beta.4 → 0.10.6-beta.0

package/build/proto/TeeProperties.d.ts

@@ -0,0 +1,263 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "";
+export interface Cpus {
+    vendorId: string;
+    cpuFamily: number;
+    model: number;
+    modelName: string;
+    physicalCores: number;
+    logicalCores: number;
+    baseFreq: number;
+    maxFreq: number;
+}
+export interface TeeDeviceInfo {
+    cpus: Cpus[];
+    memSize: number;
+    totalPhysicalCores: number;
+    totalLogicalCores: number;
+}
+export interface TeeRunCpuBenchmark {
+    cpuScore: number;
+    cpuBenchmark: string;
+    cpuCoresCount: number;
+}
+export interface TeeRunMemoryBenchmark {
+    memBandwidth: number;
+    meConfirmedSize: number;
+}
+export interface TeeProperties {
+    teeDeviceInfo: TeeDeviceInfo | undefined;
+    teeRunCpuBenchmark: TeeRunCpuBenchmark | undefined;
+    teeRunMemoryBenchmark: TeeRunMemoryBenchmark | undefined;
+}
+export declare const Cpus: {
+    encode(message: Cpus, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Cpus;
+    fromJSON(object: any): Cpus;
+    toJSON(message: Cpus): unknown;
+    fromPartial<I extends {
+        vendorId?: string | undefined;
+        cpuFamily?: number | undefined;
+        model?: number | undefined;
+        modelName?: string | undefined;
+        physicalCores?: number | undefined;
+        logicalCores?: number | undefined;
+        baseFreq?: number | undefined;
+        maxFreq?: number | undefined;
+    } & {
+        vendorId?: string | undefined;
+        cpuFamily?: number | undefined;
+        model?: number | undefined;
+        modelName?: string | undefined;
+        physicalCores?: number | undefined;
+        logicalCores?: number | undefined;
+        baseFreq?: number | undefined;
+        maxFreq?: number | undefined;
+    } & { [K in Exclude<keyof I, keyof Cpus>]: never; }>(object: I): Cpus;
+};
+export declare const TeeDeviceInfo: {
+    encode(message: TeeDeviceInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TeeDeviceInfo;
+    fromJSON(object: any): TeeDeviceInfo;
+    toJSON(message: TeeDeviceInfo): unknown;
+    fromPartial<I extends {
+        cpus?: {
+            vendorId?: string | undefined;
+            cpuFamily?: number | undefined;
+            model?: number | undefined;
+            modelName?: string | undefined;
+            physicalCores?: number | undefined;
+            logicalCores?: number | undefined;
+            baseFreq?: number | undefined;
+            maxFreq?: number | undefined;
+        }[] | undefined;
+        memSize?: number | undefined;
+        totalPhysicalCores?: number | undefined;
+        totalLogicalCores?: number | undefined;
+    } & {
+        cpus?: ({
+            vendorId?: string | undefined;
+            cpuFamily?: number | undefined;
+            model?: number | undefined;
+            modelName?: string | undefined;
+            physicalCores?: number | undefined;
+            logicalCores?: number | undefined;
+            baseFreq?: number | undefined;
+            maxFreq?: number | undefined;
+        }[] & ({
+            vendorId?: string | undefined;
+            cpuFamily?: number | undefined;
+            model?: number | undefined;
+            modelName?: string | undefined;
+            physicalCores?: number | undefined;
+            logicalCores?: number | undefined;
+            baseFreq?: number | undefined;
+            maxFreq?: number | undefined;
+        } & {
+            vendorId?: string | undefined;
+            cpuFamily?: number | undefined;
+            model?: number | undefined;
+            modelName?: string | undefined;
+            physicalCores?: number | undefined;
+            logicalCores?: number | undefined;
+            baseFreq?: number | undefined;
+            maxFreq?: number | undefined;
+        } & { [K in Exclude<keyof I["cpus"][number], keyof Cpus>]: never; })[] & { [K_1 in Exclude<keyof I["cpus"], keyof {
+            vendorId?: string | undefined;
+            cpuFamily?: number | undefined;
+            model?: number | undefined;
+            modelName?: string | undefined;
+            physicalCores?: number | undefined;
+            logicalCores?: number | undefined;
+            baseFreq?: number | undefined;
+            maxFreq?: number | undefined;
+        }[]>]: never; }) | undefined;
+        memSize?: number | undefined;
+        totalPhysicalCores?: number | undefined;
+        totalLogicalCores?: number | undefined;
+    } & { [K_2 in Exclude<keyof I, keyof TeeDeviceInfo>]: never; }>(object: I): TeeDeviceInfo;
+};
+export declare const TeeRunCpuBenchmark: {
+    encode(message: TeeRunCpuBenchmark, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TeeRunCpuBenchmark;
+    fromJSON(object: any): TeeRunCpuBenchmark;
+    toJSON(message: TeeRunCpuBenchmark): unknown;
+    fromPartial<I extends {
+        cpuScore?: number | undefined;
+        cpuBenchmark?: string | undefined;
+        cpuCoresCount?: number | undefined;
+    } & {
+        cpuScore?: number | undefined;
+        cpuBenchmark?: string | undefined;
+        cpuCoresCount?: number | undefined;
+    } & { [K in Exclude<keyof I, keyof TeeRunCpuBenchmark>]: never; }>(object: I): TeeRunCpuBenchmark;
+};
+export declare const TeeRunMemoryBenchmark: {
+    encode(message: TeeRunMemoryBenchmark, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TeeRunMemoryBenchmark;
+    fromJSON(object: any): TeeRunMemoryBenchmark;
+    toJSON(message: TeeRunMemoryBenchmark): unknown;
+    fromPartial<I extends {
+        memBandwidth?: number | undefined;
+        meConfirmedSize?: number | undefined;
+    } & {
+        memBandwidth?: number | undefined;
+        meConfirmedSize?: number | undefined;
+    } & { [K in Exclude<keyof I, keyof TeeRunMemoryBenchmark>]: never; }>(object: I): TeeRunMemoryBenchmark;
+};
+export declare const TeeProperties: {
+    encode(message: TeeProperties, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TeeProperties;
+    fromJSON(object: any): TeeProperties;
+    toJSON(message: TeeProperties): unknown;
+    fromPartial<I extends {
+        teeDeviceInfo?: {
+            cpus?: {
+                vendorId?: string | undefined;
+                cpuFamily?: number | undefined;
+                model?: number | undefined;
+                modelName?: string | undefined;
+                physicalCores?: number | undefined;
+                logicalCores?: number | undefined;
+                baseFreq?: number | undefined;
+                maxFreq?: number | undefined;
+            }[] | undefined;
+            memSize?: number | undefined;
+            totalPhysicalCores?: number | undefined;
+            totalLogicalCores?: number | undefined;
+        } | undefined;
+        teeRunCpuBenchmark?: {
+            cpuScore?: number | undefined;
+            cpuBenchmark?: string | undefined;
+            cpuCoresCount?: number | undefined;
+        } | undefined;
+        teeRunMemoryBenchmark?: {
+            memBandwidth?: number | undefined;
+            meConfirmedSize?: number | undefined;
+        } | undefined;
+    } & {
+        teeDeviceInfo?: ({
+            cpus?: {
+                vendorId?: string | undefined;
+                cpuFamily?: number | undefined;
+                model?: number | undefined;
+                modelName?: string | undefined;
+                physicalCores?: number | undefined;
+                logicalCores?: number | undefined;
+                baseFreq?: number | undefined;
+                maxFreq?: number | undefined;
+            }[] | undefined;
+            memSize?: number | undefined;
+            totalPhysicalCores?: number | undefined;
+            totalLogicalCores?: number | undefined;
+        } & {
+            cpus?: ({
+                vendorId?: string | undefined;
+                cpuFamily?: number | undefined;
+                model?: number | undefined;
+                modelName?: string | undefined;
+                physicalCores?: number | undefined;
+                logicalCores?: number | undefined;
+                baseFreq?: number | undefined;
+                maxFreq?: number | undefined;
+            }[] & ({
+                vendorId?: string | undefined;
+                cpuFamily?: number | undefined;
+                model?: number | undefined;
+                modelName?: string | undefined;
+                physicalCores?: number | undefined;
+                logicalCores?: number | undefined;
+                baseFreq?: number | undefined;
+                maxFreq?: number | undefined;
+            } & {
+                vendorId?: string | undefined;
+                cpuFamily?: number | undefined;
+                model?: number | undefined;
+                modelName?: string | undefined;
+                physicalCores?: number | undefined;
+                logicalCores?: number | undefined;
+                baseFreq?: number | undefined;
+                maxFreq?: number | undefined;
+            } & { [K in Exclude<keyof I["teeDeviceInfo"]["cpus"][number], keyof Cpus>]: never; })[] & { [K_1 in Exclude<keyof I["teeDeviceInfo"]["cpus"], keyof {
+                vendorId?: string | undefined;
+                cpuFamily?: number | undefined;
+                model?: number | undefined;
+                modelName?: string | undefined;
+                physicalCores?: number | undefined;
+                logicalCores?: number | undefined;
+                baseFreq?: number | undefined;
+                maxFreq?: number | undefined;
+            }[]>]: never; }) | undefined;
+            memSize?: number | undefined;
+            totalPhysicalCores?: number | undefined;
+            totalLogicalCores?: number | undefined;
+        } & { [K_2 in Exclude<keyof I["teeDeviceInfo"], keyof TeeDeviceInfo>]: never; }) | undefined;
+        teeRunCpuBenchmark?: ({
+            cpuScore?: number | undefined;
+            cpuBenchmark?: string | undefined;
+            cpuCoresCount?: number | undefined;
+        } & {
+            cpuScore?: number | undefined;
+            cpuBenchmark?: string | undefined;
+            cpuCoresCount?: number | undefined;
+        } & { [K_3 in Exclude<keyof I["teeRunCpuBenchmark"], keyof TeeRunCpuBenchmark>]: never; }) | undefined;
+        teeRunMemoryBenchmark?: ({
+            memBandwidth?: number | undefined;
+            meConfirmedSize?: number | undefined;
+        } & {
+            memBandwidth?: number | undefined;
+            meConfirmedSize?: number | undefined;
+        } & { [K_4 in Exclude<keyof I["teeRunMemoryBenchmark"], keyof TeeRunMemoryBenchmark>]: never; }) | undefined;
+    } & { [K_5 in Exclude<keyof I, keyof TeeProperties>]: never; }>(object: I): TeeProperties;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+declare type KeysOfUnion<T> = T extends T ? keyof T : never;
+export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/build/proto/TeeProperties.js

@@ -0,0 +1,406 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeeProperties = exports.TeeRunMemoryBenchmark = exports.TeeRunCpuBenchmark = exports.TeeDeviceInfo = exports.Cpus = exports.protobufPackage = void 0;
+/* eslint-disable */
+var minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "";
+function createBaseCpus() {
+    return {
+        vendorId: "",
+        cpuFamily: 0,
+        model: 0,
+        modelName: "",
+        physicalCores: 0,
+        logicalCores: 0,
+        baseFreq: 0,
+        maxFreq: 0,
+    };
+}
+exports.Cpus = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = minimal_1.default.Writer.create(); }
+        if (message.vendorId !== "") {
+            writer.uint32(10).string(message.vendorId);
+        }
+        if (message.cpuFamily !== 0) {
+            writer.uint32(16).int32(message.cpuFamily);
+        }
+        if (message.model !== 0) {
+            writer.uint32(24).int32(message.model);
+        }
+        if (message.modelName !== "") {
+            writer.uint32(34).string(message.modelName);
+        }
+        if (message.physicalCores !== 0) {
+            writer.uint32(40).int32(message.physicalCores);
+        }
+        if (message.logicalCores !== 0) {
+            writer.uint32(48).int32(message.logicalCores);
+        }
+        if (message.baseFreq !== 0) {
+            writer.uint32(56).int32(message.baseFreq);
+        }
+        if (message.maxFreq !== 0) {
+            writer.uint32(64).int32(message.maxFreq);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseCpus();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.vendorId = reader.string();
+                    break;
+                case 2:
+                    message.cpuFamily = reader.int32();
+                    break;
+                case 3:
+                    message.model = reader.int32();
+                    break;
+                case 4:
+                    message.modelName = reader.string();
+                    break;
+                case 5:
+                    message.physicalCores = reader.int32();
+                    break;
+                case 6:
+                    message.logicalCores = reader.int32();
+                    break;
+                case 7:
+                    message.baseFreq = reader.int32();
+                    break;
+                case 8:
+                    message.maxFreq = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            vendorId: isSet(object.vendorId) ? String(object.vendorId) : "",
+            cpuFamily: isSet(object.cpuFamily) ? Number(object.cpuFamily) : 0,
+            model: isSet(object.model) ? Number(object.model) : 0,
+            modelName: isSet(object.modelName) ? String(object.modelName) : "",
+            physicalCores: isSet(object.physicalCores) ? Number(object.physicalCores) : 0,
+            logicalCores: isSet(object.logicalCores) ? Number(object.logicalCores) : 0,
+            baseFreq: isSet(object.baseFreq) ? Number(object.baseFreq) : 0,
+            maxFreq: isSet(object.maxFreq) ? Number(object.maxFreq) : 0,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.vendorId !== undefined && (obj.vendorId = message.vendorId);
+        message.cpuFamily !== undefined && (obj.cpuFamily = Math.round(message.cpuFamily));
+        message.model !== undefined && (obj.model = Math.round(message.model));
+        message.modelName !== undefined && (obj.modelName = message.modelName);
+        message.physicalCores !== undefined && (obj.physicalCores = Math.round(message.physicalCores));
+        message.logicalCores !== undefined && (obj.logicalCores = Math.round(message.logicalCores));
+        message.baseFreq !== undefined && (obj.baseFreq = Math.round(message.baseFreq));
+        message.maxFreq !== undefined && (obj.maxFreq = Math.round(message.maxFreq));
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var message = createBaseCpus();
+        message.vendorId = (_a = object.vendorId) !== null && _a !== void 0 ? _a : "";
+        message.cpuFamily = (_b = object.cpuFamily) !== null && _b !== void 0 ? _b : 0;
+        message.model = (_c = object.model) !== null && _c !== void 0 ? _c : 0;
+        message.modelName = (_d = object.modelName) !== null && _d !== void 0 ? _d : "";
+        message.physicalCores = (_e = object.physicalCores) !== null && _e !== void 0 ? _e : 0;
+        message.logicalCores = (_f = object.logicalCores) !== null && _f !== void 0 ? _f : 0;
+        message.baseFreq = (_g = object.baseFreq) !== null && _g !== void 0 ? _g : 0;
+        message.maxFreq = (_h = object.maxFreq) !== null && _h !== void 0 ? _h : 0;
+        return message;
+    },
+};
+function createBaseTeeDeviceInfo() {
+    return { cpus: [], memSize: 0, totalPhysicalCores: 0, totalLogicalCores: 0 };
+}
+exports.TeeDeviceInfo = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = minimal_1.default.Writer.create(); }
+        for (var _i = 0, _a = message.cpus; _i < _a.length; _i++) {
+            var v = _a[_i];
+            exports.Cpus.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.memSize !== 0) {
+            writer.uint32(16).int32(message.memSize);
+        }
+        if (message.totalPhysicalCores !== 0) {
+            writer.uint32(24).int32(message.totalPhysicalCores);
+        }
+        if (message.totalLogicalCores !== 0) {
+            writer.uint32(32).int32(message.totalLogicalCores);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseTeeDeviceInfo();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.cpus.push(exports.Cpus.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.memSize = reader.int32();
+                    break;
+                case 3:
+                    message.totalPhysicalCores = reader.int32();
+                    break;
+                case 4:
+                    message.totalLogicalCores = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            cpus: Array.isArray(object === null || object === void 0 ? void 0 : object.cpus) ? object.cpus.map(function (e) { return exports.Cpus.fromJSON(e); }) : [],
+            memSize: isSet(object.memSize) ? Number(object.memSize) : 0,
+            totalPhysicalCores: isSet(object.totalPhysicalCores) ? Number(object.totalPhysicalCores) : 0,
+            totalLogicalCores: isSet(object.totalLogicalCores) ? Number(object.totalLogicalCores) : 0,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        if (message.cpus) {
+            obj.cpus = message.cpus.map(function (e) { return (e ? exports.Cpus.toJSON(e) : undefined); });
+        }
+        else {
+            obj.cpus = [];
+        }
+        message.memSize !== undefined && (obj.memSize = Math.round(message.memSize));
+        message.totalPhysicalCores !== undefined && (obj.totalPhysicalCores = Math.round(message.totalPhysicalCores));
+        message.totalLogicalCores !== undefined && (obj.totalLogicalCores = Math.round(message.totalLogicalCores));
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d;
+        var message = createBaseTeeDeviceInfo();
+        message.cpus = ((_a = object.cpus) === null || _a === void 0 ? void 0 : _a.map(function (e) { return exports.Cpus.fromPartial(e); })) || [];
+        message.memSize = (_b = object.memSize) !== null && _b !== void 0 ? _b : 0;
+        message.totalPhysicalCores = (_c = object.totalPhysicalCores) !== null && _c !== void 0 ? _c : 0;
+        message.totalLogicalCores = (_d = object.totalLogicalCores) !== null && _d !== void 0 ? _d : 0;
+        return message;
+    },
+};
+function createBaseTeeRunCpuBenchmark() {
+    return { cpuScore: 0, cpuBenchmark: "", cpuCoresCount: 0 };
+}
+exports.TeeRunCpuBenchmark = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = minimal_1.default.Writer.create(); }
+        if (message.cpuScore !== 0) {
+            writer.uint32(8).int32(message.cpuScore);
+        }
+        if (message.cpuBenchmark !== "") {
+            writer.uint32(18).string(message.cpuBenchmark);
+        }
+        if (message.cpuCoresCount !== 0) {
+            writer.uint32(24).int32(message.cpuCoresCount);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseTeeRunCpuBenchmark();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.cpuScore = reader.int32();
+                    break;
+                case 2:
+                    message.cpuBenchmark = reader.string();
+                    break;
+                case 3:
+                    message.cpuCoresCount = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            cpuScore: isSet(object.cpuScore) ? Number(object.cpuScore) : 0,
+            cpuBenchmark: isSet(object.cpuBenchmark) ? String(object.cpuBenchmark) : "",
+            cpuCoresCount: isSet(object.cpuCoresCount) ? Number(object.cpuCoresCount) : 0,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.cpuScore !== undefined && (obj.cpuScore = Math.round(message.cpuScore));
+        message.cpuBenchmark !== undefined && (obj.cpuBenchmark = message.cpuBenchmark);
+        message.cpuCoresCount !== undefined && (obj.cpuCoresCount = Math.round(message.cpuCoresCount));
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c;
+        var message = createBaseTeeRunCpuBenchmark();
+        message.cpuScore = (_a = object.cpuScore) !== null && _a !== void 0 ? _a : 0;
+        message.cpuBenchmark = (_b = object.cpuBenchmark) !== null && _b !== void 0 ? _b : "";
+        message.cpuCoresCount = (_c = object.cpuCoresCount) !== null && _c !== void 0 ? _c : 0;
+        return message;
+    },
+};
+function createBaseTeeRunMemoryBenchmark() {
+    return { memBandwidth: 0, meConfirmedSize: 0 };
+}
+exports.TeeRunMemoryBenchmark = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = minimal_1.default.Writer.create(); }
+        if (message.memBandwidth !== 0) {
+            writer.uint32(8).int32(message.memBandwidth);
+        }
+        if (message.meConfirmedSize !== 0) {
+            writer.uint32(16).int32(message.meConfirmedSize);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseTeeRunMemoryBenchmark();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.memBandwidth = reader.int32();
+                    break;
+                case 2:
+                    message.meConfirmedSize = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            memBandwidth: isSet(object.memBandwidth) ? Number(object.memBandwidth) : 0,
+            meConfirmedSize: isSet(object.meConfirmedSize) ? Number(object.meConfirmedSize) : 0,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.memBandwidth !== undefined && (obj.memBandwidth = Math.round(message.memBandwidth));
+        message.meConfirmedSize !== undefined && (obj.meConfirmedSize = Math.round(message.meConfirmedSize));
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b;
+        var message = createBaseTeeRunMemoryBenchmark();
+        message.memBandwidth = (_a = object.memBandwidth) !== null && _a !== void 0 ? _a : 0;
+        message.meConfirmedSize = (_b = object.meConfirmedSize) !== null && _b !== void 0 ? _b : 0;
+        return message;
+    },
+};
+function createBaseTeeProperties() {
+    return { teeDeviceInfo: undefined, teeRunCpuBenchmark: undefined, teeRunMemoryBenchmark: undefined };
+}
+exports.TeeProperties = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = minimal_1.default.Writer.create(); }
+        if (message.teeDeviceInfo !== undefined) {
+            exports.TeeDeviceInfo.encode(message.teeDeviceInfo, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.teeRunCpuBenchmark !== undefined) {
+            exports.TeeRunCpuBenchmark.encode(message.teeRunCpuBenchmark, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.teeRunMemoryBenchmark !== undefined) {
+            exports.TeeRunMemoryBenchmark.encode(message.teeRunMemoryBenchmark, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseTeeProperties();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.teeDeviceInfo = exports.TeeDeviceInfo.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.teeRunCpuBenchmark = exports.TeeRunCpuBenchmark.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.teeRunMemoryBenchmark = exports.TeeRunMemoryBenchmark.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            teeDeviceInfo: isSet(object.teeDeviceInfo) ? exports.TeeDeviceInfo.fromJSON(object.teeDeviceInfo) : undefined,
+            teeRunCpuBenchmark: isSet(object.teeRunCpuBenchmark)
+                ? exports.TeeRunCpuBenchmark.fromJSON(object.teeRunCpuBenchmark)
+                : undefined,
+            teeRunMemoryBenchmark: isSet(object.teeRunMemoryBenchmark)
+                ? exports.TeeRunMemoryBenchmark.fromJSON(object.teeRunMemoryBenchmark)
+                : undefined,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.teeDeviceInfo !== undefined &&
+            (obj.teeDeviceInfo = message.teeDeviceInfo ? exports.TeeDeviceInfo.toJSON(message.teeDeviceInfo) : undefined);
+        message.teeRunCpuBenchmark !== undefined &&
+            (obj.teeRunCpuBenchmark = message.teeRunCpuBenchmark
+                ? exports.TeeRunCpuBenchmark.toJSON(message.teeRunCpuBenchmark)
+                : undefined);
+        message.teeRunMemoryBenchmark !== undefined &&
+            (obj.teeRunMemoryBenchmark = message.teeRunMemoryBenchmark
+                ? exports.TeeRunMemoryBenchmark.toJSON(message.teeRunMemoryBenchmark)
+                : undefined);
+        return obj;
+    },
+    fromPartial: function (object) {
+        var message = createBaseTeeProperties();
+        message.teeDeviceInfo =
+            object.teeDeviceInfo !== undefined && object.teeDeviceInfo !== null
+                ? exports.TeeDeviceInfo.fromPartial(object.teeDeviceInfo)
+                : undefined;
+        message.teeRunCpuBenchmark =
+            object.teeRunCpuBenchmark !== undefined && object.teeRunCpuBenchmark !== null
+                ? exports.TeeRunCpuBenchmark.fromPartial(object.teeRunCpuBenchmark)
+                : undefined;
+        message.teeRunMemoryBenchmark =
+            object.teeRunMemoryBenchmark !== undefined && object.teeRunMemoryBenchmark !== null
+                ? exports.TeeRunMemoryBenchmark.fromPartial(object.teeRunMemoryBenchmark)
+                : undefined;
+        return message;
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/build/store.d.ts

@@ -2,6 +2,7 @@ import Web3 from "web3";
 export declare type Store = {
     isInitialized: boolean;
     web3?: Web3;
+    web3Https?: Web3;
     actionAccount?: string;
     gasLimit: number;
     gasLimitMultiplier: number;

package/build/store.js

@@ -4,6 +4,7 @@ var constants_1 = require("./constants");
 var store = {
     isInitialized: false,
     web3: undefined,
+    web3Https: undefined,
     actionAccount: undefined,
     gasLimit: constants_1.defaultGasLimit,
     gasLimitMultiplier: constants_1.defaultGasLimitMultiplier,