@ocap/state 1.6.5 → 1.6.10

package/lib/contexts/state.js

@@ -0,0 +1,19 @@
+// StateContext utils for account/asset/delegate etc.
+
+const create = ({ txHash, txTime }) => ({
+  genesisTime: txTime || '',
+  genesisTx: txHash || '',
+  renaissanceTime: txTime || '',
+  renaissanceTx: txHash || '',
+});
+
+const update = (context, { txHash, txTime }) => ({
+  ...context,
+  // NOTE: for historical reasons, some account state does not have genesisTime
+  genesisTime: context.genesisTime || '2020-01-15T00:00:00.000Z',
+  genesisTx: context.genesisTx || '',
+  renaissanceTime: txTime || '',
+  renaissanceTx: txHash || '',
+});
+
+module.exports = { create, update };

package/lib/index.js

@@ -1,8 +1,57 @@
+const chain = require('./states/chain');
 const account = require('./states/account');
 const asset = require('./states/asset');
 const delegation = require('./states/delegation');
 const tx = require('./states/tx');
+const factory = require('./states/factory');
+const token = require('./states/token');
+const stake = require('./states/stake');
+const rollup = require('./states/rollup');
+const rollupBlock = require('./states/rollup-block');
+const evidence = require('./states/evidence');
 
 const Blacklist = require('./states/blacklist');
 
-module.exports = { account, asset, delegation, tx, Blacklist };
+module.exports = {
+  chain,
+  account,
+  asset,
+  factory,
+  delegation,
+  tx,
+  token,
+  stake,
+  rollup,
+  rollupBlock,
+  evidence,
+
+  // indexes of the statedb to speed up reading
+  indexes: [
+    'account',
+    'asset',
+    'delegation',
+    'tx',
+    'factory',
+    'token',
+    'stake',
+    'rollup',
+    'rollupBlock',
+    'rollupValidator',
+  ],
+
+  tables: [
+    'chain',
+    'account',
+    'asset',
+    'delegation',
+    'tx',
+    'factory',
+    'token',
+    'stake',
+    'rollup',
+    'rollupBlock',
+    'evidence', // a simple key-value store
+  ],
+
+  Blacklist,
+};

package/lib/states/account.js

@@ -1,59 +1,93 @@
 const pick = require('lodash/pick');
 const uniq = require('lodash/uniq');
 const flatten = require('lodash/flatten');
-const { toBase64, toUint8Array } = require('@ocap/util');
+const Error = require('@ocap/util/lib/error');
+const { isFromPublicKey } = require('@arcblock/did');
+const { isEthereumDid, toChecksumAddress } = require('@arcblock/did/lib/type');
+const { toBase58, BN } = require('@ocap/util');
 
-const { create: createStateContext, update: updateStateContext } = require('./contexts/state');
+const Joi = require('@arcblock/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: 2,
-    numTxs: 1,
-    numAssets: 0,
+    nonce: 0,
     migratedTo: [],
     migratedFrom: [],
-    stake: null,
+    tokens: {},
     context: createStateContext(context),
-    poke: {},
-    ...pick(attrs, ['address', 'pk', 'issuer', 'balance', 'moniker', 'data', 'migratedFrom', 'poke']),
+    ...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;
-  }
+  account.address = ensureChecksumAddress(account.address);
 
-  context.emit('account.create', account, context);
-
-  return account;
+  return validate(account);
 };
 
 const update = (state, attrs, context) => {
+  if (attrs.nonce && new BN(attrs.nonce).eq(new BN(state.nonce))) {
+    throw new Error('INVALID_NONCE', '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,
-    nonce: state.nonce + 1,
-    numTxs: state.numTxs + 1,
-    ...pick(attrs, ['balance', 'moniker', 'data', 'migratedTo', 'nonce', 'poke', 'numAssets']),
+    ...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);
   }
 
-  context.emit('account.update', account, 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', `Invalid account: ${error.details.map((x) => x.message).join(', ')}`);
+  }
+
+  if (!value.data) {
+    value.data = null;
+  }
 
-  return account;
+  return value;
 };
 
-const getRelatedAddresses = (state) => [state.address].concat(state.migratedFrom).filter(Boolean);
 const isMigrated = (state) => (state.migratedTo || []).length > 0;
+const ensureChecksumAddress = (address) => (isEthereumDid(address) ? toChecksumAddress(address) : address);
 
-module.exports = { create, update, getRelatedAddresses, isMigrated };
+module.exports = { create, update, updateOrCreate, validate, isMigrated, ensureChecksumAddress };

package/lib/states/asset.js

@@ -1,6 +1,40 @@
 const pick = require('lodash/pick');
+const Joi = require('@arcblock/validator');
+const Error = require('@ocap/util/lib/error');
 
-const { create: createStateContext, update: updateStateContext } = require('./contexts/state');
+const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
+
+const props = {
+  address: Joi.DID().role('ROLE_ASSET').required(),
+  moniker: Joi.string().min(2).max(255).required(),
+  data: Joi.any().required(),
+  readonly: Joi.boolean().default(false),
+  transferrable: Joi.boolean().default(false),
+  ttl: Joi.number().min(0).default(0),
+  parent: Joi.DID().optional().allow(''),
+  issuer: Joi.DID().optional().allow(''),
+  endpoint: Joi.object({
+    id: Joi.string().uri({ scheme: ['http', 'https'] }).required(), // prettier-ignore
+    scope: Joi.string().valid('public', 'private').default('public'),
+  }).optional(),
+  display: Joi.object({
+    type: Joi.string().valid('svg', 'url', 'uri').required(),
+    content: Joi.string()
+      .when('type', { is: 'uri', then: Joi.string().dataUri().required() })
+      .when('type', { is: 'url', then: Joi.string().uri({ scheme: ['http', 'https'] }).required() }), // prettier-ignore
+  }).optional(),
+  tags: Joi.array().items(Joi.string().min(1)).optional(),
+};
+
+const schema = Joi.object({
+  ...props,
+  owner: Joi.DID().required(),
+  consumedTime: Joi.date().iso().raw().allow(''),
+  context: Joi.schemas.context,
+}).options({
+  stripUnknown: true,
+  noDefaults: false,
+});
 
 const create = (attrs, context) => {
   const asset = {
@@ -10,34 +44,62 @@ const create = (attrs, context) => {
     readonly: false,
     transferrable: true,
     ttl: 0, // means unlimited
-    stake: null,
+    tags: [],
     context: createStateContext(context),
-    ...pick(attrs, ['address', 'owner', 'issuer', 'moniker', 'parent', 'data', 'readonly', 'transferrable', 'ttl']),
+    ...pick(attrs, [
+      'address',
+      'owner',
+      'issuer',
+      'moniker',
+      'parent',
+      'data',
+      'readonly',
+      'transferrable',
+      'ttl',
+      'endpoint',
+      'display',
+      'tags',
+    ]),
   };
 
-  if (!asset.data) {
-    asset.data = null;
-  }
-
-  context.emit('asset.create', asset, context);
-
-  return asset;
+  return validate(asset);
 };
 
 const update = (state, attrs, context) => {
   const asset = {
     ...state,
-    ...pick(attrs, ['moniker', 'data', 'owner']),
+    ...pick(attrs, ['moniker', 'data', 'owner', 'consumedTime']),
     context: updateStateContext(state.context, context),
   };
 
-  if (!asset.data) {
-    asset.data = null;
+  if (!asset.consumedTime) {
+    asset.consumedTime = '';
   }
 
-  context.emit('asset.update', asset, context);
+  return validate(asset);
+};
+
+const validate = (state) => {
+  const { value, error } = schema.validate(state);
+  if (error) {
+    throw new Error('INVALID_ASSET', `Invalid asset: ${error.details.map((x) => x.message).join(', ')}`);
+  }
 
-  return asset;
+  ['endpoint', 'display'].forEach((key) => {
+    if (!value[key]) {
+      delete value[key];
+    }
+  });
+
+  return value;
 };
 
-module.exports = { create, update };
+module.exports = {
+  create,
+  update,
+  validate,
+  schema: Joi.object(props).options({
+    stripUnknown: true,
+    noDefaults: false,
+  }),
+};

package/lib/states/blacklist.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const Error = require('@ocap/util/lib/error');
 const { BloomFilter } = require('bloom-filters');
 
 class Blacklist {
@@ -10,7 +11,7 @@ class Blacklist {
         const json = JSON.parse(fs.readFileSync(dumpPath));
         filter = BloomFilter.fromJSON(json);
       } catch (err) {
-        throw new Error(`Cat not read serialized blacklist from json${dumpPath}`);
+        throw new Error('INTERNAL', `Cat not read serialized blacklist from json${dumpPath}`);
       }
     }
 

package/lib/states/chain.js

@@ -0,0 +1,36 @@
+const pick = require('lodash/pick');
+const isEqual = require('lodash/isEqual');
+const Error = require('@ocap/util/lib/error');
+
+const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
+
+const create = (attrs) => {
+  const context = { txTime: new Date().toISOString() };
+  const chain = {
+    context: createStateContext(context),
+    ...pick(attrs, ['address', 'chainId', 'version', 'transaction', 'moderator', 'accounts', 'token', 'vaults']),
+  };
+
+  return chain;
+};
+
+const update = (state, updates) => {
+  const immutableAttrs = ['chainId', 'token', 'moderator'];
+  // eslint-disable-next-line no-restricted-syntax
+  for (const attr of immutableAttrs) {
+    if (updates[attr] && isEqual(updates[attr], state[attr]) === false) {
+      throw new Error('FORBIDDEN', `Cannot update ${attr} field on chain state`);
+    }
+  }
+
+  const context = { txTime: new Date().toISOString() };
+  const chain = {
+    ...state,
+    ...pick(updates, ['version', 'transaction', 'accounts', 'vaults']),
+    context: updateStateContext(state.context, context),
+  };
+
+  return chain;
+};
+
+module.exports = { create, update };

package/lib/states/delegation.js

@@ -1,6 +1,6 @@
 const pick = require('lodash/pick');
 
-const { create: createStateContext, update: updateStateContext } = require('./contexts/state');
+const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
 
 const create = (attrs, context) => {
   const delegation = {
@@ -12,8 +12,6 @@ const create = (attrs, context) => {
     delegation.data = null;
   }
 
-  context.emit('delegation.create', delegation, context);
-
   return delegation;
 };
 
@@ -28,8 +26,6 @@ const update = (state, attrs, context) => {
     delegation.data = null;
   }
 
-  context.emit('delegation.update', delegation, context);
-
   return delegation;
 };
 

package/lib/states/evidence.js

@@ -0,0 +1,35 @@
+const pick = require('lodash/pick');
+const Error = require('@ocap/util/lib/error');
+const Joi = require('@arcblock/validator');
+
+const { create: createStateContext } = require('../contexts/state');
+
+const schema = Joi.object({
+  hash: Joi.string().trim().required(),
+  context: Joi.schemas.context,
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+
+const create = (attrs, context) => {
+  const evidence = {
+    context: createStateContext(context),
+    ...pick(attrs, ['hash', 'data']),
+  };
+
+  return validate(evidence);
+};
+
+const validate = (state) => {
+  const { value, error } = schema.validate(state);
+  if (error) {
+    throw new Error('INVALID_EVIDENCE', `Invalid evidence state: ${error.details.map((x) => x.message).join(', ')}`);
+  }
+
+  if (!value.data) {
+    value.data = null;
+  }
+
+  return value;
+};
+
+module.exports = { create, validate, schema };

package/lib/states/factory.js

@@ -0,0 +1,62 @@
+const pick = require('lodash/pick');
+const { compile, merge, getQuota } = require('@ocap/contract');
+
+const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
+
+const compileHook = (hook, quota) => {
+  if (hook.type === 'contract') {
+    hook.compiled = merge(compile(hook.hook, quota));
+  }
+
+  return hook;
+};
+
+const create = (attrs, context) => {
+  const factory = {
+    address: '',
+    owner: '',
+    name: '',
+    description: '',
+    settlement: 'instant',
+    limit: 0,
+    numMinted: 0,
+    lastSettlement: '',
+    balance: '0',
+    tokens: {},
+    trustedIssuers: [],
+    stake: null,
+    context: createStateContext(context),
+    ...pick(attrs, [
+      'address',
+      'owner',
+      'name',
+      'description',
+      'settlement',
+      'limit',
+      'tokens',
+      'trustedIssuers',
+      'input',
+      'output',
+      'display',
+      'hooks',
+      'data',
+    ]),
+  };
+
+  if (!factory.data) {
+    factory.data = null;
+  }
+
+  const quota = getQuota(factory.input);
+  factory.hooks = (factory.hooks || []).map((x) => compileHook(x, quota));
+
+  return factory;
+};
+
+const update = (state, attrs, context) => ({
+  ...state,
+  ...pick(attrs, ['numMinted', 'tokens']),
+  context: updateStateContext(state.context, context),
+});
+
+module.exports = { create, update };

package/lib/states/rollup-block.js

@@ -0,0 +1,81 @@
+const pick = require('lodash/pick');
+const Error = require('@ocap/util/lib/error');
+const Joi = require('@arcblock/validator');
+
+const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
+
+const schema = Joi.object({
+  hash: Joi.string().regex(Joi.patterns.txHash).required(),
+  height: Joi.number().integer().greater(0).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.patterns.txHash).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.schemas.multiSig.min(1).required(),
+
+  rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+
+  mintedAmount: Joi.BN().min(0).optional().default('0'),
+  burnedAmount: Joi.BN().min(0).optional().default('0'),
+  rewardAmount: Joi.BN().min(0).optional().default('0'),
+
+  minReward: Joi.BN().min(0).required(),
+
+  context: Joi.schemas.context,
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+
+const create = (attrs, context) => {
+  const block = {
+    context: createStateContext(context),
+    ...pick(attrs, [
+      'hash',
+      'height',
+      'merkleRoot',
+      'previousHash',
+      'txsHash',
+      'txs',
+      'proposer',
+      'signatures',
+      'rollup',
+      'mintedAmount',
+      'burnedAmount',
+      'rewardAmount',
+      'minReward',
+      'data',
+    ]),
+  };
+
+  return validate(block);
+};
+
+// We only support update block context
+const update = (state, context) => {
+  const rollup = {
+    ...state,
+    context: updateStateContext(state.context, context),
+  };
+
+  return validate(rollup);
+};
+
+const validate = (state) => {
+  const { value, error } = schema.validate(state);
+  if (error) {
+    throw new Error('INVALID_ROLLUP_BLOCK', `Invalid rollup block: ${error.details.map((x) => x.message).join(', ')}`);
+  }
+
+  if (!value.data) {
+    value.data = null;
+  }
+
+  return value;
+};
+
+module.exports = { create, update, validate, schema };