采用新结构：Action*.js 从 node.server 中删除，集中存放于本库。

这样消除了同一份代码出现在两处的不良结构，避免了同步的困难。
当 node.server 需要临时修改 ActionXxx.js 时，只要在 server.js 里临时 require('../tic.action').ActionXxx 即可。一处修改，到处可用。

Action.js

@@ -6,6 +6,7 @@ var Ticrypto = require('tic.crypto')
 const DAD = module.exports = function Action (prop) {
   this._class = this.constructor.name
   this.setProp(prop)
+  this.type = this.constructor.name
 }
 DAD.__proto__ = Ling
 DAD._table = DAD.name
@@ -29,7 +30,7 @@ MOM._model = {
   message: { default: undefined, sqlite: 'TEXT', mysql: 'VARCHAR(256)' },
   dataIndex: { default: undefined, sqlite: 'TEXT', mysql: 'VARCHAR(50)' }, // 用于索引json中存储数据，
   method: { default: undefined, sqlite: 'TEXT' },
-  data: { default: undefined, sqlite: 'TEXT' }
+  json: { default: undefined, sqlite: 'TEXT' } // 给不同类型的 ActionXxx 子类来自定义其所需的数据结构
 }
 
 MOM.packMe = function (keypair) { // 由前端调用，后台不创建
@@ -78,14 +79,28 @@ DAD.verifyHash = function (action) {
   return action.hash === Ticrypto.hash(DAD.getJson(action, { exclude: ['hash', 'blockHash'] }))
 }
 
-DAD.execute = function () { // 子类应当覆盖本方法。把action的影响，汇总登记到其他表格（用于辅助的、索引的表格），方便快速索引、处理。每种事务类型都要重定义这个方法。
-  // save to account or other tables
-  return this
+MOM.validateMe = async function() { // 子类应当覆盖本方法。
+  // to implement in subclasses: 检查子类事务内容的格式
+  let typedAction = new wo[this.type](this)
+  return await typedAction.validateMe()
+}
+DAD.validate = async function (action) {
+  mylog.info(`Validating action type=${action.type} of hash=${action.hash}`)
+  let typedAction = new wo[action.type](action)
+  return await typedAction.validateMe()
 }
 
-DAD.calculateFee = function () {
-  return 1000
+MOM.executeMe = async function() { // 子类应当覆盖本方法。
+  // to implement in subclasses: 把action的影响，汇总登记到其他表格（用于辅助的、索引的表格），方便快速索引、处理。每种事务类型都要重定义这个方法。
+  let typedAction = new wo[this.type](this)
+  return await typedAction.executeMe()
 }
+DAD.execute = async function (action) {
+  mylog.info(`Excecuting action type=${action.type} of hash=${action.hash}`)
+  let typedAction = new wo[action.type](action)
+  return await typedAction.executeMe()
+}
+
 /**
  * 获取一批交易，在出块时调用。调用actionPool的内容被深拷贝到currentActionPool后自动清空。
  * 所以在一次出块期间只能调用一次
@@ -116,24 +131,29 @@ DAD.api.getActionList = async function (option) {
 }
 
 DAD.api.prepare = async function (option) {
-  // 前端发来action数据，进行初步检查（不检查是否可执行--这和事务类型、执行顺序有关，只检查格式是否有效--这是所有事务通用的规范）后放入缓冲池。
+  if (typeof option === 'string') {
+    try {
+      option = JSON.parse(option)
+    } catch (error) {}
+  }
+  // 前端发来action数据，进行格式检查（不检查是否可执行--这和事务类型、执行顺序有关）后放入缓冲池。
   if (option && option.Action && option.Action.type && option.Action.hash && !DAD.actionPool[option.Action.hash]) {
-    if (DAD.verifyAddress(option.Action) &&
+    if (DAD.verifyAddress(option.Action) && // 只检查所有事务通用的格式
         DAD.verifySig(option.Action) &&
         DAD.verifyHash(option.Action) &&
         !DAD.actionPool[option.Action.hash] &&
-        (await wo[option.Action.type].validate(option.Action))
+        (await DAD.validate(option.Action)) // 调用子类的 validate 方法，检查子类的事务内容格式
     ) {
       DAD.actionPool[option.Action.hash] = option.Action
       DAD.actionPoolInfo.totalAmount += option.Action.amount || 0
       DAD.actionPoolInfo.totalFee += option.Action.fee || 0
-      wo.Node.broadcast('/Action/prepare', option)
+      wo.NodeNet.broadcast({ Action: option.Action })
       return option.Action
     }
   }
   return null // 非法的交易数据
 }
-
+wo.NodeNet.on('broadcast', DAD.api.prepare)
 /** ******************** Private in class *******************/
 
 DAD.actionPool = {} // 交易池，在执行getActionBatch时被清空