1

server/web3service/C.js

@@ -0,0 +1,3 @@
+const BC_INITIALIZED_EVENT = 'bc_initialized';
+
+exports.BC_INITIALIZED_EVENT = BC_INITIALIZED_EVENT;

server/web3service/app.js

@@ -0,0 +1,16 @@
+const app = require('j7/app');
+const event = require('j7/event');
+const config = require('j7/config');
+
+event.addListener(event.APP_INITIALIZED_EVENT, async () => {
+  require('./metadata/factory').init();
+  await require('./blockchain').init();
+  require('./middlewares/factory').init();
+  require('./controllers/factory').init();
+  require('./models/factory').init();
+  require('./services/factory').init();
+  app.injectionSession(require('./session'));
+  console.log(config('listen_port'));
+  app.listen(config('listen_port'));
+});
+app.init();

server/web3service/blockchain.js

@@ -0,0 +1,72 @@
+const util = require('util');
+const Web3 = require('web3');
+const utils = require('j7/utils');
+const bcutils = require('j7/bcutils');
+const event = require('j7/event');
+const sync = require("j7/sync");
+const log = require("j7/log");
+const metaFactory = require('./metadata/factory');
+const C = require("./C");
+
+class BlockChain {
+
+  constructor() {
+    this.netId = 0;
+  }
+
+  async initInstance(user, address, jsonUrl) {
+    const json = utils.readJsonFromFile(jsonUrl);
+    return new this.web3.eth.Contract(
+      json.abi,
+      address,
+      { from: user }
+    );
+  }
+
+  async init() {
+    this.web3 = new Web3(metaFactory.getWeb3Conf()['block_server']);
+    this.web3.eth.handleRevert = true;
+    this.web3.eth.accounts.wallet.add(metaFactory.getPrivateKey());
+    for (const data of metaFactory.getContracts()) {
+      this[`${data.name}Instance`] = await this.initInstance
+      (metaFactory.getUserAddress(), data.address, data.json);
+    }
+    event.emitEvent(C.BC_INITIALIZED_EVENT);
+  }
+
+  async getNetId() {
+    return await this.web3.eth.getChainId();
+  }
+
+  getNftAddress(tokenType) {
+    switch (Number(tokenType)) {
+    case bcutils.HERO_TYPE:
+      {
+        return metaFactory.getContractByName('HERO')['address'];
+      }
+      break;
+    case bcutils.EQUIP_TYPE:
+      {
+        return metaFactory.getContractByName('WEAPON')['address'];
+      }
+      break;
+    case bcutils.CHIP_TYPE:
+      {
+        return metaFactory.getContractByName('CHIP')['address'];
+      }
+      break;
+    case bcutils.FRAGMENT_TYPE:
+      {
+        return metaFactory.getContractByName('shard')['address'];
+      }
+      break;
+    default:
+      {
+        return '';
+      }
+    }
+  }
+
+}
+
+module.exports = new BlockChain();

server/web3service/controllers/activate.js

@@ -0,0 +1,108 @@
+const ethUtil = require('ethereumjs-util');
+const sigUtil = require('@metamask/eth-sig-util');
+
+const app = require('j7/app');
+const utils = require('j7/utils');
+const bcutils = require('j7/bcutils');
+const bc = require('../blockchain');
+const metaFactory = require('../metadata/factory');
+
+async function activate721Nft(session) {
+  try {
+    const accountId = session.request('account_id');
+    const account = session.request('account');
+    const sessionId = session.request('session_id');
+    const tokenId = session.request('token_id');
+    const tokenType = session.request('token_type');
+    const itemUniId = session.request('item_uniid');
+    const itemId = session.request('item_id');
+
+    const nftAddress = bc.getNftAddress(tokenType);
+    const userAddress = metaFactory.getUserAddress();
+
+    {
+      const itemMeta = metaFactory.getMetaByKey('Item', itemId);
+      if (!itemMeta) {
+        session.rspErr(101, 'item_id param error');
+        return;
+      }
+      if (itemMeta.getNftType() != tokenType) {
+        session.rspErr(101, 'item_id param error');
+        return;
+      }
+      if (!(itemMeta.getNftType() == bcutils.HERO_TYPE ||
+            itemMeta.getNftType() == bcutils.EQUIP_TYPE ||
+            itemMeta.getNftType() == bcutils.CHIP_TYPE)) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+    }
+    {
+      if (!nftAddress) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+    }
+
+    const transModel = session.createModel('Transaction');
+    const {err, seqId} = await transModel.add(account, session.requestToJson());
+    if (err) {
+      session.rspErr(500, 'server internal error');
+      return;
+    }
+
+    const nowTime = utils.getUtcTime();
+    const transId = bcutils.genTransId
+    (
+      bcutils.BC_TRANS_FUNC_ACTIVATE,
+      nowTime,
+      seqId,
+      [
+        itemUniId,
+        itemId
+      ]
+    );
+    await transModel.update
+    (
+      seqId,
+      [
+        ['trans_id', transId]
+      ]);
+    const nonce = transId;
+    const tokenIds = [tokenId];
+    utils.arrayToStrings(tokenIds);
+    let signStr = await bc.web3.utils.soliditySha3
+    (
+      account,
+      nftAddress,
+      nowTime,
+      nonce,
+      ...tokenIds
+    );
+    let signature = await bc.web3.eth.sign(signStr, userAddress);
+    signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+
+    const rspParams = [
+      nftAddress,
+      utils.jsonEncode(tokenIds),
+      nowTime,
+      nonce,
+      signature
+    ];
+    utils.arrayToStrings(rspParams);
+
+    session.rspData({
+      'trans_id' : transId,
+      'params': rspParams
+    });
+  } catch (e) {
+    session.rspErr(1, 1);
+    console.log(e);
+  }
+}
+
+function init() {
+  app.registerHandler('BcService', 'activate721Nft', activate721Nft);
+}
+
+exports.init = init;

server/web3service/controllers/bcservice.js

@@ -0,0 +1,156 @@
+const ethUtil = require('ethereumjs-util');
+const sigUtil = require('@metamask/eth-sig-util');
+
+const app = require('j7/app');
+const utils = require('j7/utils');
+const bc = require('../blockchain');
+const metaFactory = require('../metadata/factory');
+
+async function authVerifySignature(session) {
+  try {
+    //const netId = await bc.getNetId();
+    const msgParams = {
+      types: {
+        EIP712Domain: [
+          { name: 'name', type: 'string' },
+          { name: 'version', type: 'string' },
+        ],
+        set: [
+          { name: 'tips', type: 'string' },
+          { name: 'nonce', type: 'string' },
+        ]
+      },
+      primaryType: 'set',
+      domain: {
+        name: 'Auth',
+        version: '1',
+      },
+      message: {
+        tips: session.request('tips'),
+        nonce: session.request('nonce')
+      }
+    };
+    const recovered = sigUtil.recoverTypedSignature(
+      {data:
+       msgParams,
+       signature: session.request('signature'),
+       version: 'V4'});
+    session.rspData(
+      {
+        'recovered': recovered
+      });
+  } catch (err) {
+    session.rspErr(1, err);
+  }
+}
+
+async function buyBoxVerifySignature(session) {
+  try {
+    const netId = await bc.getNetId();
+    const msgParams = {
+      types: {
+        EIP712Domain: [
+          { name: 'name', type: 'string' },
+          { name: 'version', type: 'string' },
+          { name: 'chainId', type: 'uint256' },
+          { name: 'verifyingContract', type: 'address' }
+        ],
+        set: [
+          { name: 'item', type: 'uint256' },
+          { name: 'token', type: 'address' },
+          { name: 'price', type: 'uint256' },
+          { name: 'salt', type: 'uint256' }
+        ]
+      },
+      primaryType: 'set',
+      domain: {
+        name: 'BEBoxMall',
+        version: '1',
+        chainId: netId,
+        verifyingContract: metaFactory.getMetaByKey('Contract', 'mall')['address'],
+      },
+      message: {
+        item: session.request('type'),
+        token: session.request('paymentTokenAddress'),
+        price: session.request('price'),
+        salt: session.request('nonce')
+      }
+    };
+    const recovered = sigUtil.recoverTypedSignature(
+      {data: msgParams,
+       signature: session.request('signature'),
+       version: 'V4'});
+    console.log(recovered);
+    session.rspData(
+      {
+        'recovered': recovered
+      });
+  } catch (err) {
+    console.log(err);
+    session.rspErr(1, err);
+  }
+}
+
+async function openBoxSignature(session) {
+  const userAddress = metaFactory.getUserAddress();
+  const boxId = session.request('box_token_id');
+  const tokenIds = [];
+  tokenIds.push(session.request('token_id1'));
+  tokenIds.push(session.request('token_id2'));
+  tokenIds.push(session.request('token_id3'));
+
+  let nonce = utils.getUtcTime();
+  let signStr = bc.web3.utils.soliditySha3(
+    boxId,
+    tokenIds[0],
+    tokenIds[1],
+    tokenIds[2],
+    nonce
+  );
+  let signature = await bc.web3.eth.sign(signStr, userAddress);
+  signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+  console.log('openLuckyBox||sign: ', signature, userAddress, boxId,  tokenIds, nonce);
+  session.rspData({
+    'nonce': nonce,
+    'signature': signature
+  });
+}
+
+async function activateNftSignature(session) {
+  const userAddress = metaFactory.getUserAddress();
+  const account = session.request('account');
+  const oldTokenId = session.request('old_token_id');
+  const oldTokenType = session.request('old_token_type');
+  const newTokenId = session.request('new_token_id');
+
+  let nonce = utils.getUtcTime();
+  let signStr = bc.web3.utils.soliditySha3(
+    account,
+    oldTokenId,
+    newTokenId,
+    oldTokenType,
+    nonce
+  );
+  let signature = await bc.web3.eth.sign(signStr, userAddress);
+  signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+  console.log('activateNftSignature||sign: ',
+              signature,
+              userAddress,
+              oldTokenId,
+              newTokenId,
+              oldTokenType,
+              nonce);
+  session.rspData({
+    'nonce': nonce,
+    'signature': signature
+  });
+}
+
+function init() {
+  app.registerHandler('BcService', 'authVerifySignature', authVerifySignature);
+  app.registerHandler('BcService', 'buyBoxVerifySignature', buyBoxVerifySignature);
+  app.registerHandler('BcService', 'openBoxSignature', openBoxSignature);
+  app.registerHandler('BcService', 'activateNftSignature', activateNftSignature);
+}
+
+exports.init = init;

server/web3service/controllers/chip_plugin.js

@@ -0,0 +1,239 @@
+const ethUtil = require('ethereumjs-util');
+const sigUtil = require('@metamask/eth-sig-util');
+
+const app = require('j7/app');
+const utils = require('j7/utils');
+const bcutils = require('j7/bcutils');
+const bc = require('../blockchain');
+const metaFactory = require('../metadata/factory');
+
+async function pluginChip(session) {
+  try {
+    const accountId = session.request('account_id');
+    const account = session.request('account');
+    const sessionId = session.request('session_id');
+    const tokenId = session.request('token_id');
+    const tokenType = session.request('token_type');
+    const chipIds = session.request('chip_ids').split('|');
+    const slotIds = session.request('slot_ids').split('|');
+
+    const nftAddress = bc.getNftAddress(tokenType);
+    const chipAddress = bc.getNftAddress(bcutils.CHIP_TYPE);
+    const userAddress = metaFactory.getUserAddress();
+
+    {
+      if (!(tokenType == bcutils.HERO_TYPE ||
+            tokenType == bcutils.EQUIP_TYPE)) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+      if (!nftAddress) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+      if (!chipAddress) {
+        session.rspErr(101, 'chip_type param error');
+        return;
+      }
+      if (chipIds.length != slotIds.length ||
+          chipIds.length > 4) {
+        session.rspErr(101, 'chip_ids length error');
+        return;
+      }
+    }
+
+    const transModel = session.createModel('Transaction');
+    const {err, seqId} = await transModel.add(account, session.requestToJson());
+    if (err) {
+      session.rspErr(500, 'server internal error');
+      return;
+    }
+
+    const nowTime = utils.getUtcTime();
+    const transId = bcutils.genTransId
+    (
+      bcutils.BC_TRANS_FUNC_PLUGIN,
+      nowTime,
+      seqId,
+      [
+      ]
+    );
+    await transModel.update
+    (
+      seqId,
+      [
+        ['trans_id', transId]
+      ]);
+    const nonce = transId;
+    const signArr = [];
+    for (let i = 0; i < chipIds.length; ++i) {
+      signArr.push(chipIds[i]);
+      signArr.push(slotIds[i]);
+    }
+    let signStr = await bc.web3.utils.soliditySha3
+    (
+      nftAddress,
+      chipAddress,
+      account,
+
+      tokenId,
+      nonce,
+      nowTime,
+
+      ...signArr
+    );
+    let signature = await bc.web3.eth.sign(signStr, userAddress);
+    signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+
+    const addresses = [
+      nftAddress,
+      chipAddress,
+      userAddress
+    ];
+    const values = [
+      tokenId,
+      nonce,
+      nowTime
+    ];
+    utils.arrayToStrings(addresses);
+    utils.arrayToStrings(values);
+    utils.arrayToStrings(chipIds);
+    utils.arrayToStrings(slotIds);
+
+    const rspParams = [
+      utils.jsonEncode(addresses),
+      utils.jsonEncode(values),
+      utils.jsonEncode(chipIds),
+      utils.jsonEncode(slotIds),
+      signature
+    ];
+    utils.arrayToStrings(rspParams);
+
+    session.rspData({
+      'trans_id' : transId,
+      'params': rspParams
+    });
+  } catch (e) {
+    session.rspErr(1, 1);
+    console.log(e);
+  }
+}
+
+async function unplugChip(session) {
+  try {
+    const accountId = session.request('account_id');
+    const account = session.request('account');
+    const sessionId = session.request('session_id');
+    const tokenId = session.request('token_id');
+    const tokenType = session.request('token_type');
+    const chipIds = session.request('chip_ids').split('|');
+    const slotIds = session.request('slot_ids').split('|');
+
+    const nftAddress = bc.getNftAddress(tokenType);
+    const chipAddress = bc.getNftAddress(bcutils.CHIP_TYPE);
+    const userAddress = metaFactory.getUserAddress();
+
+    {
+      if (!(tokenType == bcutils.HERO_TYPE ||
+            tokenType == bcutils.EQUIP_TYPE)) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+      if (!nftAddress) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+      if (!chipAddress) {
+        session.rspErr(101, 'chip_type param error');
+        return;
+      }
+      if (chipIds.length != slotIds.length ||
+          chipIds.length > 4) {
+        session.rspErr(101, 'chip_ids length error');
+        return;
+      }
+    }
+
+    const transModel = session.createModel('Transaction');
+    const {err, seqId} = await transModel.add(account, session.requestToJson());
+    if (err) {
+      session.rspErr(500, 'server internal error');
+      return;
+    }
+
+    const nowTime = utils.getUtcTime();
+    const transId = bcutils.genTransId
+    (
+      bcutils.BC_TRANS_FUNC_PLUGIN,
+      nowTime,
+      seqId,
+      [
+      ]
+    );
+    await transModel.update
+    (
+      seqId,
+      [
+        ['trans_id', transId]
+      ]);
+    const nonce = transId;
+    const signArr = [];
+    for (let i = 0; i < chipIds.length; ++i) {
+      signArr.push(chipIds[i]);
+      signArr.push(slotIds[i]);
+    }
+    let signStr = await bc.web3.utils.soliditySha3
+    (
+      nftAddress,
+      chipAddress,
+      account,
+
+      tokenId,
+      nonce,
+      nowTime,
+
+      ...signArr
+    );
+    let signature = await bc.web3.eth.sign(signStr, userAddress);
+    signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+
+    const addresses = [
+      nftAddress,
+      chipAddress,
+      userAddress
+    ];
+    const values = [
+      tokenId,
+      nonce,
+      nowTime
+    ];
+    utils.arrayToStrings(addresses);
+    utils.arrayToStrings(values);
+    utils.arrayToStrings(chipIds);
+    utils.arrayToStrings(slotIds);
+
+    const rspParams = [
+      utils.jsonEncode(addresses),
+      utils.jsonEncode(values),
+      utils.jsonEncode(chipIds),
+      utils.jsonEncode(slotIds),
+      signature
+    ];
+    utils.arrayToStrings(rspParams);
+
+    session.rspData({
+      'trans_id' : transId,
+      'params': rspParams
+    });
+  } catch (e) {
+    session.rspErr(1, 1);
+    console.log(e);
+  }
+}
+
+function init() {
+  app.registerHandler('BcService', 'pluginChip', pluginChip);
+  app.registerHandler('BcService', 'unplugChip', unplugChip);
+}
+
+exports.init = init;

server/web3service/controllers/evolve.js

@@ -0,0 +1,195 @@
+const ethUtil = require('ethereumjs-util');
+const sigUtil = require('@metamask/eth-sig-util');
+
+const app = require('j7/app');
+const utils = require('j7/utils');
+const bcutils = require('j7/bcutils');
+const bc = require('../blockchain');
+const metaFactory = require('../metadata/factory');
+
+async function evolve721Nft(session) {
+  try {
+    const accountId = session.request('account_id');
+    const sessionId = session.request('session_id');
+    const account = session.request('account');
+    const type = session.request('type');
+    const tokenId1 = session.request('token_id1');
+    const tokenId2 = session.request('token_id2');
+
+    console.log(session.requestToJson());
+    let tokenType = 0;
+    switch (type) {
+    case '1':
+      {
+        tokenType = bcutils.HERO_TYPE;
+      }
+      break;
+    case '2':
+      {
+        tokenType = bcutils.EQUIP_TYPE;
+      }
+      break;
+    default:
+      {
+        session.rspErr(101, 'type paramater error');
+        return;
+      }
+      break;
+    }
+
+    const nftAddress = bc.getNftAddress(tokenType);
+    const userAddress = metaFactory.getUserAddress();
+
+    {
+      if (!nftAddress) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+    }
+
+    const transModel = session.createModel('Transaction');
+    const {err, seqId} = await transModel.add(account, session.requestToJson());
+    if (err) {
+      session.rspErr(500, 'server internal error');
+      return;
+    }
+
+    const nowTime = utils.getUtcTime();
+    const transId = bcutils.genTransId
+    (
+      bcutils.BC_TRANS_FUNC_EVOLVE,
+      nowTime,
+      seqId,
+      [
+        tokenType
+      ]
+    );
+    await transModel.update
+    (
+      seqId,
+      [
+        ['trans_id', transId]
+      ]);
+    const tokenIds = [tokenId1, tokenId2];
+    const nonce = transId;
+    let signStr = await bc.web3.utils.soliditySha3
+    (
+      account,
+      nowTime,
+      nonce,
+      ...tokenIds
+    );
+    let signature = await bc.web3.eth.sign(signStr, userAddress);
+    signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+
+    utils.arrayToStrings(tokenIds);
+
+    const rspParams = [
+      nftAddress,
+      utils.jsonEncode(tokenIds),
+      nowTime,
+      nonce,
+      signature
+    ];
+    utils.arrayToStrings(rspParams);
+    console.log(rspParams);
+
+    session.rspData({
+      'trans_id' : transId,
+      'params': rspParams
+    });
+  } catch (e) {
+    session.rspErr(1, 1);
+    console.log(e);
+  }
+}
+
+async function evolveChip(session) {
+  try {
+    const accountId = session.request('account_id');
+    const account = session.request('account');
+    const sessionId = session.request('session_id');
+    const tokenId = session.request('token_id');
+    const itemId = session.request('item_id');
+    const tokenIds = session.request('token_ids').toString().split('|');
+
+    const price = 0;
+    const nftAddress = bc.getNftAddress(bcutils.CHIP_TYPE);
+    const userAddress = metaFactory.getUserAddress();
+    const paymentTokenAddress = metaFactory.getContractByName('gold')['address'];
+
+    {
+      if (!nftAddress) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+    }
+
+    const transModel = session.createModel('Transaction');
+    const {err, seqId} = await transModel.add(account, session.requestToJson());
+    if (err) {
+      session.rspErr(500, 'server internal error');
+      return;
+    }
+
+    const nowTime = utils.getUtcTime();
+    const transId = bcutils.genTransId
+    (
+      bcutils.BC_TRANS_FUNC_EVOLVE,
+      nowTime,
+      seqId,
+      [
+        bcutils.CHIP_TYPE
+      ]
+    );
+    await transModel.update
+    (
+      seqId,
+      [
+        ['trans_id', transId]
+      ]);
+    const nonce = transId;
+    const signArr = [tokenId];
+    tokenIds.forEach
+    (
+      (element) => {
+        signArr.push(element);
+      }
+    );
+    let signStr = await bc.web3.utils.soliditySha3
+    (
+      account,
+      nowTime,
+      nonce,
+      ...signArr
+    );
+    let signature = await bc.web3.eth.sign(signStr, userAddress);
+    signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+
+    utils.arrayToStrings(signArr);
+
+    const rspParams = [
+      utils.jsonEncode(signArr),
+      nowTime,
+      nonce,
+      signature
+    ];
+    utils.arrayToStrings(rspParams);
+    console.log(rspParams);
+
+    session.rspData({
+      'trans_id' : transId,
+      'params': rspParams
+    });
+  } catch (e) {
+    session.rspErr(1, 1);
+    console.log(e);
+  }
+}
+
+function init() {
+  app.registerHandler('BcService', 'evolve721Nft', evolve721Nft);
+  app.registerHandler('BcService', 'evolveChip', evolveChip);
+}
+
+exports.init = init;

server/web3service/controllers/factory.js

@@ -0,0 +1,16 @@
+const controllers = {};
+
+function add(name) {
+  controllers[name] = require(`./${name}`);
+  controllers[name].init();
+}
+
+function init() {
+  add('bcservice');
+  add('activate');
+  //add('fragment');
+  //add('evolve');
+  //add('chip_plugin');
+}
+
+exports.init = init;

server/web3service/controllers/fragment.js

@@ -0,0 +1,232 @@
+const ethUtil = require('ethereumjs-util');
+const sigUtil = require('@metamask/eth-sig-util');
+
+const app = require('j7/app');
+const utils = require('j7/utils');
+const bcutils = require('j7/bcutils');
+const bc = require('../blockchain');
+const metaFactory = require('../metadata/factory');
+
+async function mintShardBatchUser(session) {
+  try {
+    const accountId = session.request('account_id');
+    const account = session.request('account');
+    const sessionId = session.request('session_id');
+    const tokenId = session.request('token_id');
+    const itemUniId = session.request('item_uniid');
+    const itemId = session.request('item_id');
+    const num = session.request('num');
+
+    const nftAddress = bc.getNftAddress(bcutils.FRAGMENT_TYPE);
+    const userAddress = metaFactory.getUserAddress();
+
+    {
+      if (!nftAddress) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+    }
+
+    const transModel = session.createModel('Transaction');
+    const {err, seqId} = await transModel.add(account, session.requestToJson());
+    if (err) {
+      session.rspErr(500, 'server internal error');
+      return;
+    }
+
+    const nowTime = utils.getUtcTime();
+    const transId = bcutils.genTransId
+    (
+      bcutils.BC_TRANS_FUNC_MINT_SHARD,
+      nowTime,
+      seqId,
+      [
+        itemUniId,
+        utils.pad(itemId, 10) + utils.pad(num, 10)
+      ]
+    );
+    await transModel.update
+    (
+      seqId,
+      [
+        ['trans_id', transId]
+      ]);
+    const nonce = transId;
+    let signStr = await bc.web3.utils.soliditySha3
+    (
+      account,
+      nftAddress,
+      nowTime,
+      nonce,
+      tokenId,
+      num
+    );
+    let signature = await bc.web3.eth.sign(signStr, userAddress);
+    signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+
+    const ids = [
+      tokenId
+    ];
+    const amounts = [
+      num
+    ];
+    utils.arrayToStrings(ids);
+    utils.arrayToStrings(amounts);
+
+    const rspParams = [
+      utils.jsonEncode(ids),
+      utils.jsonEncode(amounts),
+      nowTime,
+      nonce,
+      signature
+    ];
+    utils.arrayToStrings(rspParams);
+
+    session.rspData({
+      'trans_id' : transId,
+      'params': rspParams
+    });
+  } catch (e) {
+    session.rspErr(1, 1);
+    console.log(e);
+  }
+}
+
+async function shardMixByUser(session) {
+  try {
+    const accountId = session.request('account_id');
+    const account = session.request('account');
+    const sessionId = session.request('session_id');
+    const tokenId = session.request('token_id');
+    const tokenType = session.request('token_type');
+    const itemId = session.request('item_id');
+    const tokenIds = session.request('token_ids').toString().split('|');
+
+    const price = 0;
+    const nftAddress = bc.getNftAddress(tokenType);
+    const shardAddress = metaFactory.getContractByName('shard')['address'];
+    const userAddress = metaFactory.getUserAddress();
+    const paymentTokenAddress = metaFactory.getContractByName('gold')['address'];
+
+    console.log(session.requestToJson());
+    if (itemId) {
+      const itemMeta = metaFactory.getMetaByKey('Item', itemId);
+      console.log(itemMeta, itemId);
+      if (!itemMeta) {
+        session.rspErr(101, 'item_id param error');
+        return;
+      }
+      if (itemMeta.getNftType() != tokenType) {
+        session.rspErr(101, 'item_id param error');
+        return;
+      }
+      if (!(itemMeta.getNftType() == bcutils.HERO_TYPE ||
+            itemMeta.getNftType() == bcutils.EQUIP_TYPE)) {
+        session.rspErr(101, 'item_id param error');
+        return;
+      }
+    }
+
+    let nftType = 0;
+    if (tokenType == bcutils.HERO_TYPE) {
+      nftType = 0;
+    } else if (tokenType == bcutils.EQUIP_TYPE) {
+      nftType = 1;
+    } else {
+      session.rspErr(101, 'invalid nft type');
+      return;
+    }
+
+    {
+      if (!nftAddress) {
+        session.rspErr(101, 'token_type param error');
+        return;
+      }
+    }
+
+    const transModel = session.createModel('Transaction');
+    const {err, seqId} = await transModel.add(account, session.requestToJson());
+    if (err) {
+      session.rspErr(500, 'server internal error');
+      return;
+    }
+
+    const nowTime = utils.getUtcTime();
+    const transId = bcutils.genTransId
+    (
+      bcutils.BC_TRANS_FUNC_MINT_SHARD,
+      nowTime,
+      seqId,
+      [
+        utils.pad(itemId, 10) + utils.pad(tokenType, 10)
+      ]
+    );
+    await transModel.update
+    (
+      seqId,
+      [
+        ['trans_id', transId]
+      ]);
+    const nonce = transId;
+    const signArr = [];
+    tokenIds.forEach
+    (
+      (element) => {
+        signArr.push(element);
+        signArr.push(1);
+      }
+    );
+    let signStr = await bc.web3.utils.soliditySha3
+    (
+      account,
+      nftAddress,
+      tokenId,
+      paymentTokenAddress,
+      price,
+      nowTime,
+      nonce,
+      ...signArr
+    );
+    let signature = await bc.web3.eth.sign(signStr, userAddress);
+    signature = signature.replace(/00$/, "1b").replace(/01$/, "1c");
+
+    const amounts = [];
+    tokenIds.forEach
+    (
+      (element) => {
+        amounts.push(1);
+      }
+    );
+    utils.arrayToStrings(tokenIds);
+    utils.arrayToStrings(amounts);
+
+    const rspParams = [
+      tokenId,
+      nftType,
+      paymentTokenAddress,
+      price,
+      utils.jsonEncode(tokenIds),
+      utils.jsonEncode(amounts),
+      nowTime,
+      nonce,
+      signature
+    ];
+    utils.arrayToStrings(rspParams);
+    console.log(rspParams);
+
+    session.rspData({
+      'trans_id' : transId,
+      'params': rspParams
+    });
+  } catch (e) {
+    console.log(e);
+    session.rspErr(1, 1);
+  }
+}
+
+function init() {
+  app.registerHandler('BcService', 'mintShardBatchUser', mintShardBatchUser);
+  app.registerHandler('BcService', 'shardMixByUser', shardMixByUser);
+}
+
+exports.init = init;

server/web3service/metadata/Config.js

@@ -0,0 +1,8 @@
+const utils = require('j7/utils');
+const basewrap = require('./basewrap');
+
+class Config extends basewrap.BaseWrap {
+
+}
+
+module.exports = Config;

server/web3service/metadata/Contract.js

@@ -0,0 +1,8 @@
+const utils = require('j7/utils');
+const basewrap = require('./basewrap');
+
+class Contract extends basewrap.BaseWrap {
+
+}
+
+module.exports = Contract;

server/web3service/metadata/Item.js

@@ -0,0 +1,59 @@
+const assert = require('assert');
+const utils = require('j7/utils');
+const bcutils = require('j7/bcutils');
+const basewrap = require('./basewrap');
+const factory = require('./factory');
+
+const HERO_TYPE = 3;
+const GUN_TYPE = 7;
+const MATERIAL_TYPE = 10;
+const BLIND_BOX_TYPE = 12;
+const CHIP_TYPE = 13;
+
+const MATERIAL_CHIP_SUBTYPE = 3;
+
+class Item extends basewrap.BaseWrap {
+
+  getNftType() {
+    switch (this['type']) {
+    case HERO_TYPE:
+      {
+        return bcutils.HERO_TYPE;
+      }
+      break;
+    case GUN_TYPE:
+      {
+        return bcutils.EQUIP_TYPE;
+      }
+      break;
+    case MATERIAL_TYPE:
+      {
+        if (this['sub_type'] == MATERIAL_CHIP_SUBTYPE) {
+          return bcutils.CHIP_TYPE;
+        } else {
+          return bcutils.NONE_TYPE;
+        }
+      }
+      break;
+    case CHIP_TYPE:
+      {
+          return bcutils.CHIP_TYPE;
+      }
+      break;
+    case BLIND_BOX_TYPE:
+      {
+        return bcutils.BLIND_BOX_TYPE;
+      }
+      break;
+    default:
+      {
+        return bcutils.NONE_TYPE;
+      }
+      break;
+    }
+    return bcutils.NONE_TYPE;
+  }
+
+}
+
+module.exports = Item;

server/web3service/metadata/MarketDb.js

@@ -0,0 +1,8 @@
+const utils = require('j7/utils');
+const basewrap = require('./basewrap');
+
+class MarketDb extends basewrap.BaseWrap {
+
+}
+
+module.exports = MarketDb;

server/web3service/metadata/Web3.js

@@ -0,0 +1,8 @@
+const utils = require('j7/utils');
+const basewrap = require('./basewrap');
+
+class Web3 extends basewrap.BaseWrap {
+
+}
+
+module.exports = Web3;

server/web3service/metadata/basewrap.js

@@ -0,0 +1,57 @@
+const utils = require('j7/utils');
+
+class BaseWrap {
+
+  #writeLock = false;
+
+  constructor(json, metaClass) {
+    this._json = json;
+    //this._metaClass = metaClass;
+    this._metaName = metaClass['wrapClassName'];
+  }
+
+  lock() {
+    //this.#writeLock = true;
+  }
+
+  _getHandler() {
+    return {
+      get: (obj, prop) => {
+        if (prop in obj._json) {
+          let val = obj._json[prop];
+          if (utils.isArray(val)) {
+            return new Proxy(val, {
+              set: () => {
+                console.log(33333);
+              }
+            });
+          } else if (utils.isObject(val)) {
+            return new Proxy(val, {
+              set: () => {
+                console.log(33333);
+              }
+            });
+          } else {
+            return val;
+          }
+        }
+        return prop in obj ? obj[prop] : null;
+      },
+      set: (obj, prop, val) => {
+        if (this.#writeLock) {
+          console.log(111111);
+        } else {
+          Reflect.set(obj, prop, val);
+        }
+        return true;
+      }
+    };
+  }
+
+  getMetaName() {
+    return this._metaName;
+  }
+
+}
+
+exports.BaseWrap = BaseWrap;

server/web3service/metadata/factory.js

@@ -0,0 +1,188 @@
+const app = require('j7/app');
+const utils = require('j7/utils');
+const log = require('j7/log');
+
+const metaClassList = [];
+const metaClasses = {};
+
+function registerMetaClass(fileName, primKey, wrapClass) {
+  const metaClass = {
+    'fileName' : fileName,
+    'primKey' : primKey,
+    'wrapClassName': wrapClass,
+    'wrapClass': require('./' + wrapClass),
+    'rawList' : [],
+    'rawHash' : {},
+    'wrapList' : [],
+    'wrapHash' : {},
+  };
+  metaClassList.push(metaClass);
+  metaClasses[wrapClass] = metaClass;
+}
+
+function load() {
+  metaClassList.forEach((metaClass) => {
+    const json = utils.readJsonFromFile(metaClass['fileName']);
+    if (!json) {
+      throw new Error('读取配置' + metaClass['fileName'] + '失败');
+    }
+    if (Array.isArray(json)) {
+      metaClass['rawList'] = json;
+
+    } else {
+      metaClass['rawList'].push(json);
+    }
+    let idx = 0;
+    metaClass['rawList'].forEach(function (item) {
+      const wrapOjb = new metaClass['wrapClass'](item, metaClass);
+      const wrapProxy = new Proxy(wrapOjb, wrapOjb._getHandler());
+      metaClass['wrapList'].push(wrapProxy);
+      if (metaClass['primKey'] == '') {
+        metaClass['rawHash'][idx] = item;
+        metaClass['wrapHash'][idx] = wrapProxy;
+      } else {
+        metaClass['rawHash'][item[metaClass['primKey']]] = item;
+        metaClass['wrapHash'][item[metaClass['primKey']]] = wrapProxy;
+      }
+      ++idx;
+    });
+    //log.debug(utils.jsonEncode(metaClass));
+  });
+  {
+    for (let i = 0; i < 3; ++i) {
+      metaClassList.forEach((metaClass) => {
+        metaClass['wrapList'].forEach((item) => {
+          if (item['_init' + i]) {
+            item['_init' + i](exports);
+          }
+        });
+      });
+    }
+    metaClassList.forEach((metaClass) => {
+      metaClass['wrapList'].forEach((item) => {
+        item.lock();
+      });
+    });
+  }
+}
+
+function init() {
+  let configDir = './config/';
+  if (utils.isOnlineEnv()) {
+    configDir = '../config/';
+  } else if (utils.getArgv('env') == 'dev'){
+    configDir = './config_dev/';
+  }
+  console.log(configDir, utils.getArgv('env'));
+
+  let resDir = './res/';
+  if (utils.isOnlineEnv()) {
+    resDir = '../res/';
+  } else if (utils.getArgv('env') == 'dev'){
+    resDir = './res_dev/';
+  }
+  console.log(resDir);
+
+  registerMetaClass(configDir + 'config.json',
+                    '',
+                    'Config'
+                   );
+  registerMetaClass(configDir + 'web3.json',
+                    '',
+                    'Web3'
+                   );
+  registerMetaClass(configDir + 'contract.json',
+                    'name',
+                    'Contract'
+                   );
+
+  registerMetaClass(configDir + 'marketdb_mysql.json',
+                    '',
+                    'MarketDb'
+                   );
+
+  registerMetaClass(resDir + 'item@item.json',
+                    'id',
+                    'Item'
+                   );
+
+  load();
+  {
+    traverseMetaList('MarketDb', (dbConf, idx) => {
+      app.registerDb('MarketDb' + idx, dbConf);
+    });
+  }
+ }
+
+function getMetaClass(name) {
+  return utils.hasKey(metaClasses, name) ? metaClasses[name] : null;
+}
+
+function getMetaByKey(name, key) {
+  const metaClass = getMetaClass(name);
+  return metaClass && key in metaClass['wrapHash'] ? metaClass['wrapHash'][key] : null;
+}
+
+function getMetaList(name) {
+  const metaClass = getMetaClass(name);
+  return metaClass ? metaClass['wrapList'] : null;
+}
+
+function callMetaStatic(name, method, ...args) {
+  const metaClass = getMetaClass(name);
+  return metaClass['wrapClass'][method](...args);
+}
+
+function traverseMetaList(name, cb) {
+  const metaList = getMetaList(name);
+  if (metaList) {
+    for (let i = 0; i < metaList.length; ++i) {
+      if (!cb(metaList[i], i, metaList.length)) {
+        break;
+      }
+    }
+  }
+}
+
+function getWeb3Conf() {
+  return getMetaByKey('Web3', '0');
+}
+
+function getContracts() {
+  return getMetaList('Contract');
+}
+
+function getContractByName(name) {
+  return getMetaByKey('Contract', name);
+}
+
+function getContractByAddress(address) {
+  let contract = null;
+  getContracts().forEach((item) => {
+    if (item['address'] == address) {
+      contract = item;
+    }
+  });
+  return contract;
+}
+
+function getUserAddress() {
+  return getWeb3Conf()['user_address'];
+}
+
+function getPrivateKey() {
+  return getWeb3Conf()['private_key'];
+}
+
+exports.init = init;
+
+exports.getMetaByKey = getMetaByKey;
+exports.traverseMetaList = traverseMetaList;
+exports.callMetaStatic = callMetaStatic;
+
+exports.getWeb3Conf = getWeb3Conf;
+exports.getContracts = getContracts;
+exports.getContractByName = getContractByName;
+exports.getContractByAddress = getContractByAddress;
+exports.getUserAddress = getUserAddress;
+exports.getPrivateKey = getPrivateKey;

server/web3service/middlewares/factory.js

@@ -0,0 +1,5 @@
+function init() {
+
+}
+
+exports.init = init;

server/web3service/models/activate721nft.js

@@ -0,0 +1,41 @@
+const utils = require('j7/utils');
+const BaseModel = require('./basemodel');
+
+class Activate721Nft extends BaseModel {
+
+  async add(transId, tokenId, tokenType, itemUniId, itemId, buyerAddress, price, activateTime,
+            signature, nftAddress, paymentTokenAddress, sellerAddress) {
+    const result = {
+      err: null,
+      seqId: 0
+    };
+    const nowTime = utils.getUtcTime();
+    const lastId = await this.getSession().marketConn
+    (
+      'insertEx',
+      't_activate721nft',
+      [
+        ['nonce', transId],
+        ['token_id', tokenId],
+        ['token_type', tokenType],
+        ['item_uniid', itemUniId],
+        ['item_id', itemId],
+        ['buyer_address', buyerAddress],
+        ['price', price],
+        ['activate_time', activateTime],
+        ['signature', signature],
+        ['nft_address', nftAddress],
+        ['payment_token_address', paymentTokenAddress],
+        ['seller_address', sellerAddress],
+
+        ['createtime', nowTime],
+        ['modifytime', nowTime],
+      ]
+    );
+    result['seqId'] = lastId;
+    return result;
+  }
+
+}
+
+module.exports = Activate721Nft;

server/web3service/models/basemodel.js

@@ -0,0 +1,17 @@
+class BaseModel {
+
+  constructor(session) {
+    this.session = session;
+  }
+
+  getSession() {
+    return this.session;
+  }
+
+  getUser() {
+    return this.session.user;
+  }
+
+}
+
+module.exports = BaseModel;

server/web3service/models/factory.js

@@ -0,0 +1,23 @@
+const models = {};
+
+function add(clsName, modName) {
+  const modClass = require('./' + modName);
+  models[clsName] = {
+    'clsName': clsName,
+    'modName': modName,
+    'class': modClass
+  };
+}
+
+function init() {
+  add('Transaction', 'transaction');
+  add('Activate721Nft', 'activate721nft');
+}
+
+function create(name, session) {
+  const module = models[name];
+  return new module['class'](session);
+}
+
+exports.init = init;
+exports.create = create;

server/web3service/models/transaction.js

@@ -0,0 +1,42 @@
+const utils = require('j7/utils');
+const BaseModel = require('./basemodel');
+
+class Transaction extends BaseModel {
+
+  async add(account, data) {
+    const result = {
+      err: null,
+      seqId: 0
+    };
+    const nowTime = utils.getUtcTime();
+    const lastId = await this.getSession().marketConn
+    (
+      'insertEx',
+      't_transaction',
+      [
+        ['account', account],
+        ['data', data],
+        ['createtime', nowTime],
+        ['modifytime', nowTime],
+      ]
+    );
+    result['seqId'] = lastId;
+    return result;
+  }
+
+  async update(idx, fields) {
+    const err = await this.getSession().marketConn
+    (
+      'update',
+      't_transaction',
+      [
+        ['idx', idx]
+      ],
+      fields
+    );
+    return err;
+  }
+
+}
+
+module.exports = Transaction;

server/web3service/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "web3server",
+  "version": "1.0.0",
+  "description": "",
+  "private": true,
+  "scripts": {},
+  "dependencies": {
+    "j7": "file:../../third_party/j7",
+    "@metamask/eth-sig-util": "^4.0.0",
+    "express": "^4.17.2",
+    "log4js": "~6.3.0",
+    "mysql": "~2.18.1",
+    "web3": "^1.6.1"
+  }
+}

server/web3service/services/factory.js

@@ -0,0 +1,5 @@
+function init() {
+
+}
+
+exports.init = init;

server/web3service/session.js

@@ -0,0 +1,130 @@
+const utils = require('j7/utils');
+const app = require('j7/app');
+const error = require('j7/error');
+const modelsFactory = require('./models/factory');
+const serviceFactory = require('./services/factory');
+const metaFactory = require('./metadata/factory');
+
+class Session {
+
+  constructor(req, rsp) {
+    this.req = req;
+    this.rsp = rsp;
+    this.nowTime = utils.getUtcTime();
+    this.useConns = {};
+  }
+
+  async destory() {
+    if (this.user) {
+      await this.user.destory();
+    }
+    for (let key in this.useConns) {
+      this.useConns[key].release();
+    }
+    //console.log(new Error().stack);
+    this.useConns = null;
+  }
+
+  getNowTime() {
+    return this.nowTime;
+  }
+
+  getNowDaySeconds() {
+    return this.getNowDaySeconds(this.getNowTime());
+  }
+
+  getDaySeconds(utcTime) {
+
+  }
+
+  rspErr(errCode, errMsg) {
+    utils.rspErr(this.rsp, errCode, errMsg);
+  }
+
+  rspOk() {
+    utils.rspOk(this.rsp);
+  }
+
+  rspData(data) {
+    utils.rspData(this.rsp, data);
+  }
+
+  dieErr(errCode, errMsg) {
+    this.rspErr(errCode, errMsg);
+  }
+
+  throwError(errCode, errMsg) {
+    throw new error.InternalError(errCode, errMsg);
+  }
+
+  request(name, defVal = null) {
+    return name in this.req.query ? this.req.query[name] : defVal;
+  }
+
+  requestToJson() {
+    return utils.jsonEncode(this.req.query);
+  }
+
+  async getMarketDb() {
+    const idx = 0;
+    const dbKey = 'MarketDb' + idx;
+    if (this.useConns[dbKey]) {
+      return this.useConns[dbKey];
+    }
+    const {err, conn} = await app.getDbConn(dbKey);
+    if (err) {
+      console.log(err);
+    }
+    //console.log(new Error().stack);
+    if (!err && conn) {
+      this.useConns[dbKey] = conn;
+    }
+    return conn;
+  }
+
+  createModel(name) {
+    return modelsFactory.create(name, this);
+  }
+
+  createService(name) {
+    return serviceFactory.create(name, this);
+  }
+
+  getMeta(name, key) {
+    return metaFactory.getMetaByKey(name, key);
+  }
+
+  callMetaStatic(name, method, ...args) {
+    return metaFactory.callMetaStatic(name, method, this, ...args);
+  }
+
+  traverseMetaList(name, cb) {
+    return metaFactory.traverseMetaList(name, cb);
+  }
+
+  callMetaFactory(name, ...args) {
+    return metaFactory[name](this, ...args);
+  }
+
+  async marketConn(method, ...args) {
+    const conn = await this.getMarketDb();
+    const ret = await conn[method](...args);
+    if (ret.err){
+      this.throwError(500, 'internal error');
+      log.error(ret.err);
+      return null;
+    }
+    if (utils.hasKey(ret, 'row')) {
+      return ret['row'];
+    } else if (utils.hasKey(ret, 'lastId')) {
+      return ret['lastId'];
+    } else if (utils.hasKey(ret, 'rows')) {
+      return ret['rows'];
+    } else {
+      return null;
+    }
+  }
+
+}
+
+module.exports = Session;

server/web3service/user.js

@@ -0,0 +1,41 @@
+const utils = require('j7/utils');
+const app = require('j7/app');
+const db = require('j7/db');
+const log = require('j7/log');
+
+class User {
+
+  constructor(session) {
+    this.session = session;
+    this.accountId = session.request('account_id');
+    this.sessionId = session.request('session_id');
+    this.useConns = {};
+    this.selfDb = null;
+  }
+
+  async destory() {
+    for (let key in this.useConns) {
+      this.useConns[key].release();
+    }
+    this.useConns = null;
+  }
+
+  getAccountId() {
+    return this.accountId;
+  }
+
+  getChannel() {
+    return utils.extractChannel(this.getAccountId());
+  }
+
+  getSessionId() {
+    return this.sessionId;
+  }
+
+  getRegisterTime() {
+    return utils.extractRegisterTime(this.getAccountId(), this.getSessionId());
+  }
+
+}
+
+exports.User = User;