@ocap/state 1.13.45 → 1.13.49

package/lib/joi/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/joi/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/joi/index.js

@@ -0,0 +1,53 @@
+const JOI = require('joi');
+
+const bnExtension = require('./extension/bn');
+const didExtension = require('./extension/did');
+
+const Joi = JOI.extend(didExtension).extend(bnExtension);
+
+const hashRegexp = /^(0x)?([A-Fa-f0-9]{64})$/;
+
+const contextSchema = Joi.object({
+  genesisTime: Joi.date().iso().required().raw(),
+  genesisTx: Joi.string().regex(hashRegexp).required(),
+  renaissanceTime: Joi.date().iso().required().raw(),
+  renaissanceTx: Joi.string().regex(hashRegexp).required(),
+});
+
+const tokenInputSchema = Joi.object({
+  address: Joi.DID().role('ROLE_TOKEN').required(),
+  value: Joi.BN().positive().required(),
+});
+
+const indexedTokenInputSchema = Joi.object({
+  address: Joi.DID().role('ROLE_TOKEN').required(),
+  value: Joi.BN().positive().required(),
+  decimal: Joi.number().integer().greater(0).required(),
+  symbol: Joi.string().required(),
+  unit: Joi.string().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(),
+});
+
+module.exports = Joi;
+
+module.exports.contextSchema = contextSchema;
+module.exports.tokenInputSchema = tokenInputSchema;
+module.exports.indexedTokenInputSchema = indexedTokenInputSchema;
+module.exports.multiSigSchema = multiSigSchema;
+module.exports.foreignTokenSchema = foreignTokenSchema;
+module.exports.hashRegexp = hashRegexp;

package/lib/states/rollup-block.js

@@ -15,14 +15,14 @@ const schema = Joi.object({
   txHash: Joi.string().regex(Joi.hashRegexp).required(),
   txs: Joi.array().items(Joi.string().regex(Joi.hashRegexp).required()).min(1).unique().required(),
 
-  proposer: Joi.DID().required(),
+  proposer: Joi.DID().wallet('ethereum').required(),
   signatures: Joi.multiSigSchema.min(1).required(),
 
-  rollup: Joi.DID().required(),
+  rollup: Joi.DID().role('ROLE_ROLLUP').required(),
 
-  blockReward: Joi.BN().optional(),
-  mintedAmount: Joi.BN().optional(),
-  burnedAmount: Joi.BN().optional(),
+  blockReward: Joi.BN().positive().optional(),
+  mintedAmount: Joi.BN().min(0).optional(),
+  burnedAmount: Joi.BN().min(0).optional(),
 
   context: Joi.contextSchema,
   data: Joi.any().optional(),

package/lib/states/rollup.js

@@ -12,25 +12,25 @@ const validator = Joi.object({
 });
 
 const schema = Joi.object({
-  address: Joi.DID().required(),
-  tokenAddress: Joi.DID().required(),
-  erc20TokenAddress: Joi.DID().required(),
-  contractAddress: Joi.DID().required(),
+  address: Joi.DID().role('ROLE_ROLLUP').required(),
+  tokenAddress: Joi.DID().role('ROLE_TOKEN').required(),
+  contractAddress: Joi.DID().wallet('ethereum').required(),
+  paused: Joi.boolean().default(false),
 
   seedValidators: Joi.array().items(validator).min(1).required(),
   validators: Joi.array().items(validator).default([]),
 
-  minStakeAmount: Joi.BN().required(),
-  maxStakeAmount: Joi.BN().required(),
+  minStakeAmount: Joi.BN().positive().required(),
+  maxStakeAmount: Joi.BN().min(Joi.ref('minStakeAmount')).required(),
 
   minSignerCount: Joi.number()
     .integer()
     .min(Joi.ref('seedValidators', { adjust: (v) => v.length }))
     .required(),
-  maxSignerCount: Joi.number().integer().min(1).max(8).greater(Joi.ref('minSignerCount')).required(),
+  maxSignerCount: Joi.number().integer().min(1).max(8).min(Joi.ref('minSignerCount')).required(),
 
   minBlockSize: Joi.number().integer().min(1).required(),
-  maxBlockSize: Joi.number().integer().min(1).max(10).greater(Joi.ref('minBlockSize')).required(),
+  maxBlockSize: Joi.number().integer().min(1).max(10).min(Joi.ref('minBlockSize')).required(),
 
   minBlockInterval: Joi.number()
     .integer()
@@ -39,15 +39,18 @@ const schema = Joi.object({
     .required(), // in seconds
   minBlockConfirmation: Joi.number().integer().min(1).max(100).required(),
 
-  minDepositAmount: Joi.BN().required(),
-  minWithdrawAmount: Joi.BN().required(),
+  minDepositAmount: Joi.BN().positive().required(),
+  maxDepositAmount: Joi.BN().greater(Joi.ref('minDepositAmount')).required(),
+  minWithdrawAmount: Joi.BN().positive().required(),
+  maxWithdrawAmount: Joi.BN().greater(Joi.ref('minWithdrawAmount')).required(),
 
   depositFeeRate: Joi.number().integer().min(1).max(10000).required(),
   withdrawFeeRate: Joi.number().integer().min(1).max(10000).required(),
   proposerFeeShare: Joi.number().integer().min(1).max(10000).required(),
-
-  foreignChainType: Joi.string().required(),
-  foreignChainId: Joi.string().required(),
+  minDepositFee: Joi.BN().positive().required(),
+  maxDepositFee: Joi.BN().min(Joi.ref('minDepositFee')).required(),
+  minWithdrawFee: Joi.BN().positive().required(),
+  maxWithdrawFee: Joi.BN().min(Joi.ref('minWithdrawFee')).required(),
 
   blockHeight: Joi.number().integer().min(0).required(),
   blockHash: Joi.string().regex(Joi.hashRegexp).optional().allow(''),
@@ -64,8 +67,8 @@ const create = (attrs, context) => {
     blockHash: '',
     ...pick(attrs, [
       'address',
+      'paused',
       'tokenAddress',
-      'erc20TokenAddress',
       'contractAddress',
       'seedValidators',
       'validators',
@@ -77,13 +80,17 @@ const create = (attrs, context) => {
       'maxBlockSize',
       'minBlockInterval',
       'minBlockConfirmation',
-      'foreignChainType',
-      'foreignChainId',
       'minDepositAmount',
+      'maxDepositAmount',
       'minWithdrawAmount',
+      'maxWithdrawAmount',
       'depositFeeRate',
       'withdrawFeeRate',
       'proposerFeeShare',
+      'minDepositFee',
+      'maxDepositFee',
+      'minWithdrawFee',
+      'maxWithdrawFee',
       'issuer',
       'data',
     ]),
@@ -120,6 +127,7 @@ const update = (state, updates, context) => {
   const rollup = {
     ...state,
     ...pick(updates, [
+      'paused',
       'validators',
       'minStakeAmount',
       'maxStakeAmount',
@@ -130,10 +138,16 @@ const update = (state, updates, context) => {
       'minBlockInterval',
       'minBlockConfirmation',
       'minDepositAmount',
+      'maxDepositAmount',
       'minWithdrawAmount',
+      'maxWithdrawAmount',
       'depositFeeRate',
       'withdrawFeeRate',
       'proposerFeeShare',
+      'minDepositFee',
+      'maxDepositFee',
+      'minWithdrawFee',
+      'maxWithdrawFee',
       'blockHeight',
       'blockHash',
       'data',

package/lib/states/stake.js

@@ -4,11 +4,11 @@ const Joi = require('../joi');
 const { create: createStateContext, update: updateStateContext } = require('./contexts/state');
 
 const schema = Joi.object({
-  address: Joi.DID().trim().required(),
+  address: Joi.DID().role('ROLE_STAKE').trim().required(),
   sender: Joi.DID().trim().required(),
   receiver: Joi.DID().trim().required(),
   tokens: Joi.object().default({}),
-  assets: Joi.array().items(Joi.DID()).default([]),
+  assets: Joi.array().items(Joi.DID().role('ROLE_ASSET')).default([]),
   revocable: Joi.boolean().default(true),
   message: Joi.string().trim().min(1).max(256).required(),
   context: Joi.contextSchema,

package/lib/states/token.js

@@ -13,8 +13,9 @@ const create = (attrs, context) => {
       'decimal',
       'icon',
       'totalSupply',
+      'initialSupply',
       'address',
-      'erc20ContractAddress',
+      'foreignToken',
       'data',
       'issuer',
     ]),
@@ -23,6 +24,9 @@ const create = (attrs, context) => {
   if (!token.data) {
     token.data = null;
   }
+  if (!token.foreignToken) {
+    token.foreignToken = null;
+  }
 
   return token;
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.13.45",
+  "version": "1.13.49",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -16,20 +16,20 @@
     "coverage": "npm run test -- --coverage"
   },
   "dependencies": {
-    "@arcblock/did": "1.13.45",
-    "@ocap/contract": "1.13.45",
-    "@ocap/message": "1.13.45",
-    "@ocap/util": "1.13.45",
+    "@arcblock/did": "1.13.49",
+    "@ocap/contract": "1.13.49",
+    "@ocap/message": "1.13.49",
+    "@ocap/util": "1.13.49",
     "bloom-filters": "^1.3.1",
     "debug": "^4.3.2",
     "joi": "^17.4.2",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@ocap/mcrypto": "1.13.45"
+    "@ocap/mcrypto": "1.13.49"
   },
   "keywords": [],
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
-  "gitHead": "36bd0bfdf2381ecdb4a5cc38c555428328820a99"
+  "gitHead": "c0af0d1ba7ead95f2224ff29aaebb635f6969a94"
 }

package/lib/joi.js

@@ -1,89 +0,0 @@
-const JOI = require('joi');
-const { BN } = require('@ocap/util');
-const { isValid } = require('@arcblock/did');
-
-const didExtension = (joi) => ({
-  type: 'DID',
-  base: joi.string().trim(),
-  validate(value, { error }) {
-    if (!value || typeof value !== 'string') {
-      return { errors: error('did.empty', { value }) };
-    }
-
-    if (isValid(value) === false) {
-      return { errors: error('did.invalid', { value }) };
-    }
-
-    return { value };
-  },
-  messages: {
-    'did.empty': 'Expect {{#label}} to be non-empty string, got "{{#value}}"',
-    'did.invalid': 'Expect {{#label}} to be valid did, got "{{#value}}"',
-  },
-});
-
-const ZERO = new BN(0);
-const bnExtension = (joi) => ({
-  type: 'BN',
-  base: joi.string().trim(),
-  validate(value, { error }) {
-    if (!value || typeof value !== 'string') {
-      return { errors: error('bn.empty', { value }) };
-    }
-
-    try {
-      const bn = new BN(value);
-      if (bn.lt(ZERO)) {
-        return { errors: error('bn.negative', { value }) };
-      }
-    } catch (err) {
-      return { errors: error('bn.invalid', { value }) };
-    }
-
-    return { value };
-  },
-  messages: {
-    'bn.empty': 'Expect {{#label}} to be non-empty string, got "{{#value}}"',
-    'bn.invalid': 'Expect {{#label}} to be valid big number string, got "{{#value}}"',
-    'bn.negative': 'Expect {{#label}} to be positive, got "{{#value}}"',
-  },
-});
-
-const Joi = JOI.extend(didExtension).extend(bnExtension);
-
-const contextSchema = Joi.object({
-  genesisTime: Joi.date().iso().required().raw(),
-  genesisTx: Joi.string().required(),
-  renaissanceTime: Joi.date().iso().required().raw(),
-  renaissanceTx: Joi.string().required(),
-});
-
-const tokenInputSchema = Joi.object({
-  address: Joi.DID().required(),
-  value: Joi.BN().required(),
-});
-
-const indexedTokenInputSchema = Joi.object({
-  address: Joi.DID().required(),
-  value: Joi.BN().required(),
-  decimal: Joi.number().integer().greater(0).required(),
-  symbol: Joi.string().required(),
-  unit: Joi.string().required(),
-  key: Joi.string().optional(),
-});
-
-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(),
-});
-
-module.exports = Joi;
-
-module.exports.contextSchema = contextSchema;
-module.exports.tokenInputSchema = tokenInputSchema;
-module.exports.indexedTokenInputSchema = indexedTokenInputSchema;
-module.exports.multiSigSchema = multiSigSchema;
-module.exports.hashRegexp = /^(0x)?([A-Fa-f0-9]{64})$/;

package/lib/states/contexts/stake.js

@@ -1,13 +0,0 @@
-// StakeContext: just exist for compatibility
-
-const create = () => ({
-  totalStakes: 0,
-  totalUnstakes: 0,
-  totalReceivedStakes: 0,
-  recentStakes: [],
-  recentReceivedStakes: [],
-});
-
-const update = (context) => ({ ...context });
-
-module.exports = { create, update };