@arcblock/validator 1.14.10

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018-2019 ArcBlock
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,3 @@
+# OCAP State
+
+Defines core data structures for states in OCAP server.

package/lib/extension/bn.js

@@ -0,0 +1,130 @@
+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),
+        },
+        {
+          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(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),
+        },
+        {
+          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(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 } });
+      },
+    },
+  },
+});

package/lib/extension/did.js

@@ -0,0 +1,100 @@
+const isEqual = require('lodash/isEqual');
+const { types } = require('@ocap/mcrypto');
+const { isValid, toTypeInfo, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM } = 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),
+};
+
+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(', ')}`,
+        },
+        {
+          name: 'expected',
+          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 = 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 } });
+      },
+    },
+  },
+});

package/lib/index.js

@@ -0,0 +1,51 @@
+const JOI = require('joi');
+
+const bnExtension = require('./extension/bn');
+const didExtension = require('./extension/did');
+
+const Joi = JOI.extend(didExtension).extend(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 tokenInputSchema = Joi.object({
+  address: Joi.DID().role('ROLE_TOKEN').required(),
+  value: 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 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 schemas = {
+  context: contextSchema,
+  tokenInput: tokenInputSchema,
+  multiSig: multiSigSchema,
+  foreignToken: foreignTokenSchema,
+};
+
+const patterns = {
+  txHash,
+};
+
+module.exports = Joi;
+module.exports.schemas = schemas;
+module.exports.patterns = patterns;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@arcblock/validator",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.14.10",
+  "description": "",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint tests lib",
+    "lint:fix": "eslint --fix tests lib",
+    "test": "jest --forceExit --detectOpenHandles",
+    "coverage": "npm run test -- --coverage"
+  },
+  "dependencies": {
+    "@arcblock/did": "1.14.10",
+    "@ocap/mcrypto": "1.14.10",
+    "@ocap/util": "1.14.10",
+    "joi": "^17.4.2",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "jest": "^27.3.1"
+  },
+  "keywords": [],
+  "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
+  "license": "MIT",
+  "gitHead": "3475efca85274bbd44bf4edd775189f9cabe2188"
+}