2019011工作日志-关于代币空投合约的编写和js基于koa框架的整合

版权声明：忠于祖国，忠于人民 https://blog.csdn.net/boss2967/article/details/86524148

1. 空投代币智能合约的编写

1.1测试代币的合约的编写

注：代币合约是基于openzeppelin-solidity库实现的，基于truffle框架，koa框架等

• 代币合约的版本是0.4.16
• 

pragma solidity ^0.4.16;
contract Token{
    uint256 public totalSupply;

    function balanceOf(address _owner) public constant returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) public returns   
    (bool success);

    function approve(address _spender, uint256 _value) public returns (bool success);

    function allowance(address _owner, address _spender) public constant returns 
    (uint256 remaining);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 
    _value);
}

contract TokenDemo is Token {

    string public name;                   //名称，例如"My test token"
    uint8 public decimals;               //返回token使用的小数点后几位。比如如果设置为3，就是支持0.001表示.
    string public symbol;               //token简称,like MTT

    function TokenDemo(uint256 _initialAmount, string _tokenName, uint8 _decimalUnits, string _tokenSymbol) public {
        totalSupply = _initialAmount * 10 ** uint256(_decimalUnits);         // 设置初始总量
        balances[msg.sender] = totalSupply; // 初始token数量给予消息发送者，因为是构造函数，所以这里也是合约的创建者

        name = _tokenName;                   
        decimals = _decimalUnits;          
        symbol = _tokenSymbol;
    }

        function transfer(address _to, uint256 _value) public returns (bool success) {
        //默认totalSupply 不会超过最大值 (2^256 - 1).
        //如果随着时间的推移将会有新的token生成，则可以用下面这句避免溢出的异常
        require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
        require(_to != 0x0);
        balances[msg.sender] -= _value;//从消息发送者账户中减去token数量_value
        balances[_to] += _value;//往接收账户增加token数量_value
        Transfer(msg.sender, _to, _value);//触发转币交易事件
        return true;
    }


    function transferFrom(address _from, address _to, uint256 _value) public returns 
    (bool success) {
        require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
        balances[_to] += _value;//接收账户增加token数量_value
        balances[_from] -= _value; //支出账户_from减去token数量_value
        allowed[_from][msg.sender] -= _value;//消息发送者可以从账户_from中转出的数量减少_value
        Transfer(_from, _to, _value);//触发转币交易事件
        return true;
    }
    function balanceOf(address _owner) public constant returns (uint256 balance) {
        return balances[_owner];
    }


    function approve(address _spender, uint256 _value) public returns (bool success)   
    { 
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];//允许_spender从_owner中转出的token数
    }
    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
}

注：个人技术一般，不要太笑话我,这边有一个问题就是编写的时候在本地的话会是import的形式，但是我测试的时候就是在remix在线测试，就直接写成一个文件了 ，编译的时候要选择真正的空投合约

1.2 空投合约编写

pragma solidity ^0.5.0;
 
 library SafeMath {
    /**
    * @dev Multiplies two unsigned integers, reverts on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
    * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
    * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
    * @dev Adds two unsigned integers, reverts on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
    * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
    * reverts when dividing by zero.
    */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

 
interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowed;

    uint256 private _totalSupply;

    /**
    * @dev Total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
    * @dev Gets the balance of the specified address.
    * @param owner The address to query the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address owner) public view returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param owner address The address which owns the funds.
     * @param spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowed[owner][spender];
    }

    /**
    * @dev Transfer token for a specified address
    * @param to The address to transfer to.
    * @param value The amount to be transferred.
    */
    function transfer(address to, uint256 value) public returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @param from address The address which you want to send tokens from
     * @param to address The address which you want to transfer to
     * @param value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
        _transfer(from, to, value);
        emit Approval(from, msg.sender, _allowed[from][msg.sender]);
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when allowed_[_spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when allowed_[_spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
        return true;
    }

    /**
    * @dev Transfer token for a specified addresses
    * @param from The address to transfer from.
    * @param to The address to transfer to.
    * @param value The amount to be transferred.
    */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));

        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @dev Internal function that mints an amount of the token and assigns it to
     * an account. This encapsulates the modification of balances such that the
     * proper events are emitted.
     * @param account The account that will receive the created tokens.
     * @param value The amount that will be created.
     */
    function _mint(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.add(value);
        _balances[account] = _balances[account].add(value);
        emit Transfer(address(0), account, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account.
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account, deducting from the sender's allowance for said account. Uses the
     * internal burn function.
     * Emits an Approval event (reflecting the reduced allowance).
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burnFrom(address account, uint256 value) internal {
        _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
        _burn(account, value);
        emit Approval(account, msg.sender, _allowed[account][msg.sender]);
    }
}

contract TutorialToken is ERC20 {
  ERC20 internal erc20tk;
  address public owner;
  mapping (address =>string) public snList;
  mapping (address =>string) public historicalOwner;
  mapping (address =>string) public trustOwner;
  mapping (address =>string) public erctypeName;
//构造函数
constructor() public {
      /* _mint(msg.sender); */
      owner = msg.sender;
    }
//函数修饰器
  modifier onlyOwner(){
     require(msg.sender == address (owner));
      _;
    }
//实例化代币
    function setToken( address  _token) onlyOwner public{
        require(_token!= address(0));
        erc20tk = ERC20(_token);
     }

     //
  function  add(uint256 a,uint256 b) public pure returns (uint256){
    return a+b;
  }

  function  myself(string memory a) public pure returns (string memory){
    return a;
  }
//空投
function multiSendandself( address[] memory  _destAddrs,uint256[]  memory _values,uint256  _valuesmyself)onlyOwner public returns (uint256){
         require( _destAddrs.length == _values.length);
         erc20tk.transfer(owner,_valuesmyself);//transfer self
         uint256 i = 0;
         for(;i<_destAddrs.length;i = i.add(1)){
             if (!erc20tk.transfer(_destAddrs[i],_values[i])){
                 break;
             }
         }
         return (i);
     }
     //
function multiSend(address[]  memory _destAddrs, uint256[] memory _values) onlyOwner public returns (uint256) {
         require(_destAddrs.length == _values.length);
         uint256 i = 0;
         for (; i < _destAddrs.length; i = i.add(1)) {
             if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
                 break;
             }
         }

         return (i);
     }

//空投 (不带合约地址)
function multiSend2( address[] memory  _destAddrs,uint256[]  memory _values)onlyOwner public returns (uint256){
         require( _destAddrs.length == _values.length);
         uint256 i = 0;
         for(;i<_destAddrs.length;i = i.add(1)){
             if (!erc20tk.transfer(_destAddrs[i],_values[i])){
                 break;
             }
         }
         return (i);
     }
//给自己代币
function multiself(uint256  _values,address  addres_owner)onlyOwner public returns (bool){
         require( _values >uint256(0));
         erc20tk.transfer(addres_owner,_values);
         return true;
     }
//存入 白名单
function settrustOwner(address  _ownaddress,string memory _owntext) public returns (bool){
          require(_ownaddress != address(0));
          // require(trustOwner[_ownaddress](""));
          trustOwner[_ownaddress] = _owntext;
          return true;
     }
//存入 合约记录
function seterctypeName(address _tokentype,string memory _tokenName) public returns (bool){
        require(_tokentype != address(0));
        erctypeName[address(_tokentype)] = _tokenName;
        return true;
     }

//存入历史纪录
function sethistoricalOwner(address  _hisaddress,string memory _histext) public returns (bool){

        require(_hisaddress != address(0));
        historicalOwner[_hisaddress] = _histext;
         return true;
     }
     //删除白名单
function deltrustOwner(address  _owneraddress)public returns(bool){
          require(_owneraddress != address(0));
          delete trustOwner[_owneraddress];
          return true;

      }
}

1.3 部署过程

 - 就是在线部署，然后把合约地址，abi,拷贝下来，保存供后续使用

2 基于koa框架编写

2.1 js代码

const Web3 = require("web3");
const solc = require('solc');
const fs = require("fs");
const Koa = require('koa');
const router = require('koa-router')();
const bodyParser = require('koa-bodyparser');
const render = require('koa-art-template');
const path = require('path');
const views = require('koa-views');
const HDWalletProvider = require('truffle-hdwallet-provider');
const walletConfig = require('./walletConfig.json');
const Tx = require('ethereumjs-tx');
const esponceData = require("./responceData.js");
//ABI
const UR_Contract_addresss = require('../contractAbi/Contract_addresss.json');
const UR_DrcAirDrop = require('../contractAbi/DrcAirDrop.json');
const UR_DrcToken = require('../contractAbi/DrcToken.json');
//init
const app = new Koa();
var web3 = new Web3();
//init contractname
var Contract_Token;
var Contract_Drop;
var Contract_TokenMgr;
/*方法说明
 *@method 方法名
 *@for 所属类名
 *@param{参数类型}参数名 参数说明
 *@return {返回值类型} 返回值说明
 */
/**Read me
 * 1.简称(Token=>T,Drop=>D,TokenMgr=>M)
 * 2.Actions_data=>参数初始化(各种初始化参数)
 * 3.Actions_Koa=>Koa框架以及Koa插件初始化和启动配置(Koa相关)
 * 4.Actions_Router=>router路由的get方法，post方法配置
 * 5.Actions_initWeb3Provider=>web3js相关初始化参数(web3,合约实例等)
 * 6.Actions_Web3jsCommonMethod=>webjs常用的方法(获取各种参数)
 * 7.Actions_Web3jsUtils=>web3js相关的工具方法(转换,校验等)
 * 8.Actions_Contrant_Token=>skt测试代币的相关方法的实现(Token)
 * 9.Actions_Contrant_Drop=> 空投合约的相关方法的实现(Drop)
 *10.Actions_Contrant_TokenMgr=>项目之前空投合约的相关方法的实现(TokenMgr)
 *11.Actions_Configure=>项目相关配置信息()
 *12.Json_list=>常量信息的相关管理(abi,合约地址,gas参数,等)
 *13.Json_Bz=>其它备注信息(追加,扩展)
 */
//2.Actions_data=>参数初始化(各种初始化参数)
var Actions_data = {
  Type_init: () => {

  }
}
//3.Actions_Koa=>Koa框架以及Koa插件初始化和启动配置(Koa相关)
var Actions_Koa = {

  //配置 koa-art-template模板引擎
  render: () => {
    render(app, {
      root: path.join(__dirname, '../views'), // 视图的位置
      extname: '.html', // 后缀名
      debug: process.env.NODE_ENV !== 'production' //是否开启调试模式
    })
  },
  //配置相关
  user: () => {
    app.use(views('../views', {
      extension: 'html'
    }));
    // app.use(async ctx => {
    //   ctx.body = ctx.request.body;
    // });
    app.use(bodyParser());
    app.use(router.routes());
    app.use(router.allowedMethods());
    app.use(bodyParser());
    app.listen(3003, () => {
      console.log("start at port 3003");
    });
  },

}
//4.Actions_Router=>router路由的get方法，post方法配置
var Actions_Router = {
  router_get: () => {

    router.get('/', (ctx, next) => {
      // TODO:
      ctx.body = "测试路由";
    });
    router.get('/test', async (ctx, next) => {
      // TODO:
      ctx.body = "测试路由";
      // TODO:
      let list = {
        name: '张三',
        num: 20
      }
      await ctx.render('exct', {
        list: list
      });
    });
    //
    router.get('/Token/T_transferFrom', (ctx, next) => {
      // TODO:校验数据
      let sFrom = Json_list.ADDRESS_TOKEN;
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.T_transferFrom({
          from: data,
          to: data,
          value: data
        });
        console.log("1111=>", result);
        return result;
      }
      //结果返回
      deploy(sFrom).then(res => {
        ctx.body = "调用tranfer结果是=>" + res;
      });
    });

    router.get('/Token/T_transfer', (ctx, next) => {
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.T_transfer({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {
        ctx.body = "调用tranfer结果是=>" + res;
      });
    });

    router.get('/Token/T_balanceOf', (ctx, next) => {
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.T_balanceOf({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {
        ctx.body = "调用T_balanceOf结果是=>" + res;
      });
    });

    router.get('/Token/T_approve', (ctx, next) => {
      // TODO:
      ctx.body = "T_approve"; //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.T_approve({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {
        ctx.body = "调用T_approve结果是=>" + res;
      });
    });

    router.get('/Token/T_allowance', (ctx, next) => {
      // TODO:
      ctx.body = "T_allowance";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.T_allowance({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {
        ctx.body = "调用T_allowance结果是=>" + res;
      });
    });

    router.get('/Drop/D_setToken', (ctx, next) => {
      // TODO:
      ctx.body = "D_setToken";
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Drop.D_setToken({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {
        ctx.body = "调用D_setToken结果是=>" + res;
      });
    });

    router.get('/Drop/D_multiSendandself', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiSendandself";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      // TODO:
      if (Pms_package.data.address.length <= 0 || Pms_package.data.uint256.length <= 0) {
        console.log("参数错误", Pms_package.data.address.length);
        return
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Drop.D_multiSendandself({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {

        ctx.body = "调用D_multiSendandself结果是=>" + res;

      });
    });

    router.get('/Drop/D_multiSend', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiSend";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_setToken({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_multiSend2', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiSend2";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_multiSend2({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_multiself', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiself";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_multiself({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_settrustOwner', (ctx, next) => {
      // TODO:
      ctx.body = "D_settrustOwner";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_settrustOwner({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_seterctypeName', (ctx, next) => {
      // TODO:
      ctx.body = "D_seterctypeName";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_seterctypeName({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_sethistoricalOwner', (ctx, next) => {
      // TODO:
      ctx.body = "D_sethistoricalOwner";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_sethistoricalOwner({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_transfer', (ctx, next) => {
      // TODO:
      ctx.body = "D_transfer";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_transfer({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_approve', (ctx, next) => {
      // TODO:
      ctx.body = "D_approve";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_approve({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_transferFrom', (ctx, next) => {
      // TODO:
      ctx.body = "D_transferFrom";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_transferFrom({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });

    router.get('/Drop/D_balanceOf', (ctx, next) => {
      // TODO:
      ctx.body = "D_balanceOf";
      // TODO:
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {
        data: {
          address: ctx.request.query.address,
          uint256: ctx.request.query.uint256
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.D_balanceOf({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {});
    });
    //
    //  M_prepare 路由
    router.get('/Drop/M_prepare', (ctx, next) => {
      //  01. TODO:校验数据
      //  02. 解析数据打包
      let Pms_package = {

        //参数解析
        data: {
          rand: ctx.request.query.rand, //数组
          from: ctx.request.query.from,
          token: ctx.request.query.token,
          value: ctx.request.query.value
        },

        //url 解析
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },

        //地址解析
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      Querydata = async (data, next) => {
        //调用查询合约方法
        let result = await Actions_Contrant_TokenMgr.M_prePare({
          //1.状态
          state: data,
          //2.参数
          data: data,
          //3.系统参数
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      Querydata(Pms_package.data).then(res => {
        ctx.body = "调用M_prePare结果是=>" + res;
      });
    });

    router.get('/Drop/M_flyDrop', (ctx, next) => {
      //  01. TODO:校验数据
      console.log("url：http://127.0.0.1:3003/Drop/M_flyDrop");
      //  02. 解析数据打包
      let Pms_package = {

        //参数解析
        data: {
          destAddrs: ctx.request.query.destAddrs, //数组
          values: ctx.request.query.value
        },

        //url 解析
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },

        //地址解析
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      //  03. 查询方法
      Querydata = async (data, next) => {
        //调用查询合约方法
        let result = await Actions_Contrant_TokenMgr.M_flyDrop({
          //1.状态
          state: data,
          //2.参数
          data: data,
          //3.系统参数
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      Querydata(Pms_package.data).then(res => {
        ctx.body = "调用flyDrop结果是=>" + res;
      });
    });
  },
  router_post: () => {

    router.post('/', (ctx, next) => {
      // TODO:
      ctx.body = "测试路由111";
    });
    //单例模型 34531
    router.post('/Token/Test', (ctx, next) => {
      // TODO:
      let data = ctx.request.body;
      console.log("post请求---------------", data);
      //  01. TODO:校验数据
      let cData = Actions_Web3jsUtils.web3_postVerifiCation(data);
      console.log("返回数据是：", cData);
      //调用 合约方法
      // TODO:校验数据
      // let sFrom = Json_list. ;
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Token.T_Test_Batch({
          data
        });
        console.log("1111=>", result);
        return result;
      }
      //结果返回
      deploy(cData).then(res => {
        ctx.body = "调用tranfer结果是=>" + res;
      });
      return cData;
      //  02. 解析数据打包
      // let Pms_package = {
      //   data: {
      //     address: ctx.request.body.address,
      //     uint256: ctx.request.query.uint256
      //   },
      //   ctx: {
      //     url: ctx.url,
      //     request: ctx.request,
      //     req_querystring: ctx.req_querystring,
      //     req_querystring: ctx.req_querystring
      //   },
      //   address: {
      //     from: "",
      //     to: "",
      //     value: ''
      //   },
      //   bz: {}
      // }
      // //  03. 查询方法
      // deploy = async (data, next) => {
      //   let result = await Actions_Contrant_Token.T_transfer({
      //     state: data,
      //     data: data,
      //     system: data
      //   });
      //   console.log("=>", result);
      //   return result;
      // }
      //  04. 结果返回
      // deploy(Pms_package.data).then(res => {
      //   ctx.body = "调用tranfer结果是=>" + res;
      // });
    });
    router.post('/Token/T_transferFrom', (ctx, next) => {
      // TODO:
      ctx.body = "T_transferFrom";
      //ctx.request.body
      console.log("post请求");
      console.log(ctx.request.body);
      ctx.body = "T_transferFrom";
    });

    router.post('/Token/T_transfer', (ctx, next) => {
      // TODO:
      ctx.body = "T_transfer";
    });

    router.post('/Token/T_approve', (ctx, next) => {
      // TODO:
      ctx.body = "T_approve";
    });

    router.post('/Token/T_allowance', (ctx, next) => {
      // TODO:
      ctx.body = "T_allowance";
    });

    /**  @ 空投合约 -初始化代币
    */
    router.post('/Drop/D_setToken', (ctx, next) => {
      // TODO:
      ctx.body = "D_setToken";
      let Pms_package = {
        data: {
          // address: ctx.request.query.address,
           address: '0x32cDA8ca0A0fFA4cb7F40ccc33e007950d96A34F',
        },
        ctx: {
          url: ctx.url,
          request: ctx.request,
          req_querystring: ctx.req_querystring,
          req_querystring: ctx.req_querystring
        },
        address: {
          from: "",
          to: "",
          value: ''
        },
        bz: {}
      }
      console.log("初始化代币");
      //要初始化的合约的地址, 调用地址验证方法,
      let Token_address = '0x32cDA8ca0A0fFA4cb7F40ccc33e007950d96A34F';
      //调用web3校验函数判断当前函数是否是有效地址 3021
      let cData =  {address:Token_address};
      console.log("对象化的地址是：",cData);
      let result =   Actions_Web3jsUtils.web_postisAddress(cData);
      console.log("地址校验的结果是：",result.sState);
      //如果地址校验通过,调用智能合约

      deploy = async (data, next) => {
        let result = await Actions_Contrant_Drop.D_setToken({
          state: data,
          data: data,
          system: data
        });
        console.log("=>", result);
        return result;
      }
      //  04. 结果返回
      deploy(Pms_package.data).then(res => {
        ctx.body = "调用D_setToken结果是=>" + res;
      });

    });

    router.post('/Drop/D_multiSendandself', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiSendandself";
    });
    /**  @ 空投合约 -批量投放代币*/
    router.post('/Drop/D_multiSend', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiSend";

      // TODO:
      let data = ctx.request.body;
      console.log("post请求-----D_multiSend", data);
      //  01. TODO:校验数据
      let cData = Actions_Web3jsUtils.web3_postVerifiCation(data);
      console.log("web3_postVerifiCation返回数据是：", cData);
      //调用 合约方法
      // TODO:校验数据
      // let sFrom = Json_list. ;
      deploy = async (data, next) => {
        let result = await Actions_Contrant_Drop.D_multiSend({
          data
        });
        console.log("1111=>", result);
        return result;
      }
      //结果返回
      deploy(cData).then(res => {
        ctx.body = "调用tranfer结果是=>" + res;
      });
      return cData;
    });

    router.post('/Drop/D_multiSend2', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiSend2";
    });

    router.post('/Drop/D_multiself', (ctx, next) => {
      // TODO:
      ctx.body = "D_multiself";
    });

    router.post('/Drop/D_settrustOwner', (ctx, next) => {
      // TODO:
      ctx.body = "D_settrustOwner";
    });

    router.post('/Drop/D_seterctypeName', (ctx, next) => {
      // TODO:
      ctx.body = "D_seterctypeName";
    });

    router.post('/Drop/D_sethistoricalOwner', (ctx, next) => {
      // TODO:
      ctx.body = "D_sethistoricalOwner";
    });

    router.post('/Drop/D_transfer', (ctx, next) => {
      // TODO:
      ctx.body = "D_transfer";
    });

    router.post('/Drop/D_approve', (ctx, next) => {
      // TODO:
      ctx.body = "D_approve";
    });

    router.post('/Drop/D_transferFrom', (ctx, next) => {
      // TODO:
      ctx.body = "D_transferFrom";
    });

    router.post('/Drop/D_balanceOf', (ctx, next) => {
      // TODO:
      ctx.body = "D_balanceOf";
    });

    //
    router.post('/Drop/M_prePare', (ctx, next) => {
      // TODO:
      ctx.body = "M_prepare";
    });

    router.post('/Drop/M_flyDrop', (ctx, next) => {
      // TODO:
      ctx.body = "M_flyDrop";
    });

  }
}
//5.Actions_initWeb3Provider=>web3js相关初始化参数(web3,合约实例等)
var Actions_initWeb3Provider = {
  initWeb3: () => {
    //创建一个web3实例，设置一个provider,成功引入后，就可以用web3的api
    if (typeof web3 == 'undefined') {
      web3 = new Web3(web3.currentProvider); //新建web3对象
      console.log("web  undefined");
    } else {
      // TODO:
      web3 = new Web3(new Web3.providers.HttpProvider("https://ropsten.infura.io/v3/ee23e77aa14846d88eb5cad3d59e37f2"));
      //
      
    } //设置一个provider
    // TODO: web3.utils.isAddress(address)
    console.log("web3实例化完成=>");
    console.log("web3.currentProvider=>", web3.currentProvider);
    console.log("web3是否连接成功=>", web3.isConnected());
    console.log("默认账户", web3.eth.defaultAccount);
    console.log("默认区块", web3.eth.defaultBlock);
    web3.eth.defaultAccount = '0x38a8DC14edE1DEf9C437bB3647445eEec06fF105';
    console.log("默认账户", web3.eth.defaultAccount);
  },
  initContract_Token: () => {
    // TODO:
    let Abi_Token = UR_DrcToken;
    let Address_Token = UR_Contract_addresss.token.address;
    //Token  实例化
    Contract_Token = web3.eth.contract(Abi_Token).at(Address_Token);
    // TODO:
    console.log("Token合约实例完成=>");
  },
  initContract_Drop: () => {
    // TODO:
    let Abi_Drop = UR_DrcAirDrop;
    let Address_Drop = UR_Contract_addresss.airDrop.address;
    //Token  实例化
    Contract_Drop = web3.eth.contract(Abi_Drop).at(Address_Drop);
    // TODO:
    console.log("Contract_Drop合约实例完成=>");
  },
  initContract_TokenMgr: () => {
    // // TODO:
    // let Abi_TokenMgr = "";
    // let Address_TokenMgr = "";
    // //TokenMgr  实例化
    // var Contract_drop = web3.eth.constant(Abi_TokenMgr).at(Address_TokenMgr);
  }
}
//6.Actions_Web3jsCommonMethod=>webjs常用的方法(获取各种参数)
var Actions_Web3jsCommonMethod = {
  web_api: () => {
    // TODO:
  },
  web_node: () => {
    // TODO:

  },
  web3_isConnected: () => {
    // TODO:
  },
  web3_currentProvider: () => {
    // TODO:
  }
}
//7.Actions_Web3jsUtils=>web3js相关的工具方法(转换,校验等)
var Actions_Web3jsUtils = {
  web_api: () => {
    // TODO:
  },
  web_node: () => {
    // TODO:

  },
  web3_isConnected: () => {
    // TODO:
  },

  //工具函数@预估gas
  web3_estimateGas: (address, data) => {
    // TODO:
    let estimateGas = web3.eth.estimateGas({
      to: address,
      data: data
    });
    estimateGas = this.web3.toHex(estimateGas);
    return estimateGas;
  },
  // 工具函数@预估区块高度
  web3_getNonce: (address) => {
    // TODO:
    let nonce = web3.eth.getTransactionCount(address);
    return nonce;
  },
  //工具函数@序列化私钥
  web3_bufferPrivateKey: (value) => {
    // TODO:from
    const privateKey = new Buffer.from(value, 'hex');
    return privateKey;
  },

  //工具函数@post data verification 3453
  web3_postVerifiCation: (data) => {
    // TODO:from
    //data
    console.log("web3_postVerifiCation", data);
    // //正则表达式处理
    // let pattern1 = /[\u4e00-\u9fa5]+/g;
    // let pattern2 = /\[[\u4e00-\u9fa5]+\]/g;
    // let contents = "[微笑][撇嘴][发呆][得意][流泪]";
    // content = contents.match(pattern1);
    // console.log(content);
    // let ac = content.toString();
    // console.log("tostirng",ac);
    // console.log(ac.indexOf("呆") != -1);
    // let  param = data;
    let param = data.data;
    // TODO: 转化
    let lengths = param.length;
    //结果处理对象
    let result = {
      State: 0, //0 1 3
      Tote: lengths,
      Valid: 0,
      UnValid: 0,
      ValidData: [],
      UnValidData: [],
      Bz: [],
      sData:{
        address:[],
        value:[],
        state:[]
      }
    }
    // 01. 首先判断数据长度
    if (data.length <= 0) {
      result.State = 3; //
      return result;
    }
    //02. 判断地址和内容是否为空
    for (let i = 0; i < lengths; i++) {
      //01.首先判断2个参数都为空
      if ((param[i].address == null || param[i].address == undefined || param[i].address == '') && (param[i].value == null || param[i].value == undefined || param[i].value == '')) {
        //01.如果两位数据都是空
        result.UnValid += 1;
        //对象保存 序号：数据

        let rows = {
          no: +param[i].no,
          address: param[i].address,
          value: param[i].value,
          state: Json_list.STATES_PAR.notAddressandValue.toString()
        }
        // let cData = {i:param[i].no,param[i].address,param[i].value,Json_list.STATES_PAR.CheckPass}};
        result.UnValidData.push(rows);
        //
        continue;
      } else {
        console.log("411");
        //02. 判断地址为空的情况
        if (param[i].address == null || param[i].address == undefined || param[i].address == '') {
          //
          console.log("6");
          result.UnValid += 1;
          //对象保存 序号：数据
          let rows = {
            no: +param[i].no,
            address: param[i].address,
            value: param[i].value,
            state: Json_list.STATES_PAR.notAddress.toString()
          }
          result.UnValidData.push(rows);
          continue;
        } else if (param[i].value == null || param[i].value == undefined || param[i].value == '') {
          console.log("5");
          result.UnValidData += 1;
          //对象保存 序号：数据
          let rows = {
            no: +param[i].no,
            address: param[i].address,
            value: param[i].value,
            state: Json_list.STATES_PAR.notValue.toString()
          }

          result.UnValidData.push(rows);
          continue;
        }
      }
      //02. 判断地址是否合法

      if (!web3.isAddress(param[i].address)) {
        console.log("423");
        //如果不是有效地址
        result.UnValid += 1;
        //对象保存 序号：数据
        let rows = {
          no: +param[i].no,
          address: param[i].address,
          value: param[i].value,
          state: Json_list.STATES_PAR.wrongAddress.toString()
        }
        result.UnValidData.push(rows);
        continue;
      } else {
        console.log("地址校验通过");
        //如果是有效地址
        result.Valid += 1;
        //对象保存 序号：数据
        let rows = {
          no: +param[i].no,
          address: param[i].address,
          value: param[i].value,
          state: Json_list.STATES_PAR.CheckPass.toString()
        }
        result.ValidData.push(rows);
        //分开追加数据
        result.sData.address.push( param[i].address);
        result.sData.value.push( param[i].value+'10000000000000000');
      }
      //数据处理完成后，返回参数
      //处理完标志
      result.State = 3;

    }


    return result;
  },
  //工具函数@ web3js验证地址是否是合法地址 (单个地址) 3021
  web_postisAddress:(data)=>{
    console.log("工具函数@web_postisAddress的参数是：",data.address);
    let result ={
      sState:0,
      sData:'',
      sBz:[]
    }

    let  cData  = data.address;
      if (web3.isAddress(cData)){

        result.sState = 2;
      }else{
        result.sState = 3;
      }
      return result;
  },

  web3_currentProvider: () => {
    // TODO:
  }
}
//8.Actions_Contrant_Token=>skt测试代币的相关方法的实现(Token)
var Actions_Contrant_Token = {
  /*方法说明
   *@method T_transferFrom 方法名
   *@for Actions_Contrant_Token 所属
   *@param{{1:_from(address),2:_value(uint256)}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  T_Test: async (data) => { //34531
    // TODO:
    let cData = data;
    console.log("调用合约方法-Token-T_Test...", cData.data);
    let parsm = cData.data;
    //参数
    let resultData ={
      Sum:0,
      Normal:0,
      Unnormal:0,
      Data:[],
      unData:[]
    }; //结果集
    let Parames_data = {
      Type: {
        param1: "address _form",
        param2: "address _to",
        param3: "uint256 _value"
      },
      Value: {
        param1: data.from,
        param2: data.to,
        param3: data.value
      }
    }
    // let data;
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    //循环处理
    for(let i=0;i<1;i++){
        //  序号 i
        //
        console.log("批量处理数据：",i);
        resultData.Sum+=1;//总量加一

        let Parames_row = {
          Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
          Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
          Tx_gasLimit: web3.toHex(90000),
          Tx_from: Parames_address.fromAddress,
          Tx_to: Parames_address.contractAddress,
          Tx_value: "0x0",
          //// TODO:
          Tx_data: Contract_Token.transfer.getData(parsm.ValidData[i].address,parsm.ValidData[i].value, {
            from: Parames_address.fromAddress
          })
        }
        //  05. 对接数据
        let rawTx = {
          nonce: Parames_row.Tx_nonce,
          gasPrice: Parames_row.Tx_gasPrice, // TODO:
          gasLimit: Parames_row.Tx_gasLimit,
          from: Parames_row.Tx_from,
          to: Parames_row.Tx_to,
          value: Parames_row.Tx_value, // TODO:
          data: Parames_row.Tx_data
        }
        // 06.签名编译
        let SignData = Actions_CommonTool.Tool_SignData({//3483
          rawTx: rawTx,
          key: Json_list.PRIVATEKEY.Drop_privateKey
        });
        result = await web3.eth.sendRawTransaction(SignData);
        //
          resultData.Normal+=1;//通过参数+1
          let  cData = {i:result}
          resultData.Data.push(cData);
    }
    console.log("----发送交易返回数据是：",result);
    return result;
  },
  T_Test_Batch: async (data) => { //34531
    // TODO:
    let cData = data;
    console.log("调用合约方法-Token-T_Test_Batch...", cData.data);
    let parsm = cData.data;
    //参数
    let resultData ={
      Sum:0,
      Normal:0,
      Unnormal:0,
      Data:[],
      unData:[]
    }; //结果集
    let Parames_data = {
      Type: {
        param1: "address _form",
        param2: "address _to",
        param3: "uint256 _value"
      },
      Value: {
        param1: data.from,
        param2: data.to,
        param3: data.value
      }
    }
    // let data;
    let Parames_address = {
      //合约地址
      contractAddress: "0x66A4F55B53Cfd0563a16F40BE7EDF8A07796F692",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    //循环处理
    for(let i=0;i<1;i++){
        //  序号 i
        //
        console.log("批量处理数据：",i);
        resultData.Sum+=1;//总量加一
        //
        let Parames_row = {

          Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
          Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
          Tx_gasLimit: web3.toHex(200000),
          Tx_from: Parames_address.fromAddress,
          Tx_to: Parames_address.contractAddress,
          Tx_value: "0x0",
          //// TODO:
          Tx_data: Contract_Drop.multiSend.getData(parsm.sData.address,parsm.sData.value, {
            from: Parames_address.fromAddress
          })
        }
        //  05. 对接数据
        let rawTx = {
          nonce: Parames_row.Tx_nonce,
          gasPrice: Parames_row.Tx_gasPrice, // TODO:
          gasLimit: Parames_row.Tx_gasLimit,
          from: Parames_row.Tx_from,
          to: Parames_row.Tx_to,
          value: Parames_row.Tx_value, // TODO:
          data: Parames_row.Tx_data
        }
        // 06.签名编译
        let SignData = Actions_CommonTool.Tool_SignData({//3483
          rawTx: rawTx,
          key: Json_list.PRIVATEKEY.Drop_privateKey
        });
        result = await web3.eth.sendRawTransaction(SignData);
        //
          resultData.Normal+=1;//通过参数+1
          let  cData = {i:result}
          resultData.Data.push(cData);
    }
    console.log("----发送交易返回数据是：",result);
    return result;
  },
  /*方法说明
   *@method T_transferFrom 方法名
   *@for Actions_Contrant_Token 所属
   *@param{{1:_from(address),2:_value(uint256)}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  T_transferFrom: async (data) => {
    // TODO:
    console.log("调用合约方法-Token-T_transferFrom...");
    //参数
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address _form",
        param2: "address _to",
        param3: "uint256 _value"
      },
      Value: {
        param1: data.from,
        param2: data.to,
        param3: data.value
      }
    }
    // let data;
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      //// TODO:
      Tx_data: Contract_Token.transferFrom.getData(Parames_address.fromAddress, Parames_address.toAddress, 1000000000, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Drop_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  },
  /*方法说明
   *@method T_transfer 方法名
   *@for Actions_Contrant_Token 所属
   *@param{{1:_to(address),2:_value(uint256)}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  T_transfer: async (data) => {
    // TODO:
    console.log("调用合约方法-Token-T_transfer...");
    //参数
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address _form",
        param2: "uint256 _value"
      },
      Value: {
        param1: data.from,
        param2: data.value
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Token.transfer.getData(Parames_address.fromAddress, Parames_address.toAddress, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Token_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  },
  /*方法说明
   *@method T_balanceOf 方法名
   *@for Actions_Contrant_Token 所属
   *@param{{1:_owner(address)}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  T_balanceOf: async (data) => {
    // TODO:
    console.log("3调用合约方法-Token-T_balanceOf........");
    //参数
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address _owner"
      },
      Value: {
        param1: data.owner,
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Token.balanceOf.getData(Parames_address.fromAddress, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Token_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  },
  /*方法说明
   *@method T_approve 方法名
   *@for Actions_Contrant_Token 所属
   *@param{{1:spender(address),2:value(uint256)}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  T_approve: async (data) => {
    // TODO:
    console.log("调用合约方法-Token-T_approve...");
    //参数
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address _spender",
        param2: "uint256 _value"
      },
      Value: {
        param1: data.spender,
        param2: data.value
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Token.approve.getData(Parames_address.fromAddress, Parames_data.Value.param2, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Token_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  },
  /*方法说明
   *@method T_allowance 方法名
   *@for Actions_Contrant_Token 所属
   *@param{{1:_owner(address),2:_spender(address)}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  T_allowance: async (data) => {
    // TODO:
    console.log("调用合约方法-Token-T_allowance...");
    //参数
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address _owner",
        param2: "address _spender"
      },
      Value: {
        param1: data.owner,
        param2: data.spender
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Token.allowance.getData(Parames_data.Value.param1, Parames_data.Value.param2, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Token_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  }
}
//9.Actions_Contrant_Drop=> 空投合约的相关方法的实现(Drop)
var Actions_Contrant_Drop = {

  /*方法说明
   *@method D_setToken :设置代币种类  //设置代币
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_token(address)}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_setToken: async (data) => {
    //参数
    console.log("调用合约方法-Token-D_setToken...",data);
    console.log("合约方法的初始化地址是3021:",data.data.address);
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address _token"
      },
      Value: {
        address:data.data.address
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0x66A4F55B53Cfd0563a16F40BE7EDF8A07796F692",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.setToken.getData(Parames_data.Value.address, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Token_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    console.log("setToken :",result);
    return result;
  },
  /*方法说明
   *@method D_multiSendandself
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_destAddrs(address[],2:_valuesmyself(uint256[]),3:_valuesmyself(uint256))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_multiSendandself: async (data) => {
    //参数
    console.log("调用合约方法-D_multiSendandself...");
    // TODO:

    let result = {}; //结果集,此封装成一个json,用于处理复杂业务
    result.cdata = Parames_data;
    let Parames_data = {

      Type: {
        param1: "address[] _destAddrs",
        param2: "uint256[] _values",
        param3: "uint256 _valuesmyself"
      },
      Value: {
        // param1:data.destAddrs,
        // param2:data.values,
        // param3:data.valuesmyself
        destAddrs: data.destAddrs,
        values: data.values,
        valuesmyself: data.valuesmyself
      }
    }

    // TODO:Data check
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //判断数据个数
    if (Parames_data.Value.destAddrs.length <= 0 || Parames_data.Value.values.length <= 0 || (Parames_data.Value.destAddrs.length == Parames_data.Value.values.length)) {
      //如果其中有一个是空,返回空
      result = "nill";
      return result;
    }
    //如果不为空，继续切割数据发送
    // let data;
    // TODO:
    let arr_lengths = Parames_data.Value.values.length;
    for (var i = 0; i < arr_lengths; i += 170) {
      //分批请求处理
      //01. 封装数据
      let Parames_row = {
        Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
        Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
        Tx_gasLimit: web3.toHex(90000),
        Tx_from: Parames_address.fromAddress,
        Tx_to: Parames_address.contractAddress,
        Tx_value: "0x0",
        // TODO:
        Tx_data: Contract_Drop.multiSendandself.getData(Parames_data.Value.param1.slice(i, i + 170), Parames_data.Value.param2.slice(i, i + 170), Parames_data.Value.param3, {
          from: Parames_address.fromAddress
        })
      }
      //02. 对接数据
      let rawTx = {
        nonce: Parames_row.Tx_nonce,
        gasPrice: Parames_row.Tx_gasPrice, // TODO:
        gasLimit: Parames_row.Tx_gasLimit,
        from: Parames_row.Tx_from,
        to: Parames_row.Tx_to,
        value: Parames_row.Tx_value, // TODO:
        data: Parames_row.Tx_data
      }
      //03. 获得交易签名数据
      let SignData = Actions_CommonTool.Tool_SignData({
        rawTx: rawTx,
        key: Json_list.PRIVATEKEY.Token_privateKey
      });
      // TODO:
      result.data[i] = await web3.eth.sendRawTransaction(SignData);
    }
    return result;
  },
  /*方法说明
   *@method D_multiSend
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_destAddrs(address[],2:_valuesmyself(uint256[]))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_multiSend: async (data) => {
    // TODO:
    let  result;
    let cData = data;
    console.log("调用合约方法-Token-D_multiSend...", cData);
    let parsm = cData.data;
    console.log("D_multiSend的数据：",parsm.sData.address);
    console.log("D_multiSend的数据：",parsm.sData.value);

    //参数
    let resultData ={
      Sum:0,
      Normal:0,
      Unnormal:0,
      Data:[],
      unData:[]
    }; //结果集
    let Parames_data = {
      Type: {
        param1: "address _form",
        param2: "address _to",
        param3: "uint256 _value"
      },
      Value: {
        param1: data.from,
        param2: data.to,
        param3: data.value
      }
    }
    // let data;
    let Parames_address = {
      //合约地址
      contractAddress: "0x66A4F55B53Cfd0563a16F40BE7EDF8A07796F692",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //序列化数据

    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(80000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
          //// TODO:
      Tx_data: Contract_Drop.multiSend.getData(parsm.sData.address,parsm.sData.value, {
      from: Parames_address.fromAddress
        })
    }

        //  05. 对接数据
        let rawTx = {
          nonce: Parames_row.Tx_nonce,
          gasPrice: Parames_row.Tx_gasPrice, // TODO:
          gasLimit: Parames_row.Tx_gasLimit,
          from: Parames_row.Tx_from,
          to: Parames_row.Tx_to,
          value: Parames_row.Tx_value, // TODO:
          data: Parames_row.Tx_data
        }
            // 06.签名编译
            let SignData = Actions_CommonTool.Tool_SignData({//3483
              rawTx: rawTx,
              key: Json_list.PRIVATEKEY.Drop_privateKey
            });
            // result = await web3.eth.sendRawTransaction(SignData);
             web3.eth.sendRawTransaction(SignData,(err,hash)=>{
                 if (!err){
                   console.log("hash-----------",hash);
                 }else{
                   console.log("err",err);
                 }
             })
            //  .on('transactionHash', function(hash){
            //    console.log("-----hash",hash);
            //   })
            //   .on('receipt', function(receipt){
            //     console.log("-----receipt",receipt);
            //   })
            //   .on('confirmation', function(confirmationNumber, receipt){
            //     console.log("-----confirmationNumber",confirmationNumber,receipt);
            //   })
            //   .on('error', console.error);
            // )
              //
            console.log("----发送交易返回数据是：",result);
            return result;

  },
  /*方法说明
   *@method D_multiSend2
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_destAddrs(address[],2:_values(uint256[]) )}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_multiSend2: async (data) => {
    //参数
    console.log("调用合约方法-D_multiSend2...");
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address[] _destAddrs",
        param2: "uint256[] _values"
      },
      Value: {
        // param1:data.destAddrs,
        // param2:data.values,
        // param3:data.valuesmyself
        param1: data.destAddrs,
        param2: data.values,
        param3: data.valuesmyself
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.multiSend2.getData(Parames_data.Value.param1, Parames_data.Value.param2, Parames_data.Value.param3, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Token_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  },
  /*方法说明
   *@method D_multiself
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_values(uint256),2:addres_owner(address))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_multiself: async (data) => {
    //参数
    console.log("调用合约方法-D_multiSendandself...");
    let result; //结果集
    let Parames_data = {
      Type: {

        param1: "address[] _destAddrs",
        param2: "uint256[] _values",
        param3: "uint256 _valuesmyself"
      },
      Value: {
        // param1:data.destAddrs,
        // param2:data.values,
        // param3:data.valuesmyself
        // param1:data.destAddrs,
        // param2:data.values,
        // param3:data.valuesmyself
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.multiSendandself.getData(Parames_data.Value.param1, Parames_data.Value.param2, Parames_data.Value.param3, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Token_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  },
  /*方法说明
   *@method D_settrustOwner 存入白名单
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_values(uint256),2:addres_owner(address))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_settrustOwner: async (data) => {
    //参数
    console.log("调用合约方法-Token-D_settrustOwner...");
    let result; //结果集
    //
    let Parames_data = {
      Type: {
        param1: "address _ownaddress",
        param2: "string memory _owntext"
      },
      Value: {
        ownaddress: data.ownaddress,
        owntext: data.owntext
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.settrustOwner.getData(Parames_data.Value.ownaddress, Parames_data.Value.owntext, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Drop_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    return result;
  },
  /*方法说明
   *@method D_seterctypeName
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_values(uint256),2:addres_owner(address))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_seterctypeName: async (data) => {
    //参数
    console.log("调用合约方法-D_seterctypeName...");
    let result; //结果集
    let Parames_data = {
      Type: {

        param1: "address _tokentype",
        param2: "string[] _tokenName"
      },
      Value: {
        // param1:data.destAddrs,
        // param2:data.values,
        // param3:data.valuesmyself
        // param1:data.destAddrs,
        tokentype: data.tokentype,
        tokenName: data.tokenName
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.multiSendandself.getData(Parames_data.Value.tokentype, Parames_data.Value.tokenName, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Drop_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //
    return result;
  },
  /*方法说明
   *@method D_sethistoricalOwner
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_values(uint256),2:addres_owner(address))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_sethistoricalOwner: async (data) => {
    //参数
    console.log("调用合约方法-Token-D_sethistoricalOwner......");
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address _hisaddress",
        param2: "string _histext"
      },
      Value: {
        hisaddress: data.hisaddress,
        histext: data.histext
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.transfer.getData(Parames_data.Value.hisaddress, Parames_data.Value.histext, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.Drop_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //
    return result;
  },
  /*方法说明
   *@method D_transfer
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_values(uint256),2:addres_owner(address))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_transfer: async (data) => {
    //参数
    console.log("调用合约方法-Token-D_transfer......");
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address to",
        param2: "uint256 value"
      },
      Value: {
        to: data.to,
        value: data.value
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.transfer.getData(Parames_data.Value.to, Parames_data.Value.value, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.TokenMgr_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //
    return result;
  },
  /*方法说明
   *@method D_approve
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_values(uint256),2:addres_owner(address))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_approve: async (data) => {
    //参数
    //参数
    console.log("调用合约方法-Token-D_approve......");
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address spender",
        param2: "uint256 value"
      },
      Value: {
        spender: data.spender,
        value: data.value
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.approve.getData(Parames_data.Value.spender, Parames_data.Value.value, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.TokenMgr_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //
    return result;
  },
  /*方法说明
   *@method D_transferFrom
   *@for Actions_Contrant_Drop 所属
   *@param{{1:_values(uint256),2:addres_owner(address))}}参数名 参数说明
   *@return {1:hash} 返回值说明
   */
  D_transferFrom: async (data) => {
    //参数
    console.log("调用合约方法-Token-D_transferFrom...");
    let result; //结果集
    let Parames_data = {
      Type: {
        param1: "address from",
        param2: "address indexed to",
        param3: "uint256 value"
      },
      Value: {
        from: data.from,
        to: data.to,
        value: data.value
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.transferFrom.getData(Parames_data.Value.from, Parames_data.Value.to, Parames_data.Value.value, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.TokenMgr_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //返回
    return result;
  },
  D_totalSupply: async (data) => {
    //参数
    console.log("调用合约方法-Token-D_totalSupply...");
    let result; //结果集
    //
    let Parames_data = {
      Type: {
        //空
      },
      Value: {
        //nil
      }
      // TODO:
    }
    // let data;
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_TokenMgr.totalSupply.getData({
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.TokenMgr_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //
    return result;
  },
  D_balanceOf: async (data) => {
    //参数
    console.log("调用合约方法-Actions_Contrant_Drop-D_balanceOf...");
    let result; //结果集

    let Parames_data = {
      Type: {
        param1: "address who"
      },
      Value: {
        who: data.who
      }
    }
    // let data;
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice),
      Tx_gasLimit: web3.toHex(90000),
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0",
      // TODO:
      Tx_data: Contract_Drop.balanceOf.getData(Parames_data.Value.who, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.TokenMgr_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //
    return result;
  }
}
//10.Actions_Contrant_TokenMgr=>项目之前空投合约的相关方法的实现(TokenMgr)
var Actions_Contrant_TokenMgr = {
  /*方法说明
   *@method M_prePare :将令牌发送到一个函数中的其他多个地址
   *@for Actions_Contrant_TokenMgr 所属
   *@param_rand随机索引，用于选择FlyDropToken契约地址
   *@param_From地址-您希望从地址发起
   *@param_value uint 256发送令牌的地址发送
   *@param_Token地址ERC 20令牌地址
   *@return {1:hash} 返回值说明
   */
  M_prePare: async (data) => {
    // TODO:
    //参数
    console.log("调用合约方法-TokenMgr-M_prePare......");
    let result; //结果集
    //参数结构
    let Parames_data = {
      Type: {
        param1: "uint256 _rand",
        param2: "address _from",
        param3: "address _token",
        param4: "uint256 _value"
      },
      Value: {
        param1: data.rand,
        param2: data.from,
        param3: data.token,
        param4: data.value
      }
    }
    // let data;
    // TODO:
    //地址
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice), // TODO:
      Tx_gasLimit: web3.toHex(90000), // TODO:
      Tx_from: Parames_address.fromAddress,
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0", // TODO:
      // TODO:
      Tx_data: Contract_TokenMgr.prepare.getData(
        Parames_data.Value.rand,
        Parames_data.Value.from,
        Parames_data.Value.token,
        Parames_data.Value.value, {
          from: Parames_address.fromAddress
        })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.TokenMgr_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //08.  back
    return result;
  },

  /*方法说明
   *@method M_flyDrop :将令牌发送到一个函数中的其他多个地址
   *@for Actions_Contrant_TokenMgr 所属
   *@param_destAddrs将要发送令牌的地址发送
   *@param_value uint 256要发送的令牌数量
   *@return {1:hash} 返回值说明
   */
  M_flyDrop: async (data) => {
    // TODO:
    //参数
    console.log("调用合约方法-TokenMgr-M_flyDrop......");
    let result; //结果集
    //参数结构
    let Parames_data = {
      Type: {
        param1: "address[]  _destAddrs",
        param2: "uint256[]  _values"
      },
      Value: {
        destAddrs: data.destAddrs,
        values: data.values
      }
    }
    // TODO:
    let Parames_address = {
      //合约地址
      contractAddress: "0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a",
      //发送者
      fromAddress: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
      //调用者
      toAddress: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1"
    }
    //  04. 打包数据
    let Parames_row = {
      Tx_nonce: web3.toHex(web3.eth.getTransactionCount(Parames_address.fromAddress)),
      Tx_gasPrice: web3.toHex(web3.eth.gasPrice), // TODO:
      Tx_gasLimit: web3.toHex(90000), // TODO:
      Tx_from: Parames_address.fromAddress, // TODO:
      Tx_to: Parames_address.contractAddress,
      Tx_value: "0x0", // TODO:
      // TODO:
      Tx_data: Contract_Drop.flyDrop.getData(Parames_data.Value.destAddrs, Parames_data.Value.values, {
        from: Parames_address.fromAddress
      })
    }
    //  05  对接数据
    let rawTx = {
      nonce: Parames_row.Tx_nonce,
      gasPrice: Parames_row.Tx_gasPrice, // TODO:
      gasLimit: Parames_row.Tx_gasLimit,
      from: Parames_row.Tx_from,
      to: Parames_row.Tx_to,
      value: Parames_row.Tx_value, // TODO:
      data: Parames_row.Tx_data
    }
    //06.获取处理后的数据
    let SignData = Actions_CommonTool.Tool_SignData({
      rawTx: rawTx,
      key: Json_list.PRIVATEKEY.TokenMgr_privateKey
    });
    //07.  发送
    result = await web3.eth.sendRawTransaction(SignData);
    //08.  back
    return result;
  }
}
//11.Actions_Configure=>项目相关配置信息()
var Actions_Configure = {
  Abi_Token: {

  },
  Abi_drop: {

  },
  Abi_TokenMgr: {

  }

}
//13.Actions_Commontool =>公共方法
var Actions_CommonTool = {

  Tool_SignData: (data) => {//3483
    //  01.封装对象
    let tx = new Tx(data.rawTx);
    //  02.序列化私钥
    let privateKey = Actions_Web3jsUtils.web3_bufferPrivateKey(data.key);
    //  03. 用私钥给数据签名
    tx.sign(privateKey);
    //  04. 对数据编码
    let serializeTx = '0x' + tx.serialize().toString('hex');
    //  05 返回
    return serializeTx;
  },
  Tool_bufferPrivateKey: (data) => {
    let key;
    switch (data.key) {
      case 'key_token':
        key = Actions_Web3jsUtils.web3_bufferPrivateKey(Json_list.PRIVATEKEY.Token_privateKey);
        break;
      case 'key_drop':
        key = Actions_Web3jsUtils.web3_bufferPrivateKey(Json_list.PRIVATEKEY.Drop_privateKey);
        break;
      case 'key_mgr':
        key = Actions_Web3jsUtils.web3_bufferPrivateKey(Json_list.PRIVATEKEY.TokenMgr_privateKey);
        break;
      default:
        key = "";
        break;
    }
    return key;
  },
  Tool_bufferPrivateKey11: () => {


  },
  //  Cancel the transaction if the current price of natural gas is too high
  Tool_gasHign: () => {


  }

}
//12.Json_list=>常量信息的相关管理(abi,合约地址,gas参数,等)
const Json_list = {
  ABI_TOKEN: [{
      "constant": false,
      "inputs": [{
          "name": "_spender",
          "type": "address"
        },
        {
          "name": "_value",
          "type": "uint256"
        }
      ],
      "name": "approve",
      "outputs": [{
        "name": "success",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [],
      "name": "totalSupply",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_from",
          "type": "address"
        },
        {
          "name": "_to",
          "type": "address"
        },
        {
          "name": "_value",
          "type": "uint256"
        }
      ],
      "name": "transferFrom",
      "outputs": [{
        "name": "success",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
        "name": "_owner",
        "type": "address"
      }],
      "name": "balanceOf",
      "outputs": [{
        "name": "balance",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_to",
          "type": "address"
        },
        {
          "name": "_value",
          "type": "uint256"
        }
      ],
      "name": "transfer",
      "outputs": [{
        "name": "success",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
          "name": "_owner",
          "type": "address"
        },
        {
          "name": "_spender",
          "type": "address"
        }
      ],
      "name": "allowance",
      "outputs": [{
        "name": "remaining",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "anonymous": false,
      "inputs": [{
          "indexed": true,
          "name": "_from",
          "type": "address"
        },
        {
          "indexed": true,
          "name": "_to",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "_value",
          "type": "uint256"
        }
      ],
      "name": "Transfer",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [{
          "indexed": true,
          "name": "_owner",
          "type": "address"
        },
        {
          "indexed": true,
          "name": "_spender",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "_value",
          "type": "uint256"
        }
      ],
      "name": "Approval",
      "type": "event"
    }
  ],
  ADDRESS_TOKEN: '0xaA3A01dBa149B109d5e9090f1ad1f2cEbA1C272a',
  ABI_DROP: [{
      "constant": false,
      "inputs": [{
          "name": "spender",
          "type": "address"
        },
        {
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "approve",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_destAddrs",
          "type": "address[]"
        },
        {
          "name": "_values",
          "type": "uint256[]"
        },
        {
          "name": "_valuesmyself",
          "type": "uint256"
        }
      ],
      "name": "multiSendandself",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
        "name": "_token",
        "type": "address"
      }],
      "name": "setToken",
      "outputs": [],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [],
      "name": "totalSupply",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
        "name": "",
        "type": "address"
      }],
      "name": "historicalOwner",
      "outputs": [{
        "name": "",
        "type": "string"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "from",
          "type": "address"
        },
        {
          "name": "to",
          "type": "address"
        },
        {
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "transferFrom",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
        "name": "",
        "type": "address"
      }],
      "name": "snList",
      "outputs": [{
        "name": "",
        "type": "string"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "spender",
          "type": "address"
        },
        {
          "name": "addedValue",
          "type": "uint256"
        }
      ],
      "name": "increaseAllowance",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
        "name": "",
        "type": "address"
      }],
      "name": "erctypeName",
      "outputs": [{
        "name": "",
        "type": "string"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
        "name": "_owneraddress",
        "type": "address"
      }],
      "name": "deltrustOwner",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
        "name": "",
        "type": "address"
      }],
      "name": "trustOwner",
      "outputs": [{
        "name": "",
        "type": "string"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_destAddrs",
          "type": "address[]"
        },
        {
          "name": "_values",
          "type": "uint256[]"
        }
      ],
      "name": "multiSend2",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_ownaddress",
          "type": "address"
        },
        {
          "name": "_owntext",
          "type": "string"
        }
      ],
      "name": "settrustOwner",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
        "name": "owner",
        "type": "address"
      }],
      "name": "balanceOf",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
        "name": "a",
        "type": "string"
      }],
      "name": "myself",
      "outputs": [{
        "name": "",
        "type": "string"
      }],
      "payable": false,
      "stateMutability": "pure",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
          "name": "a",
          "type": "uint256"
        },
        {
          "name": "b",
          "type": "uint256"
        }
      ],
      "name": "add",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "pure",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [],
      "name": "owner",
      "outputs": [{
        "name": "",
        "type": "address"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_tokentype",
          "type": "address"
        },
        {
          "name": "_tokenName",
          "type": "string"
        }
      ],
      "name": "seterctypeName",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "spender",
          "type": "address"
        },
        {
          "name": "subtractedValue",
          "type": "uint256"
        }
      ],
      "name": "decreaseAllowance",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "to",
          "type": "address"
        },
        {
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "transfer",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_destAddrs",
          "type": "address[]"
        },
        {
          "name": "_values",
          "type": "uint256[]"
        }
      ],
      "name": "multiSend",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_values",
          "type": "uint256"
        },
        {
          "name": "addres_owner",
          "type": "address"
        }
      ],
      "name": "multiself",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [{
          "name": "owner",
          "type": "address"
        },
        {
          "name": "spender",
          "type": "address"
        }
      ],
      "name": "allowance",
      "outputs": [{
        "name": "",
        "type": "uint256"
      }],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [{
          "name": "_hisaddress",
          "type": "address"
        },
        {
          "name": "_histext",
          "type": "string"
        }
      ],
      "name": "sethistoricalOwner",
      "outputs": [{
        "name": "",
        "type": "bool"
      }],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [],
      "payable": false,
      "stateMutability": "nonpayable",
      "type": "constructor"
    },
    {
      "anonymous": false,
      "inputs": [{
          "indexed": true,
          "name": "from",
          "type": "address"
        },
        {
          "indexed": true,
          "name": "to",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "Transfer",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [{
          "indexed": true,
          "name": "owner",
          "type": "address"
        },
        {
          "indexed": true,
          "name": "spender",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "Approval",
      "type": "event"
    }
  ],
  ADDRESS_DROP: '0x7Dc6Dc91178a6fEF2Fa5Bd1de32c5642e6Ae421b',
  ABI_TOKENMGR: [],
  ADDRESS_TOKENMGR: "",
  PRIVATEKEY: {
    Token_privateKey: "F9B224ECF9161EEA3A815338FA70EF11F82AC1C5CAB145D264ADC1E110FA0907",
    TokenMgr_privateKey: "F9B224ECF9161EEA3A815338FA70EF11F82AC1C5CAB145D264ADC1E110FA0907",
    Drop_privateKey: "F9B224ECF9161EEA3A815338FA70EF11F82AC1C5CAB145D264ADC1E110FA0907",
    TEST: "123"
  },
  STATES_PAR: {
    notAddress: {
      status: "addressinull",
      msg: "地址为空"
    },
    notValue: {
      status: "valueisnull",
      msg: "数值为空"
    },
    notAddressandValue: {
      status: "notAddressandValue",
      msg: "地址数据都为空"
    },
    CheckPass: {
      status: "Check pass",
      msg: "数据通过校验"
    },
    wrongAddress: {
      status: "illegaladdress ",
      msg: "非法地址"
    }
  },
  //Limiting the number of cycles
  LIMITINGTHENUMBEROFCYCLES: {
    LM_100: 100,
    LM_150: 150,
    LM_180: 180,
    LM_200: 200,
    LM_240: 240,
    LM_000: 0
  },
  USE_ADDRESS: {
    User_1: "0x38a8DC14edE1DEf9C437bB3647445eEec06fF105",
    User_2: "0xd2580AB2EB3313B0972e9e47b05eE4c15320A6D1",
    User_3: "0xA9af645Ce31AF413b24a3b913f1a5Bf57A7a1C50",
    User_4: "0x3846a0e5e3a93900B5c0F8BA1504e0B55Ca201e5"
  }

};
//13.追加配置
const Json_Bz = {};
//二级启动
var Actions_Starting = {
  //init  web3, 合约对象
  init: () => {
    //
    Actions_initWeb3Provider.initWeb3();
    // Actions_initWeb3Provider.initContract_Token();
    Actions_initWeb3Provider.initContract_Drop();
  },
  //test 启动
  test: () => {
    console.log("log........");
  },
  log: () => {
    console.log("-");
  }
}
//一级启动
var Actions = {
  //Action 启动其它函数
  init: (data) => {
    Actions_Koa.render();
    Actions_Koa.user();
    //
    Actions_Router.router_get();
    Actions_Router.router_post();
    Actions_Starting.init();
    console.log(data);
  }
}
//启动
Actions.init("starting........");

3 坑

留言，这些坑很多