@arcblock/validator 1.16.16 → 1.16.17

package/lib/extension/bn.d.ts

@@ -0,0 +1,96 @@
+import { Root, AnySchema } from 'joi';
+import BN from 'bn.js';
+export interface BNSchema extends AnySchema {
+    min(threshold: any): this;
+    gte(threshold: any): this;
+    max(threshold: any): this;
+    lte(threshold: any): this;
+    greater(threshold: any): this;
+    gt(threshold: any): this;
+    less(threshold: any): this;
+    lt(threshold: any): this;
+    positive(): this;
+    negative(): this;
+}
+export declare function BNExtension(root: Root): {
+    type: string;
+    base: AnySchema<any>;
+    messages: {
+        'bn.nan': string;
+        'bn.max': string;
+        'bn.min': string;
+        'bn.less': string;
+        'bn.greater': string;
+        'bn.positive': string;
+        'bn.negative': string;
+    };
+    prepare(value: any, helpers: any): {
+        value: BN;
+        errors?: undefined;
+    } | {
+        errors: any;
+        value?: undefined;
+    };
+    coerce(value: BN): {
+        value: string;
+    };
+    validate(value: any): {
+        value: any;
+    };
+    rules: {
+        gt: {
+            args: ({
+                name: string;
+                ref: boolean;
+                assert: (v: any) => boolean;
+                message: string;
+                normalize: (v: any) => BN;
+            } | {
+                name: string;
+                assert: (v: any) => boolean;
+                message: string;
+                ref?: undefined;
+                normalize?: undefined;
+            })[];
+            validate(value: any, helpers: any, args: any): any;
+        };
+        lt: {
+            args: ({
+                name: string;
+                ref: boolean;
+                assert: (v: any) => boolean;
+                message: string;
+                normalize: (v: any) => BN;
+            } | {
+                name: string;
+                assert: (v: any) => boolean;
+                message: string;
+                ref?: undefined;
+                normalize?: undefined;
+            })[];
+            validate(value: any, helpers: any, args: any): any;
+        };
+        min: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        max: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        greater: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        less: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        positive: {
+            method(): BNSchema;
+        };
+        negative: {
+            method(): BNSchema;
+        };
+    };
+};

package/lib/extension/bn.js

@@ -1,130 +1,137 @@
-const { BN } = require('@ocap/util');
-
-module.exports = (Joi) => ({
-  type: 'BN',
-  base: Joi.any(),
-  messages: {
-    'bn.nan': '{{#label}} is not a big number',
-    'bn.max': '{{#label}} needs to be less than or equal to "{{#threshold}}"',
-    'bn.min': '{{#label}} needs to be greater than or equal to "{{#threshold}}"',
-    'bn.less': '{{#label}} needs to be less than "{{#threshold}}"',
-    'bn.greater': '{{#label}} needs to be greater than "{{#threshold}}"',
-    'bn.positive': '{{#label}} needs to be positive',
-    'bn.negative': '{{#label}} needs to be negative',
-  },
-
-  prepare(value, helpers) {
-    try {
-      return { value: new BN(value) };
-    } catch (err) {
-      return { errors: helpers.error('bn.nan') };
-    }
-  },
-  coerce(value) {
-    return { value: value.toString(10) };
-  },
-
-  validate(value) {
-    return { value };
-  },
-
-  rules: {
-    gt: {
-      args: [
-        {
-          name: 'threshold',
-          ref: true,
-          assert: (v) => BN.isBN(v),
-          message: 'must be a big number',
-          normalize: (v) => new BN(v),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BNExtension = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+function BNExtension(root) {
+    return {
+        type: 'BN',
+        base: root.any(),
+        messages: {
+            'bn.nan': '{{#label}} is not a big number',
+            'bn.max': '{{#label}} needs to be less than or equal to "{{#threshold}}"',
+            'bn.min': '{{#label}} needs to be greater than or equal to "{{#threshold}}"',
+            'bn.less': '{{#label}} needs to be less than "{{#threshold}}"',
+            'bn.greater': '{{#label}} needs to be greater than "{{#threshold}}"',
+            'bn.positive': '{{#label}} needs to be positive',
+            'bn.negative': '{{#label}} needs to be negative',
         },
-        {
-          name: 'equal',
-          assert: (v) => typeof v === 'boolean',
-          message: 'must be a boolean',
+        prepare(value, helpers) {
+            try {
+                return { value: new bn_js_1.default(value) };
+            }
+            catch (err) {
+                return { errors: helpers.error('bn.nan') };
+            }
         },
-      ],
-      // The rule return structure is different from the root
-      // eslint-disable-next-line consistent-return
-      validate(value, helpers, args) {
-        const v = new BN(value);
-        if (args.equal && v.lt(args.threshold)) {
-          return helpers.error('bn.min', args);
-        }
-        if (!args.equal && v.lte(args.threshold)) {
-          return helpers.error('bn.greater', args);
-        }
-
-        // must return value when valid
-        return value;
-      },
-    },
-
-    lt: {
-      args: [
-        {
-          name: 'threshold',
-          ref: true,
-          assert: (v) => BN.isBN(v),
-          message: 'must be a big number',
-          normalize: (v) => new BN(v),
+        coerce(value) {
+            return { value: value.toString(10) };
         },
-        {
-          name: 'equal',
-          assert: (v) => typeof v === 'boolean',
-          message: 'must be a boolean',
+        validate(value) {
+            return { value };
         },
-      ],
-      // The rule return structure is different from the root
-      // eslint-disable-next-line consistent-return
-      validate(value, helpers, args) {
-        const v = new BN(value);
-        if (args.equal && v.gt(args.threshold)) {
-          return helpers.error('bn.max', args);
-        }
-        if (!args.equal && v.gte(args.threshold)) {
-          return helpers.error('bn.less', args);
-        }
-
-        // must return value when valid
-        return value;
-      },
-    },
-
-    min: {
-      alias: 'gte',
-      method(threshold) {
-        return this.$_addRule({ name: 'gt', args: { threshold, equal: true } });
-      },
-    },
-    max: {
-      alias: 'lte',
-      method(threshold) {
-        return this.$_addRule({ name: 'lt', args: { threshold, equal: true } });
-      },
-    },
-    greater: {
-      alias: 'gt',
-      method(threshold) {
-        return this.$_addRule({ name: 'gt', args: { threshold, equal: false } });
-      },
-    },
-    less: {
-      alias: 'lt',
-      method(threshold) {
-        return this.$_addRule({ name: 'lt', args: { threshold, equal: false } });
-      },
-    },
-
-    positive: {
-      method() {
-        return this.$_addRule({ name: 'gt', args: { threshold: 0, equal: false } });
-      },
-    },
-    negative: {
-      method() {
-        return this.$_addRule({ name: 'lt', args: { threshold: 0, equal: false } });
-      },
-    },
-  },
-});
+        rules: {
+            gt: {
+                args: [
+                    {
+                        name: 'threshold',
+                        ref: true,
+                        assert: (v) => bn_js_1.default.isBN(v),
+                        message: 'must be a big number',
+                        normalize: (v) => new bn_js_1.default(v),
+                    },
+                    {
+                        name: 'equal',
+                        assert: (v) => typeof v === 'boolean',
+                        message: 'must be a boolean',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const v = new bn_js_1.default(value);
+                    if (args.equal && v.lt(args.threshold)) {
+                        return helpers.error('bn.min', args);
+                    }
+                    if (!args.equal && v.lte(args.threshold)) {
+                        return helpers.error('bn.greater', args);
+                    }
+                    // must return value when valid
+                    return value;
+                },
+            },
+            lt: {
+                args: [
+                    {
+                        name: 'threshold',
+                        ref: true,
+                        assert: (v) => bn_js_1.default.isBN(v),
+                        message: 'must be a big number',
+                        normalize: (v) => new bn_js_1.default(v),
+                    },
+                    {
+                        name: 'equal',
+                        assert: (v) => typeof v === 'boolean',
+                        message: 'must be a boolean',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const v = new bn_js_1.default(value);
+                    if (args.equal && v.gt(args.threshold)) {
+                        return helpers.error('bn.max', args);
+                    }
+                    if (!args.equal && v.gte(args.threshold)) {
+                        return helpers.error('bn.less', args);
+                    }
+                    // must return value when valid
+                    return value;
+                },
+            },
+            min: {
+                alias: 'gte',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold, equal: true } });
+                },
+            },
+            max: {
+                alias: 'lte',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold, equal: true } });
+                },
+            },
+            greater: {
+                alias: 'gt',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold, equal: false } });
+                },
+            },
+            less: {
+                alias: 'lt',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold, equal: false } });
+                },
+            },
+            positive: {
+                method() {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold: 0, equal: false } });
+                },
+            },
+            negative: {
+                method() {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold: 0, equal: false } });
+                },
+            },
+        },
+    };
+}
+exports.BNExtension = BNExtension;

package/lib/extension/did.d.ts

@@ -0,0 +1,55 @@
+import { Root, StringSchema } from 'joi';
+import { KeyType, HashType, RoleType } from '@ocap/mcrypto';
+export interface DIDSchema extends StringSchema {
+    wallet(type: string): this;
+    pk(type: string): this;
+    hash(type: string): this;
+    role(type: string): this;
+}
+export declare function DIDExtension(root: Root): {
+    type: string;
+    base: StringSchema;
+    messages: {
+        'did.empty': string;
+        'did.invalid': string;
+        'did.wallet': string;
+        'did.pk': string;
+        'did.hash': string;
+        'did.role': string;
+    };
+    validate(value: any, helpers: any): {
+        errors: any;
+        value?: undefined;
+    } | {
+        value: string;
+        errors?: undefined;
+    };
+    rules: {
+        type: {
+            args: ({
+                name: string;
+                ref: boolean;
+                assert: (v: string) => boolean;
+                message: string;
+            } | {
+                name: string;
+                assert: (v: string) => boolean;
+                message: string;
+                ref?: undefined;
+            })[];
+            validate(value: string, helpers: any, args: any): any;
+        };
+        wallet: {
+            method(type: string): DIDSchema;
+        };
+        pk: {
+            method(type: KeyType): DIDSchema;
+        };
+        hash: {
+            method(type: HashType): DIDSchema;
+        };
+        role: {
+            method(type: RoleType): DIDSchema;
+        };
+    };
+};

package/lib/extension/did.js

@@ -1,100 +1,105 @@
-const isEqual = require('lodash/isEqual');
-const { types } = require('@ocap/mcrypto');
-const { isValid, toTypeInfo, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM } = require('@arcblock/did');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIDExtension = void 0;
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const mcrypto_1 = require("@ocap/mcrypto");
+const did_1 = require("@arcblock/did");
 const ruleTypes = {
-  wallet: ['arcblock', 'ethereum', 'default', 'eth'],
-  pk: Object.keys(types.KeyType),
-  hash: Object.keys(types.HashType),
-  role: Object.keys(types.RoleType),
+    wallet: ['arcblock', 'ethereum', 'default', 'eth'],
+    pk: Object.keys(mcrypto_1.types.KeyType),
+    hash: Object.keys(mcrypto_1.types.HashType),
+    role: Object.keys(mcrypto_1.types.RoleType),
 };
-
-module.exports = (Joi) => ({
-  type: 'DID',
-  base: Joi.string().trim(),
-  messages: {
-    'did.empty': 'Expect {{#label}} to be non-empty string, got "{{#value}}"',
-    'did.invalid': 'Expect {{#label}} to be valid did, got "{{#value}}"',
-    'did.wallet': 'Expect wallet type of {{#label}} to be "{{#expected}}" wallet, got "{{#actual}}"',
-    'did.pk': 'Expect pk type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
-    'did.hash': 'Expect hash type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
-    'did.role': 'Expect role type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
-  },
-
-  validate(value, helpers) {
-    if (!value || typeof value !== 'string') {
-      return { errors: helpers.error('did.empty', { value }) };
-    }
-
-    if (isValid(value) === false) {
-      return { errors: helpers.error('did.invalid', { value }) };
-    }
-
-    return { value };
-  },
-
-  rules: {
-    type: {
-      args: [
-        {
-          name: 'key',
-          ref: true,
-          assert: (v) => Object.keys(ruleTypes).includes(v),
-          message: `must be one of ${Object.keys(ruleTypes).join(', ')}`,
+function DIDExtension(root) {
+    return {
+        type: 'DID',
+        base: root.string().trim(),
+        messages: {
+            'did.empty': 'Expect {{#label}} to be non-empty string, got "{{#value}}"',
+            'did.invalid': 'Expect {{#label}} to be valid did, got "{{#value}}"',
+            'did.wallet': 'Expect wallet type of {{#label}} to be "{{#expected}}" wallet, got "{{#actual}}"',
+            'did.pk': 'Expect pk type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+            'did.hash': 'Expect hash type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+            'did.role': 'Expect role type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+        },
+        validate(value, helpers) {
+            if (!value || typeof value !== 'string') {
+                return { errors: helpers.error('did.empty', { value }) };
+            }
+            if ((0, did_1.isValid)(value) === false) {
+                return { errors: helpers.error('did.invalid', { value }) };
+            }
+            return { value };
         },
-        {
-          name: 'expected',
-          assert: (v) => Object.keys(ruleTypes).some((x) => ruleTypes[x].includes(v)),
-          message: 'must be valid type',
+        rules: {
+            type: {
+                args: [
+                    {
+                        name: 'key',
+                        ref: true,
+                        assert: (v) => Object.keys(ruleTypes).includes(v),
+                        message: `must be one of ${Object.keys(ruleTypes).join(', ')}`,
+                    },
+                    {
+                        name: 'expected',
+                        // @ts-ignore
+                        assert: (v) => Object.keys(ruleTypes).some((x) => ruleTypes[x].includes(v)),
+                        message: 'must be valid type',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const type = (0, did_1.toTypeInfo)(value);
+                    const typeStr = (0, did_1.toTypeInfoStr)(value);
+                    if (args.key === 'wallet') {
+                        if (['ethereum', 'eth'].includes(args.expected) && (0, isEqual_1.default)(type, did_1.DID_TYPE_ETHEREUM) === false) {
+                            return helpers.error('did.wallet', Object.assign(Object.assign({}, args), { actual: JSON.stringify(typeStr) }));
+                        }
+                        if (['arcblock', 'default'].includes(args.expected) && (0, isEqual_1.default)(type, did_1.DID_TYPE_ARCBLOCK) === false) {
+                            return helpers.error('did.wallet', Object.assign(Object.assign({}, args), { actual: JSON.stringify(typeStr) }));
+                        }
+                    }
+                    if (args.key === 'pk' && typeStr.pk !== args.expected) {
+                        return helpers.error('did.pk', Object.assign(Object.assign({}, args), { actual: typeStr.pk }));
+                    }
+                    if (args.key === 'hash' && typeStr.hash !== args.expected) {
+                        return helpers.error('did.hash', Object.assign(Object.assign({}, args), { actual: typeStr.hash }));
+                    }
+                    if (args.key === 'role' && typeStr.role !== args.expected) {
+                        return helpers.error('did.role', Object.assign(Object.assign({}, args), { actual: typeStr.role }));
+                    }
+                    return value;
+                },
+            },
+            wallet: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'wallet', expected: type } });
+                },
+            },
+            pk: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'pk', expected: type } });
+                },
+            },
+            hash: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'hash', expected: type } });
+                },
+            },
+            role: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'role', expected: type } });
+                },
+            },
         },
-      ],
-      // The rule return structure is different from the root
-      // eslint-disable-next-line consistent-return
-      validate(value, helpers, args) {
-        const type = toTypeInfo(value);
-        const typeStr = toTypeInfo(value, true);
-
-        if (args.key === 'wallet') {
-          if (['ethereum', 'eth'].includes(args.expected) && isEqual(type, DID_TYPE_ETHEREUM) === false) {
-            return helpers.error('did.wallet', { ...args, actual: JSON.stringify(typeStr) });
-          }
-          if (['arcblock', 'default'].includes(args.expected) && isEqual(type, DID_TYPE_ARCBLOCK) === false) {
-            return helpers.error('did.wallet', { ...args, actual: JSON.stringify(typeStr) });
-          }
-        }
-        if (args.key === 'pk' && typeStr.pk !== args.expected) {
-          return helpers.error('did.pk', { ...args, actual: typeStr.pk });
-        }
-        if (args.key === 'hash' && typeStr.hash !== args.expected) {
-          return helpers.error('did.hash', { ...args, actual: typeStr.hash });
-        }
-        if (args.key === 'role' && typeStr.role !== args.expected) {
-          return helpers.error('did.role', { ...args, actual: typeStr.role });
-        }
-
-        return value;
-      },
-    },
-
-    wallet: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'wallet', expected: type } });
-      },
-    },
-    pk: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'pk', expected: type } });
-      },
-    },
-    hash: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'hash', expected: type } });
-      },
-    },
-    role: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'role', expected: type } });
-      },
-    },
-  },
-});
+    };
+}
+exports.DIDExtension = DIDExtension;

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+import BaseJoi, { Root } from 'joi';
+import { BNSchema } from './extension/bn';
+import { DIDSchema } from './extension/did';
+export interface ExtendedRoot extends Root {
+    DID(): DIDSchema;
+    BN(): BNSchema;
+}
+export declare const Joi: ExtendedRoot;
+export declare const schemas: {
+    context: BaseJoi.ObjectSchema<any>;
+    tokenInput: BaseJoi.ObjectSchema<any>;
+    multiSig: BaseJoi.ArraySchema;
+    foreignToken: BaseJoi.ObjectSchema<any>;
+};
+export declare const patterns: {
+    txHash: RegExp;
+};

package/lib/index.js

@@ -1,51 +1,44 @@
-const JOI = require('joi');
-
-const bnExtension = require('./extension/bn');
-const didExtension = require('./extension/did');
-
-const Joi = JOI.extend(didExtension).extend(bnExtension);
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patterns = exports.schemas = exports.Joi = void 0;
+const joi_1 = __importDefault(require("joi"));
+const bn_1 = require("./extension/bn");
+const did_1 = require("./extension/did");
+exports.Joi = joi_1.default.extend(did_1.DIDExtension).extend(bn_1.BNExtension);
 const txHash = /^(0x)?([A-Fa-f0-9]{64})$/;
-
-const contextSchema = Joi.object({
-  genesisTime: Joi.date().iso().required().raw(),
-  genesisTx: Joi.string().regex(txHash).required().allow(''),
-  renaissanceTime: Joi.date().iso().required().raw(),
-  renaissanceTx: Joi.string().regex(txHash).required().allow(''),
+const contextSchema = exports.Joi.object({
+    genesisTime: exports.Joi.date().iso().required().raw(),
+    genesisTx: exports.Joi.string().regex(txHash).required().allow(''),
+    renaissanceTime: exports.Joi.date().iso().required().raw(),
+    renaissanceTx: exports.Joi.string().regex(txHash).required().allow(''),
 });
-
-const tokenInputSchema = Joi.object({
-  address: Joi.DID().role('ROLE_TOKEN').required(),
-  value: Joi.BN().positive().required(),
+const tokenInputSchema = exports.Joi.object({
+    address: exports.Joi.DID().role('ROLE_TOKEN').required(),
+    value: exports.Joi.BN().positive().required(),
 });
-
-const multiSigSchema = Joi.array().items({
-  signer: Joi.DID().required(),
-  pk: Joi.any().required(),
-  signature: Joi.any().required(),
-  delegator: Joi.DID().valid('').optional(),
-  data: Joi.any().optional(),
+const multiSigSchema = exports.Joi.array().items({
+    signer: exports.Joi.DID().required(),
+    pk: exports.Joi.any().required(),
+    signature: exports.Joi.any().required(),
+    delegator: exports.Joi.DID().valid('').optional(),
+    data: exports.Joi.any().optional(),
 });
-
-const foreignTokenSchema = Joi.object({
-  type: Joi.string().min(1).max(32).required(),
-  contractAddress: Joi.DID().wallet('ethereum').required(),
-  chainType: Joi.string().min(1).max(32).required(),
-  chainName: Joi.string().min(1).max(32).required(),
-  chainId: Joi.number().positive().required(),
+const foreignTokenSchema = exports.Joi.object({
+    type: exports.Joi.string().min(1).max(32).required(),
+    contractAddress: exports.Joi.DID().wallet('ethereum').required(),
+    chainType: exports.Joi.string().min(1).max(32).required(),
+    chainName: exports.Joi.string().min(1).max(32).required(),
+    chainId: exports.Joi.number().positive().required(),
 });
-
-const schemas = {
-  context: contextSchema,
-  tokenInput: tokenInputSchema,
-  multiSig: multiSigSchema,
-  foreignToken: foreignTokenSchema,
+exports.schemas = {
+    context: contextSchema,
+    tokenInput: tokenInputSchema,
+    multiSig: multiSigSchema,
+    foreignToken: foreignTokenSchema,
 };
-
-const patterns = {
-  txHash,
+exports.patterns = {
+    txHash,
 };
-
-module.exports = Joi;
-module.exports.schemas = schemas;
-module.exports.patterns = patterns;

package/package.json

@@ -3,30 +3,43 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.16",
+  "version": "1.16.17",
   "description": "",
   "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "files": [
     "lib"
   ],
   "scripts": {
-    "lint": "eslint tests lib",
-    "lint:fix": "eslint --fix tests lib",
+    "lint": "eslint tests src",
+    "lint:fix": "eslint --fix tests src",
     "test": "jest --forceExit --detectOpenHandles",
-    "coverage": "npm run test -- --coverage"
+    "coverage": "npm run test -- --coverage",
+    "clean": "rm -fr lib",
+    "prebuild": "npm run clean",
+    "build:watch": "npm run build -- -w",
+    "build": "tsc"
   },
   "dependencies": {
-    "@arcblock/did": "1.16.16",
-    "@ocap/mcrypto": "1.16.16",
-    "@ocap/util": "1.16.16",
+    "@arcblock/did": "1.16.17",
+    "@ocap/mcrypto": "1.16.17",
+    "@ocap/util": "1.16.17",
+    "bn.js": "5.2.1",
     "joi": "^17.6.0",
     "lodash": "^4.17.21"
   },
+  "resolutions": {
+    "bn.js": "5.2.1"
+  },
   "devDependencies": {
-    "jest": "^27.3.1"
+    "@arcblock/eslint-config-ts": "0.2.2",
+    "eslint": "^8.17.0",
+    "jest": "^28.1.1",
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.7.3"
   },
   "keywords": [],
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
-  "gitHead": "051f9620995cf24407374cc4811b0fa6ed6dc7ca"
+  "gitHead": "489ce5e03bce27ddcd535390228b11ab56e7a2e3"
 }