@caict/bop-typescript-sdk 1.0.0

package/src/bop-sdk/interface/service/offline/common/snowFlakeUtils.js

@@ -0,0 +1,192 @@
+/**
+ *
+ * 名词说明：
+ * Twitter_Snowflake
+ * SnowFlake的结构如下(每部分用-分开):
+ *
+ * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
+ * A-|--------------------B--------------------------|-------C-------|------D------|
+ *
+ * A区：1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
+ * B区：41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)得到的值，
+ *      这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，
+ *      年T = (1n << 41n) / (1000n * 60n * 60n * 24n * 365n) = 69n
+ * C区：10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId（2^5 * 2^5 = 1024）
+ * D区：12位序列，毫秒内的计数，12位 的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号（2^12=4096）
+ * 加起来刚好64位，为一个Long型。
+ *
+ * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据ID和机器ID作区分)，并且效率较高。
+ * 理论1S内生成的ID数量是 1000*4096 = 4096000（四百零九万六千个）
+ * 代码中使用Bigint实现，该类型在Node10.X版本才开始支持，返回出去的结果是Bigint转为String后的字符串类型，toString方法消耗总性能的三分之一时间；
+ * 性能测试结果：
+ *      生成100W条ID，      约850-1000ms；  如果不toString后再转，  时间约 640-660ms
+ *      生成409.6WW条ID，   约3600-3850ms； 如果不toString后再转，  时间约约 2600-2800ms
+ */
+
+// ==============================Constructors=====================================
+/**
+ * 构造函数
+ * @param workerId 工作ID (0~31)
+ * @param datacenterId 数据标识ID (0~31)
+ */
+let Snowflake = (function () {
+  function Snowflake(_workerId, _dataCenterId) {
+    /** 开始时间截 ：2019-12-20 13:52:35 */
+    this.twepoch = 1576821155667;
+
+    /** 机器id所占的位数 */
+    this.workerIdBits = 5;
+
+    /** 数据标识id所占的位数 */
+    this.dataCenterIdBits = 5;
+
+    // this.maxWrokerId = -1 ^ (-1 << this.workerIdBits) // 值为：31
+
+    /** 支持的最大数据标识id，结果是31 */
+    // this.maxDataCenterId = -1 ^ (-1 << this.dataCenterIdBits) // 值为：31
+
+    /** 序列在id中占的位数 */
+    this.sequenceBits = 12;
+
+    /** 机器ID向左移12位 */
+    this.workerIdShift = this.sequenceBits; // 值为：12
+
+    /** 数据标识id向左移17位(12序列id+5机器ID) */
+    this.dataCenterIdShift = this.sequenceBits + this.workerIdBits; // 值为：17
+
+    /** 时间截向左移22位( 12序列id + 5机器ID + 5数据ID) */
+    this.timestampLeftShift =
+      this.sequenceBits + this.workerIdBits + this.dataCenterIdBits; // 值为：22
+    // this.timestampLeftShift = this.sequenceBits + this.workerIdBits + this.dataCenterIdBits + 10; // 32
+    this.sequenceMask = -1 ^ (-1 << this.sequenceBits); //4095
+    /** 上次生成ID的时间截 */
+    this.lastTimestamp = -1;
+
+    this.workerId = _workerId || 0; // 工作机器ID(0~31)
+
+    this.dataCenterId = _dataCenterId || 0; // 数据标识ID(0~31)
+    this.sequence = 0; // 毫秒内序列(0~4095)
+
+    // workerId 校验
+    if (this.workerId > ~(-1 << this.workerIdBits) || this.workerId < 0) {
+      throw new Error(
+        `workerId must be greater than 0 and less than ${~(-1 << this.workerIdBits)}`,
+      );
+    }
+    // dataCenterId 校验
+    if (
+      this.dataCenterId > ~(-1 << this.dataCenterIdBits) ||
+      this.dataCenterId < 0
+    ) {
+      throw new Error(
+        `dataCenterId must be greater than 0 and less than ${~(-1 << this.dataCenterIdBits)}`,
+      );
+    }
+  }
+  // ==============================Methods==========================================
+  /**
+   * 获得下一个ID (该方法是线程安全的)
+   * @return SnowflakeId
+   */
+  Snowflake.prototype.nextId = function () {
+    let timestamp = this.timeGen(); // 获取当前时间戳
+
+    // 如果当前时间小于上一次ID生成的时间戳，抛出异常
+    if (timestamp < this.lastTimestamp) {
+      throw new Error(
+        `Clock moved backwards. Refusing to generate id for ${
+          this.lastTimestamp - timestamp
+        }`,
+      );
+    }
+
+    // 如果是同一时间生成的，则进行毫秒内序列
+    if (this.lastTimestamp === timestamp) {
+      // 增加序列号，并应用位掩码以确保其在允许的范围内
+      this.sequence = (this.sequence + 1) & this.sequenceMask;
+
+      // 毫秒内序列溢出
+      if (this.sequence === 0) {
+        // 阻塞到下一个毫秒,获得新的时间戳
+        timestamp = this.tilNextMillis(this.lastTimestamp);
+      }
+    } else {
+      // 时间戳改变，毫秒内序列重置
+      this.sequence = 0;
+    }
+
+    // 上次生成ID的时间截
+    this.lastTimestamp = timestamp;
+
+    // 用除法和加法替代位移操作
+    let timestampPart =
+      (timestamp - this.twepoch) * Math.pow(2, this.timestampLeftShift);
+    let dataCenterIdPart =
+      this.dataCenterId * Math.pow(2, this.dataCenterIdShift);
+    let workerIdPart = this.workerId * Math.pow(2, this.workerIdShift);
+    let result =
+      timestampPart + dataCenterIdPart + workerIdPart + this.sequence; // 如果 result 超过 JavaScript Number 的最大安全整数，返回一个字符串，避免精度丢失
+    return result > Number.MAX_SAFE_INTEGER ? result.toString() : result;
+  };
+
+  Snowflake.randomLenNum = function () {
+    return singleSnowFlake.nextId();
+  };
+
+  Snowflake.getIPAdress = function () {
+    let interfaces = require("os").networkInterfaces();
+    for (let devName in interfaces) {
+      let iface = interfaces[devName];
+      for (let i = 0; i < iface.length; i++) {
+        let alias = iface[i];
+        if (
+          alias.family === "IPv4" &&
+          alias.address !== "127.0.0.1" &&
+          !alias.internal
+        ) {
+          console.log(alias.address);
+          return alias.address;
+        }
+      }
+    }
+  };
+
+  Snowflake.getHostName = function () {
+    let os = require("os");
+    console.log(os.hostname());
+    return os.hostname();
+  };
+
+  Snowflake.getRangeRandom = function (m, n) {
+    return Math.ceil(Math.random() * (n - m + 1) + m - 1);
+  };
+  Snowflake.getDefaultRangeRandom = function () {
+    return this.getRangeRandom(100, 2000);
+  };
+
+  /**
+   * 阻塞到下一个毫秒，直到获得新的时间戳
+   * @param lastTimestamp 上次生成ID的时间截
+   * @return 当前时间戳
+   */
+  Snowflake.prototype.tilNextMillis = function (lastTimestamp) {
+    let timestamp = this.timeGen();
+    while (timestamp <= lastTimestamp) {
+      timestamp = this.timeGen();
+    }
+    return timestamp;
+  };
+
+  /**
+   * 返回以毫秒为单位的当前时间
+   * @return 当前时间(毫秒)
+   */
+  Snowflake.prototype.timeGen = function () {
+    return Date.now();
+  };
+
+  return Snowflake;
+})();
+// console.log(new Snowflake(1n, 1n).nextId())
+var singleSnowFlake = new Snowflake(1, 1);
+module.exports = Snowflake;

package/src/bop-sdk/interface/service/offline/common/util.js

@@ -0,0 +1,511 @@
+const is = require("is-type-of");
+const long = require("long");
+const JSONbig = require("json-bigint");
+const BigNumber = require("bignumber.js");
+const keypair = require("@caict/bif-encryption");
+const proto = exports;
+// 星火令 单位转换
+proto.gasToUGas = function (gas) {
+  if (!_isAvailableGas(gas)) {
+    throw new Error("invalid gas value");
+  }
+
+  const oneUGas = Math.pow(10, 8);
+  const uGas = new BigNumber(gas).times(oneUGas);
+  return uGas.toString();
+};
+proto.uGasToGas = function (uGas) {
+  if (!_isAvailableUGas(uGas)) {
+    throw new Error("invalid uGas value");
+  }
+  const oneUGas = Math.pow(10, 8);
+  const gas = new BigNumber(uGas).dividedBy(oneUGas);
+  return handleData(gas.toString());
+};
+
+const handleData = function (value) {
+  const e = String(value);
+  let rex = /^([0-9])\.?([0-9]*)e-([0-9])/;
+  if (!rex.test(e)) {
+    return value;
+  }
+  const numArr = e.match(rex);
+  const n = Number(`${numArr[1]}${numArr[2] || ""}`);
+  const num = `0.${String(Math.pow(10, Number(numArr[3]) - 1)).substr(1)}${n}`;
+  return num.replace(/0*$/, "");
+};
+
+function _isAvailableUGas(value) {
+  const reg = /^(0|([1-9]\d*))$/;
+  return (
+    typeof value === "string" &&
+    reg.test(value) &&
+    long.fromValue(value).greaterThanOrEqual(0) &&
+    long.fromValue(value).lessThanOrEqual(long.MAX_VALUE)
+  );
+}
+
+function _isAvailableGas(value) {
+  const reg = /^(([1-9]\d*)+|0)(\.\d{1,8})?$/;
+  return (
+    typeof value === "string" &&
+    reg.test(value) &&
+    long.fromValue(value).greaterThanOrEqual(0) &&
+    long
+      .fromValue(value)
+      .lessThanOrEqual(long.MAX_VALUE.divide(Math.pow(10, 8)))
+  );
+}
+
+proto._response = function (obj) {
+  const data = {
+    errorCode: obj.error_code || 0,
+    errorDesc: obj.error_desc || "Success",
+  };
+
+  if (is.object(obj) && obj.error_code) {
+    if (obj.error_code === 0) {
+      data.result = obj.result || {};
+    } else {
+      data.errorDesc = obj.error_desc || "";
+      data.result = {};
+    }
+  } else if (is.object(obj) && obj.errorCode) {
+    data.errorCode = obj.errorCode;
+    if (obj.errorCode === 0) {
+      data.result = obj.result || {};
+    } else {
+      data.errorDesc = obj.errorDesc || "";
+      data.result = {};
+    }
+  } else {
+    data.result = obj;
+  }
+
+  return data;
+};
+
+proto._isEmptyString = function (str) {
+  if (!is.string(str)) {
+    throw new Error("str must be a string");
+  }
+  return str.trim().length === 0;
+};
+
+proto._postData = function (blob, signature) {
+  const data = {
+    items: [
+      {
+        transaction_blob: blob,
+        signatures: signature,
+      },
+    ],
+  };
+  return JSONbig.stringify(data);
+};
+
+proto._isBigNumber = function (object) {
+  return (
+    object instanceof BigNumber ||
+    (object && object.constructor && object.constructor.name === "BigNumber")
+  );
+};
+
+proto._toBigNumber = function (number) {
+  number = number || 0;
+  //
+  if (this._isBigNumber(number)) {
+    return number;
+  }
+  return new BigNumber(number);
+};
+
+proto._stringFromBigNumber = function (number) {
+  return this._toBigNumber(number).toString(10);
+};
+
+proto._verifyValue = function (str) {
+  const reg = /^[0-9]\d*$/;
+  return (
+    is.string(str) &&
+    reg.test(str) &&
+    long.fromValue(str).greaterThan(0) &&
+    long.fromValue(str).lessThanOrEqual(long.MAX_VALUE)
+  );
+};
+proto._verifyIInitBalancelValue = function (str) {
+  const reg = /^[0-9]\d*$/;
+  return (
+    is.string(str) &&
+    reg.test(str) &&
+    long.fromValue(str).greaterThanOrEqual(0) &&
+    long.fromValue(str).lessThanOrEqual(long.MAX_VALUE)
+  );
+};
+
+proto._isAvailableValue = function (str, from = -1, to = long.MAX_VALUE) {
+  const reg = /^(0|([1-9]\d*))$/;
+  return (
+    is.string(str) &&
+    reg.test(str) &&
+    long.fromValue(str).greaterThan(from) &&
+    long.fromValue(str).lessThanOrEqual(to)
+  );
+};
+
+proto._responseData = function (data) {
+  const errorCode = 0;
+  const errorDesc = "Success";
+
+  return {
+    errorCode,
+    errorDesc,
+    result: data,
+  };
+};
+
+proto._responseError = function (message) {
+  if (!message) {
+    throw new Error("require message");
+  }
+  const errorCode = message.CODE;
+
+  return {
+    errorCode,
+    errorDesc: message.MSG,
+  };
+};
+
+proto._isHexString = function (str) {
+  if (str === "" || !is.string(str)) {
+    return false;
+  }
+  const hexString = Buffer.from(str, "hex").toString("hex");
+  return hexString === str;
+};
+
+proto._isString = function (str) {
+  if (!is.string(str) || str.trim().length === 0) {
+    return false;
+  }
+  return true;
+};
+
+proto._isOperation = function (arr) {
+  let tag = true;
+  if (!is.array(arr) || arr.length === 0) {
+    tag = false;
+    return tag;
+  }
+
+  arr.some((item) => {
+    if (!is.object(item)) {
+      tag = false;
+      return true;
+    }
+    if (!item.type || !item.data) {
+      tag = false;
+      return true;
+    }
+  });
+
+  return tag;
+};
+
+/**
+ *
+ * @param obj
+ * @param schema
+ * @returns {boolean}
+ * @private
+ *
+ * eg:
+ schema: {
+ required: false,
+ string: true,
+ address: true,
+ numeric: true,
+ }
+ */
+proto._validate = function (obj, schema) {
+  let tag = true;
+  let msg = "";
+
+  if (!is.object(obj) || !is.object(schema)) {
+    tag = false;
+    msg = "INVALID_NUMBER_OF_ARG";
+    return {
+      tag,
+      msg,
+    };
+  }
+
+  Object.keys(schema).some((item) => {
+    // required is true
+    if (schema[item].required && is.undefined(obj[item])) {
+      obj[item] = "";
+    }
+
+    // numeric is true
+    if (
+      !is.undefined(obj[item]) &&
+      schema[item].numeric &&
+      !this._isAvailableValue(obj[item])
+    ) {
+      tag = false;
+
+      switch (item) {
+        case "amount":
+          msg = "INVALID_AMOUNT_ERROR";
+          break;
+        case "gasPrice":
+          msg = "INVALID_GASPRICE_ERROR";
+          break;
+        case "feeLimit":
+          msg = "INVALID_FEELIMIT_ERROR";
+          break;
+        case "ceilLedgerSeq":
+          msg = "INVALID_CEILLEDGERSEQ_ERROR";
+          break;
+        case "nonce":
+          msg = "INVALID_NONCE_ERROR";
+          break;
+        case "initBalance":
+          msg = "INVALID_INITBALANCE_ERROR";
+          break;
+        default:
+          msg = "REQUEST_NULL_ERROR";
+      }
+
+      return true;
+    }
+
+    // address is true
+    if (
+      !is.undefined(obj[item]) &&
+      schema[item].address &&
+      !keypair.isAddress(obj[item])
+    ) {
+      tag = false;
+
+      switch (item) {
+        case "sourceAddress":
+          msg = "INVALID_SOURCEADDRESS_ERROR";
+          break;
+        case "destAddress":
+          msg = "INVALID_DESTADDRESS_ERROR";
+          break;
+        case "address":
+          msg = "INVALID_ADDRESS_ERROR";
+          break;
+        case "contractAddress":
+          msg = "INVALID_CONTRACTADDRESS_ERROR";
+          break;
+        case "fromAddress":
+          msg = "INVALID_FROMADDRESS_ERROR";
+          break;
+        default:
+          msg = "INVALID_ARGUMENTS";
+      }
+
+      return true;
+    }
+
+    // hex is true
+    if (
+      !is.undefined(obj[item]) &&
+      schema[item].hex &&
+      !this._isHexString(obj[item])
+    ) {
+      tag = false;
+
+      switch (item) {
+        case "metadata":
+          msg = "METADATA_NOT_HEX_STRING_ERROR";
+          break;
+        default:
+          msg = "METADATA_NOT_HEX_STRING_ERROR";
+      }
+
+      return true;
+    }
+
+    // string is true
+    if (
+      !is.undefined(obj[item]) &&
+      schema[item].string &&
+      !this._isString(obj[item])
+    ) {
+      tag = false;
+
+      switch (item) {
+        case "payload":
+          msg = "PAYLOAD_EMPTY_ERROR";
+          break;
+        case "key":
+          msg = "INVALID_DATAKEY_ERROR";
+          break;
+        case "value":
+          msg = "INVALID_DATAVALUE_ERROR";
+          break;
+        default:
+          msg = "INVALID_ARGUMENTS";
+      }
+
+      return true;
+    }
+  });
+
+  return {
+    tag,
+    msg,
+  };
+};
+
+proto._bufToHex = function (buf) {
+  const utf8Str = buf.toString("utf8");
+  return Buffer.from(utf8Str, "utf8").toString("hex");
+};
+
+proto._isSignature = function (arr) {
+  let tag = true;
+  if (!is.array(arr) || arr.length === 0) {
+    tag = false;
+    return tag;
+  }
+
+  arr.some((item) => {
+    if (!is.object(item)) {
+      tag = false;
+      return true;
+    }
+
+    if (!item.signData || !item.publicKey) {
+      tag = false;
+      return true;
+    }
+
+    if (!this._isHexString(item.signData)) {
+      tag = false;
+      return true;
+    }
+
+    if (!keypair.isPublicKey(item.publicKey)) {
+      tag = false;
+      return true;
+    }
+  });
+
+  return tag;
+};
+proto._bigNumberToString = function (obj, base) {
+  // setup base
+  base = base || 10;
+
+  // check if obj is type object, not an array and does not have BN properties
+  if (
+    typeof obj === "object" &&
+    obj !== null &&
+    !Array.isArray(obj) &&
+    !("lessThan" in obj)
+  ) {
+    // move through plain object
+    Object.keys(obj).forEach((key) => {
+      // recurively converty item
+      obj[key] = proto._bigNumberToString(obj[key], base);
+    });
+  }
+
+  // obj is an array
+  if (Array.isArray(obj)) {
+    // convert items in array
+    obj = obj.map((item) => {
+      // convert item to a string if bignumber
+      return proto._bigNumberToString(item, base);
+    });
+  }
+
+  // if obj is number, convert to string
+  if (typeof obj === "number") {
+    return `${obj}`;
+  }
+
+  // if not an object bypass
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+
+  // if the object to does not have BigNumber properties, bypass
+  if (!("toString" in obj) || !("lessThan" in obj)) {
+    return obj;
+  }
+
+  // if object has bignumber properties, convert to string with base
+  return obj.toString(base);
+};
+
+proto._longToInt = function (obj) {
+  // check if obj is type object, not an array and does not have long properties
+  if (
+    typeof obj === "object" &&
+    obj !== null &&
+    !Array.isArray(obj) &&
+    !("low" in obj)
+  ) {
+    // move through plain object
+    Object.keys(obj).forEach((key) => {
+      // recurively converty item
+      obj[key] = proto._longToInt(obj[key]);
+    });
+  }
+
+  // obj is an array
+  if (Array.isArray(obj)) {
+    // convert items in array
+    obj = obj.map((item) => {
+      // convert item to an int if long
+      return proto._longToInt(item);
+    });
+  }
+
+  // if not an object bypass
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+
+  // if the object to does not have long properties, bypass
+  if (!("low" in obj)) {
+    return obj;
+  }
+
+  // if object has long properties, convert to int
+  return long.fromValue(obj).toNumber();
+};
+
+proto._isAvailableVersion = function (str) {
+  const reg = /^\d+(\.\d+)?$/;
+  return (
+    is.string(str) &&
+    reg.test(str) &&
+    long.fromValue(str).greaterThanOrEqual(0) &&
+    long.fromValue(str).lessThanOrEqual(long.MAX_VALUE)
+  );
+};
+
+proto._isAvailableBu = function (str) {
+  const reg = /^(([1-9]\d*)+|0)(\.\d{1,8})?$/;
+  return (
+    is.string(str) &&
+    reg.test(str) &&
+    long.fromValue(str).greaterThanOrEqual(0) &&
+    long.fromValue(str).lessThanOrEqual(long.MAX_VALUE.divide(Math.pow(10, 8)))
+  );
+};
+proto._containsInvalidUnicodeCharacters = function (str) {
+  try {
+    const encoded = encodeURIComponent(str);
+    return encoded.length !== str.length;
+  } catch (e) {
+    return true;
+  }
+};