@ocap/state 1.28.9 → 1.29.0

package/lib/states/blacklist.js

@@ -1,103 +0,0 @@
-const fs = require('node:fs');
-const { isSameDid } = require('@ocap/util');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { BloomFilter } = require('bloom-filters');
-
-class Blacklist {
-  constructor({
-    size = 256,
-    numHashFns = 4,
-    dumpPath = '',
-    dumpInterval = 0,
-    getBlockedAccounts = null,
-    getTrustedAccounts = null,
-  } = {}) {
-    let filter;
-
-    if (dumpPath && fs.existsSync(dumpPath)) {
-      try {
-        const json = JSON.parse(fs.readFileSync(dumpPath));
-        filter = BloomFilter.fromJSON(json);
-      } catch (_err) {
-        throw new Error('INTERNAL', `Cat not read serialized blacklist from json${dumpPath}`);
-      }
-    }
-
-    if (!filter) {
-      filter = new BloomFilter(size, numHashFns);
-    }
-
-    this.dumpPath = dumpPath;
-    this.filter = filter;
-    this.getBlockedAccounts = getBlockedAccounts;
-    this.getTrustedAccounts = getTrustedAccounts;
-
-    if (dumpPath && dumpInterval > 0) {
-      this.timer = setTimeout(() => {
-        this.dump();
-
-        // Schedule for next
-        this.timer = setTimeout(() => {
-          this.dump();
-        }, dumpInterval);
-        this.timer.unref();
-      }, dumpInterval);
-      this.timer.unref();
-
-      process.on('beforeExit', () => {
-        this.dump();
-      });
-    }
-  }
-
-  has(key) {
-    return this.filter.has(key);
-  }
-
-  add(key) {
-    return this.filter.add(key);
-  }
-
-  async isBlocked(address) {
-    if (typeof this.getBlockedAccounts === 'function') {
-      const blocked = await this.getBlockedAccounts();
-      if (blocked.length) {
-        return blocked.some((b) => isSameDid(b, address));
-      }
-    }
-
-    return false;
-  }
-
-  async isTrusted(address) {
-    if (typeof this.getTrustedAccounts === 'function') {
-      const trustedAccounts = await this.getTrustedAccounts();
-      if (trustedAccounts.length) {
-        return trustedAccounts.some((b) => isSameDid(b, address));
-      }
-    }
-
-    return false;
-  }
-
-  async getTrustedAccountConfig(address) {
-    if (typeof this.getTrustedAccounts === 'function') {
-      const trustedAccounts = await this.getTrustedAccounts();
-      return trustedAccounts.find((x) => isSameDid(x.address, address));
-    }
-    return null;
-  }
-
-  dump() {
-    try {
-      const exported = this.filter.saveAsJSON();
-      const tmpFile = `${this.dumpPath}~`;
-      fs.writeFileSync(tmpFile, JSON.stringify(exported));
-      fs.renameSync(tmpFile, this.dumpPath);
-    } catch (_err) {
-      // Do nothing
-    }
-  }
-}
-
-module.exports = Blacklist;

package/lib/states/chain.js

@@ -1,49 +0,0 @@
-const pick = require('lodash/pick');
-const isEqual = require('lodash/isEqual');
-const get = require('lodash/get');
-const { CustomError: 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', 'moderator', 'token.symbol', 'token.decimal'];
-
-  // should not update these attrs cause the token address is generated from these attrs
-  if (!process.env.CHAIN_TOKEN_ADDRESS) {
-    immutableAttrs.push(
-      'token.name',
-      'token.description',
-      'token.unit',
-      'token.totalSupply',
-      'token.initialSupply',
-      'token.foreignToken'
-    );
-  }
-
-  for (const attr of immutableAttrs) {
-    if (get(updates, attr) && !isEqual(get(updates, attr), get(state, attr))) {
-      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', 'token']),
-    context: updateStateContext(state.context, context),
-  };
-
-  return chain;
-};
-
-module.exports = { create, update };

package/lib/states/delegation.js

@@ -1,46 +0,0 @@
-const pick = require('lodash/pick');
-const { toAddress } = require('@ocap/util');
-
-// FIXME: add better validation
-const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
-const { nullify } = require('../util');
-
-const create = (attrs, context) => {
-  const delegation = {
-    context: createStateContext(context),
-    ...pick(attrs, ['address', 'to', 'from', 'ops', 'data']),
-  };
-
-  if (!delegation.data) {
-    delegation.data = null;
-  }
-
-  delegation.address = toAddress(delegation.address);
-  delegation.ops = nullify(delegation.ops);
-
-  return delegation;
-};
-
-const update = (state, attrs, context) => {
-  const delegation = {
-    ...state,
-    ...pick(attrs, ['ops', 'data']),
-    context: updateStateContext(state.context, context),
-  };
-
-  if (!delegation.data) {
-    delegation.data = null;
-  }
-  if (!state.to && attrs.to) {
-    delegation.to = toAddress(attrs.to);
-  }
-  if (!state.from && attrs.from) {
-    delegation.from = toAddress(attrs.from);
-  }
-
-  delegation.ops = nullify(delegation.ops);
-
-  return delegation;
-};
-
-module.exports = { create, update };

package/lib/states/evidence.js

@@ -1,35 +0,0 @@
-const pick = require('lodash/pick');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { Joi, schemas, patterns } = require('@arcblock/validator');
-
-const { create: createStateContext } = require('../contexts/state');
-
-const schema = Joi.object({
-  hash: Joi.string().regex(patterns.txHash).required(),
-  context: schemas.context,
-  data: Joi.any().optional().allow(null),
-}).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

@@ -1,92 +0,0 @@
-const pick = require('lodash/pick');
-const { Joi, schemas } = require('@arcblock/validator');
-const { compile, merge, getQuota } = require('@ocap/contract');
-const { toAddress } = require('@ocap/util');
-
-const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
-
-const stateSchema = Joi.object({
-  ...schemas.factoryProps,
-  owner: Joi.DID().prefix().required(),
-  numMinted: Joi.number().min(0).default(0),
-  lastSettlement: Joi.date().iso().raw().allow(''),
-  tokens: Joi.object().pattern(Joi.DID().prefix().role('ROLE_TOKEN'), Joi.BN().min(0)).default({}),
-  context: schemas.context,
-}).options({
-  stripUnknown: true,
-  noDefaults: false,
-});
-
-const compileHook = (hook, quota) => {
-  if (hook.type === 'contract') {
-    hook.compiled = merge(compile(hook.hook, quota));
-  }
-
-  return hook;
-};
-
-const create = (attrs, context) => {
-  const factory = {
-    numMinted: 0,
-    lastSettlement: '',
-    tokens: {},
-    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));
-
-  factory.address = toAddress(factory.address);
-
-  return validate(factory);
-};
-
-const update = (state, attrs, context) => {
-  const factory = {
-    ...state,
-    ...pick(attrs, ['numMinted', 'tokens']),
-    context: updateStateContext(state.context, context),
-  };
-
-  if (factory.output?.tags === null) {
-    factory.output.tags = [];
-  }
-
-  return validate(factory);
-};
-
-const validate = (state) => {
-  const { value, error } = stateSchema.validate(state);
-  if (error) {
-    throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(', ')}`);
-  }
-
-  ['display'].forEach((key) => {
-    if (!value[key]) {
-      delete value[key];
-    }
-  });
-
-  return value;
-};
-
-module.exports = { create, update, validate };

package/lib/states/rollup-block.js

@@ -1,84 +0,0 @@
-const pick = require('lodash/pick');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { Joi, schemas, patterns } = require('@arcblock/validator');
-
-const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
-
-const schema = Joi.object({
-  hash: Joi.string().regex(patterns.txHash).required(),
-  height: Joi.number().integer().greater(0).required(),
-  merkleRoot: Joi.string().regex(patterns.txHash).required(),
-  previousHash: Joi.string().when('height', {
-    is: 1,
-    then: Joi.string().optional().allow(null).allow(''),
-    otherwise: Joi.string().regex(patterns.txHash).required(),
-  }),
-  txsHash: Joi.string().regex(patterns.txHash).required(),
-  txs: Joi.array().items(Joi.string().regex(patterns.txHash).required()).min(1).unique().required(),
-
-  proposer: Joi.DID().prefix().wallet('ethereum').required(),
-  signatures: schemas.multiSig.min(1).required(),
-
-  rollup: Joi.DID().prefix().role('ROLE_ROLLUP').required(),
-
-  mintedAmount: Joi.BN().min(0).optional().allow(null).default('0'),
-  burnedAmount: Joi.BN().min(0).optional().allow(null).default('0'),
-  rewardAmount: Joi.BN().min(0).optional().allow(null).default('0'),
-
-  minReward: Joi.BN().min(0).required(),
-
-  governance: Joi.boolean().default(false),
-
-  context: schemas.context,
-  data: Joi.any().optional().allow(null),
-}).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',
-      'governance',
-      '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 };

package/lib/states/rollup.js

@@ -1,297 +0,0 @@
-const pick = require('lodash/pick');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { toAddress } = require('@ocap/util');
-
-const { Joi, schemas, patterns } = require('@arcblock/validator');
-const { create: createStateContext, update: updateStateContext } = require('../contexts/state');
-
-const validator = Joi.object({
-  pk: Joi.string().required(),
-  address: Joi.DID().prefix().required(),
-  endpoint: Joi.string()
-    .uri({ scheme: [/https?/] })
-    .required(),
-});
-
-const schema = Joi.object({
-  // a closed rollup must be paused
-  address: Joi.DID().prefix().role('ROLE_ROLLUP').required(),
-  tokenAddress: Joi.DID().prefix().role('ROLE_TOKEN').required(),
-  contractAddress: Joi.DID().prefix().wallet('ethereum').required(),
-  vaultAddress: Joi.DID().wallet('ethereum').optional().allow(null).allow(''), // FIXME: this should be enforced
-  migrateHistory: Joi.array().items(Joi.DID().prefix().wallet('ethereum')).default([]),
-  vaultHistory: Joi.array().items(Joi.DID().prefix().wallet('ethereum')).default([]),
-  paused: Joi.boolean().default(false),
-  closed: Joi.boolean().default(false),
-
-  seedValidators: Joi.array().items(validator).min(1).required(),
-  validators: Joi.array().items(validator).max(24).default([]),
-
-  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).min(Joi.ref('minSignerCount')).required(),
-
-  minBlockSize: Joi.number().integer().min(1).required(),
-  maxBlockSize: Joi.number().integer().min(1).max(15).min(Joi.ref('minBlockSize')).required(),
-
-  minBlockInterval: Joi.number()
-    .integer()
-    .min(1)
-    .max(60 * 60)
-    .required(), // in seconds
-  minBlockConfirmation: Joi.number().integer().min(1).max(100).required(),
-
-  minDepositAmount: Joi.BN().positive().less(Joi.ref('minStakeAmount')).required(),
-  maxDepositAmount: Joi.BN().greater(Joi.ref('minDepositAmount')).less(Joi.ref('minStakeAmount')).required(),
-  minWithdrawAmount: Joi.BN().positive().required(),
-  maxWithdrawAmount: Joi.BN().greater(Joi.ref('minWithdrawAmount')).required(),
-
-  depositFeeRate: Joi.number().integer().min(0).max(10000).required(),
-  withdrawFeeRate: Joi.number().integer().min(0).max(10000).required(),
-  proposerFeeShare: Joi.number().integer().min(1).max(10000).required(),
-  publisherFeeShare: Joi.number().integer().min(1).max(10000).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(patterns.txHash).optional().allow(null).allow(''),
-  issuer: Joi.DID().prefix().optional().allow(null),
-
-  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: schemas.context,
-  data: Joi.any().optional().allow(null),
-}).options({ stripUnknown: true, noDefaults: false });
-
-const create = (attrs, context) => {
-  const rollup = {
-    context: createStateContext(context),
-    paused: false,
-    closed: false,
-    migrateHistory: [],
-    vaultHistory: [],
-    blockHeight: 0,
-    blockHash: '',
-    ...pick(attrs, [
-      'address',
-      'tokenAddress',
-      'vaultAddress',
-      'contractAddress',
-      'seedValidators',
-      'validators',
-      'minStakeAmount',
-      'maxStakeAmount',
-      'minSignerCount',
-      'maxSignerCount',
-      'minBlockSize',
-      'maxBlockSize',
-      'minBlockInterval',
-      'minBlockConfirmation',
-      'minDepositAmount',
-      'maxDepositAmount',
-      'minWithdrawAmount',
-      'maxWithdrawAmount',
-      'depositFeeRate',
-      'withdrawFeeRate',
-      'proposerFeeShare',
-      'publisherFeeShare',
-      'minDepositFee',
-      'maxDepositFee',
-      'minWithdrawFee',
-      'maxWithdrawFee',
-      'leaveWaitingPeriod',
-      'publishWaitingPeriod',
-      'publishSlashRate',
-      'issuer',
-      'data',
-    ]),
-  };
-
-  rollup.address = toAddress(rollup.address);
-
-  return validate(rollup);
-};
-
-const update = (state, updates, context) => {
-  // latest block height must be incremented on each update
-  // latest block hash must be updated together with block height
-  if (updates.blockHeight && !updates.blockHash) {
-    throw new Error('INVALID_ROLLUP_UPDATE', 'blockHash must be updated together with blockHeight');
-  }
-  if (updates.blockHash && !updates.blockHeight) {
-    throw new Error('INVALID_ROLLUP_UPDATE', 'blockHeight must be updated together with blockHash');
-  }
-  if (updates.blockHeight && updates.blockHash) {
-    if (updates.blockHeight !== state.blockHeight + 1) {
-      throw new Error('INVALID_ROLLUP_UPDATE', 'blockHeight must be incremented');
-    }
-    if (updates.blockHash === state.blockHash) {
-      throw new Error('INVALID_ROLLUP_UPDATE', 'blockHash can not remain unchanged between blocks');
-    }
-  }
-
-  if (typeof updates.blockHeight !== 'undefined' && !updates.blockHeight) {
-    throw new Error('INVALID_ROLLUP_UPDATE', 'blockHeight can not be unset');
-  }
-  if (typeof updates.blockHash !== 'undefined' && !updates.blockHash) {
-    throw new Error('INVALID_ROLLUP_UPDATE', 'blockHash can not be unset');
-  }
-
-  const rollup = {
-    ...state,
-    ...pick(updates, [
-      'validators',
-      'minStakeAmount',
-      'maxStakeAmount',
-      'minSignerCount',
-      'maxSignerCount',
-      'minBlockSize',
-      'maxBlockSize',
-      'minBlockInterval',
-      'minBlockConfirmation',
-      'minDepositAmount',
-      'maxDepositAmount',
-      'minWithdrawAmount',
-      'maxWithdrawAmount',
-      'depositFeeRate',
-      'withdrawFeeRate',
-      'publisherFeeShare',
-      'minDepositFee',
-      'maxDepositFee',
-      'minWithdrawFee',
-      'maxWithdrawFee',
-      'blockHeight',
-      'blockHash',
-      'leaveWaitingPeriod',
-      'publishWaitingPeriod',
-      'publishSlashRate',
-      'data',
-    ]),
-    context: updateStateContext(state.context, context),
-  };
-
-  return validate(rollup);
-};
-
-const pause = (state, context) => {
-  if (state.closed) {
-    throw new Error('INVALID_PAUSE_ATTEMPT', 'rollup already closed');
-  }
-  if (state.paused) {
-    throw new Error('INVALID_PAUSE_ATTEMPT', 'rollup already paused');
-  }
-
-  const rollup = {
-    ...state,
-    paused: true,
-    context: updateStateContext(state.context, context),
-  };
-
-  return validate(rollup);
-};
-
-const close = (state, context) => {
-  if (state.closed) {
-    throw new Error('INVALID_CLOSE_ATTEMPT', 'rollup already closed');
-  }
-  if (!state.paused) {
-    throw new Error('INVALID_CLOSE_ATTEMPT', 'rollup must be paused');
-  }
-
-  const rollup = {
-    ...state,
-    closed: true,
-    context: updateStateContext(state.context, context),
-  };
-
-  return validate(rollup);
-};
-
-const resume = (state, context) => {
-  if (state.closed) {
-    throw new Error('INVALID_RESUME_ATTEMPT', 'rollup is closed');
-  }
-  if (state.paused === false) {
-    throw new Error('INVALID_RESUME_ATTEMPT', 'rollup not paused');
-  }
-
-  const rollup = {
-    ...state,
-    paused: false,
-    context: updateStateContext(state.context, context),
-  };
-
-  return validate(rollup);
-};
-
-const migrateContract = (state, to, context) => {
-  if (state.closed) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'rollup is closed');
-  }
-  if (state.paused === false) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'rollup not paused');
-  }
-  if (state.contractAddress === to) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'can not migrate contract to self');
-  }
-  if (state.migrateHistory.includes(to)) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'can not migrate contract to history contracts');
-  }
-
-  const rollup = {
-    ...state,
-    contractAddress: to,
-    migrateHistory: [...state.migrateHistory, state.contractAddress],
-    context: updateStateContext(state.context, context),
-  };
-
-  return validate(rollup);
-};
-
-const migrateVault = (state, to, context) => {
-  if (state.closed) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'rollup is closed');
-  }
-  if (state.paused === false) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'rollup not paused');
-  }
-  if (state.vaultAddress === to) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'can not migrate vault to self');
-  }
-  if (state.vaultHistory.includes(to)) {
-    throw new Error('INVALID_MIGRATE_ATTEMPT', 'can not migrate vault to history vaults');
-  }
-
-  const rollup = {
-    ...state,
-    vaultAddress: to,
-    vaultHistory: [...state.vaultHistory, state.vaultAddress],
-    context: updateStateContext(state.context, context),
-  };
-
-  return validate(rollup);
-};
-
-const validate = (state) => {
-  const { value, error } = schema.validate(state);
-  if (error) {
-    throw new Error('INVALID_ROLLUP_PROPS', error.details.map((x) => x.message).join(', '));
-  }
-
-  if (!value.data) {
-    value.data = null;
-  }
-
-  return value;
-};
-
-module.exports = { create, update, pause, close, resume, migrateContract, migrateVault, validate, schema };