@ocap/state 1.13.63 → 1.13.67

package/lib/contexts/state.js

@@ -2,15 +2,16 @@
 
 const create = ({ txHash, txTime }) => ({
   genesisTime: txTime || '',
-  genesisTx: txHash || null,
+  genesisTx: txHash || '',
   renaissanceTime: txTime || '',
-  renaissanceTx: txHash || null,
+  renaissanceTx: txHash || '',
 });
 
 const update = (context, { txHash, txTime }) => ({
   ...context,
+  genesisTx: context.genesisTx || '',
   renaissanceTime: txTime || '',
-  renaissanceTx: txHash || null,
+  renaissanceTx: txHash || '',
 });
 
 module.exports = { create, update };

package/lib/index.js

@@ -10,8 +10,6 @@ const rollup = require('./states/rollup');
 const rollupBlock = require('./states/rollup-block');
 const evidence = require('./states/evidence');
 
-const Joi = require('./joi');
-
 const Blacklist = require('./states/blacklist');
 
 module.exports = {
@@ -56,5 +54,4 @@ module.exports = {
   ],
 
   Blacklist,
-  Joi,
 };

package/lib/states/account.js

@@ -1,35 +1,40 @@
 const pick = require('lodash/pick');
 const uniq = require('lodash/uniq');
 const flatten = require('lodash/flatten');
-const { toBase64, toUint8Array, BN } = require('@ocap/util');
+const { isFromPublicKey } = require('@arcblock/did');
+const { toBase58, BN } = require('@ocap/util');
 
+const Joi = require('@ocap/validator');
 const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
 
+const schema = Joi.object({
+  address: Joi.DID().required(),
+  pk: Joi.string().allow(''),
+  issuer: Joi.DID().allow(''),
+  moniker: Joi.string().trim().min(2).max(40).allow(''),
+  nonce: Joi.number().min(0).default(0),
+  tokens: Joi.object().pattern(Joi.DID().role('ROLE_TOKEN'), Joi.BN().min(0)).default({}),
+  migratedTo: Joi.array().items(Joi.DID()).default([]),
+  migratedFrom: Joi.array().items(Joi.DID()).default([]),
+  context: Joi.schemas.context,
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+
 const create = (attrs, context) => {
   const account = {
-    balance: '0',
-    gasBalance: '0',
     nonce: 0,
-    numTxs: 0,
-    numAssets: 0,
     migratedTo: [],
     migratedFrom: [],
-    stake: null,
     tokens: {},
     context: createStateContext(context),
     ...pick(attrs, ['address', 'pk', 'issuer', 'moniker', 'data', 'nonce', 'migratedFrom', 'tokens']),
   };
 
-  // ensure we have correct pk
-  if (typeof account.pk !== 'string') {
-    account.pk = toBase64(toUint8Array(account.pk));
+  if (!account.moniker) {
+    account.moniker = [account.address.slice(0, 6), account.address.slice(-5)].join('-');
   }
 
-  if (!account.data) {
-    account.data = null;
-  }
-
-  return account;
+  return validate(account);
 };
 
 const update = (state, attrs, context) => {
@@ -37,20 +42,47 @@ const update = (state, attrs, context) => {
     throw new Error('nonce must be greater in newer transactions');
   }
 
+  // ensure we are updating the correct pk
+  if (attrs.pk && isFromPublicKey(state.address, attrs.pk) === false) {
+    delete attrs.pk;
+  }
+
   const account = {
     ...state,
-    ...pick(attrs, ['moniker', 'data', 'migratedTo', 'nonce', 'tokens']),
+    ...pick(attrs, ['moniker', 'data', 'migratedTo', 'nonce', 'tokens', 'pk']),
     migratedTo: uniq(flatten(attrs.migratedTo ? [attrs.migratedTo].concat(state.migratedTo) : state.migratedTo)),
     context: updateStateContext(state.context, context),
   };
 
-  if (!account.data) {
-    account.data = null;
+  return validate(account);
+};
+
+const updateOrCreate = (state, attrs, context) => {
+  if (state) {
+    return update(state, attrs, context);
+  }
+
+  return create(attrs, context);
+};
+
+const validate = (state) => {
+  // ensure we have correct pk
+  if (state.pk && typeof state.pk !== 'string') {
+    state.pk = toBase58(state.pk);
+  }
+
+  const { value, error } = schema.validate(state);
+  if (error) {
+    throw new Error(`Invalid account: ${error.details.map((x) => x.message).join(', ')}`);
+  }
+
+  if (!value.data) {
+    value.data = null;
   }
 
-  return account;
+  return value;
 };
 
 const isMigrated = (state) => (state.migratedTo || []).length > 0;
 
-module.exports = { create, update, isMigrated };
+module.exports = { create, update, updateOrCreate, validate, isMigrated };

package/lib/states/chain.js

@@ -7,7 +7,7 @@ const create = (attrs) => {
   const context = { txTime: new Date().toISOString() };
   const chain = {
     context: createStateContext(context),
-    ...pick(attrs, ['address', 'chainId', 'version', 'transaction', 'moderator', 'accounts', 'token']),
+    ...pick(attrs, ['address', 'chainId', 'version', 'transaction', 'moderator', 'accounts', 'token', 'vaults']),
   };
 
   return chain;
@@ -25,7 +25,7 @@ const update = (state, updates) => {
   const context = { txTime: new Date().toISOString() };
   const chain = {
     ...state,
-    ...pick(updates, ['version', 'transaction', 'accounts']),
+    ...pick(updates, ['version', 'transaction', 'accounts', 'vaults']),
     context: updateStateContext(state.context, context),
   };
 

package/lib/states/evidence.js

@@ -1,11 +1,11 @@
 const pick = require('lodash/pick');
 
-const Joi = require('../joi');
+const Joi = require('@ocap/validator');
 const { create: createStateContext } = require('../contexts/state');
 
 const schema = Joi.object({
   hash: Joi.string().trim().required(),
-  context: Joi.contextSchema,
+  context: Joi.schemas.context,
   data: Joi.any().optional(),
 }).options({ stripUnknown: true, noDefaults: false });
 

package/lib/states/rollup-block.js

@@ -1,22 +1,22 @@
 const pick = require('lodash/pick');
 
-const Joi = require('../joi');
+const Joi = require('@ocap/validator');
 const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
 
 const schema = Joi.object({
-  hash: Joi.string().regex(Joi.hashRegexp).required(),
+  hash: Joi.string().regex(Joi.patterns.txHash).required(),
   height: Joi.number().integer().greater(0).required(),
-  merkleRoot: Joi.string().regex(Joi.hashRegexp).required(),
+  merkleRoot: Joi.string().regex(Joi.patterns.txHash).required(),
   previousHash: Joi.string().when('height', {
     is: 1,
     then: Joi.string().optional().allow(''),
-    otherwise: Joi.string().regex(Joi.hashRegexp).required(),
+    otherwise: Joi.string().regex(Joi.patterns.txHash).required(),
   }),
-  txsHash: Joi.string().regex(Joi.hashRegexp).required(),
-  txs: Joi.array().items(Joi.string().regex(Joi.hashRegexp).required()).min(1).unique().required(),
+  txsHash: Joi.string().regex(Joi.patterns.txHash).required(),
+  txs: Joi.array().items(Joi.string().regex(Joi.patterns.txHash).required()).min(1).unique().required(),
 
   proposer: Joi.DID().wallet('ethereum').required(),
-  signatures: Joi.multiSigSchema.min(1).required(),
+  signatures: Joi.schemas.multiSig.min(1).required(),
 
   rollup: Joi.DID().role('ROLE_ROLLUP').required(),
 
@@ -26,7 +26,7 @@ const schema = Joi.object({
 
   minReward: Joi.BN().min(0).required(),
 
-  context: Joi.contextSchema,
+  context: Joi.schemas.context,
   data: Joi.any().optional(),
 }).options({ stripUnknown: true, noDefaults: false });
 

package/lib/states/rollup.js

@@ -1,6 +1,6 @@
 const pick = require('lodash/pick');
 
-const Joi = require('../joi');
+const Joi = require('@ocap/validator');
 const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
 
 const validator = Joi.object({
@@ -54,14 +54,14 @@ const schema = Joi.object({
   maxWithdrawFee: Joi.BN().min(Joi.ref('minWithdrawFee')).required(),
 
   blockHeight: Joi.number().integer().min(0).required(),
-  blockHash: Joi.string().regex(Joi.hashRegexp).optional().allow(''),
+  blockHash: Joi.string().regex(Joi.patterns.txHash).optional().allow(''),
   issuer: Joi.DID().optional(),
 
   leaveWaitingPeriod: Joi.number().integer().min(Joi.ref('minBlockInterval')).default(0),
   publishWaitingPeriod: Joi.number().integer().min(Joi.ref('minBlockInterval')).default(0),
   publishSlashRate: Joi.number().integer().min(1).max(10000).required(),
 
-  context: Joi.contextSchema,
+  context: Joi.schemas.context,
   data: Joi.any().optional(),
 }).options({ stripUnknown: true, noDefaults: false });
 

package/lib/states/stake.js

@@ -1,20 +1,20 @@
 const pick = require('lodash/pick');
 
-const Joi = require('../joi');
+const Joi = require('@ocap/validator');
 const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
 
 const schema = Joi.object({
   address: Joi.DID().role('ROLE_STAKE').trim().required(),
   sender: Joi.DID().trim().required(),
   receiver: Joi.DID().trim().required(),
-  tokens: Joi.object().default({}),
+  tokens: Joi.object({}).pattern(Joi.DID().role('ROLE_TOKEN'), Joi.BN().min(0)).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(),
   revokeWaitingPeriod: Joi.number().integer().min(0).default(0),
-  revokedTokens: Joi.object().default({}),
+  revokedTokens: Joi.object({}).pattern(Joi.DID().role('ROLE_TOKEN'), Joi.BN().min(0)).default({}),
   revokedAssets: Joi.array().items(Joi.DID().role('ROLE_ASSET')).default([]),
-  context: Joi.contextSchema,
+  context: Joi.schemas.context,
   data: Joi.any().optional(),
 }).options({ stripUnknown: true, noDefaults: false });
 

package/package.json

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

package/lib/joi/extension/bn.js

@@ -1,130 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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;