@caict/bop-typescript-sdk 1.0.0

package/src/bop-sdk/interface/service/offline/transaction/operations.js

@@ -0,0 +1,188 @@
+const long = require("long");
+const chain_pb = require("../proto/chain_pb");
+const is = require("is-type-of");
+const keypair = require("@caict/bif-encryption");
+const errors = require("../exception");
+
+function payCoin(args = {}) {
+  const { from, to, amount, input, metadata } = args;
+
+  const payCoin = new chain_pb.OperationPayCoin();
+  payCoin.setDestAddress(to);
+  if (amount !== 0 && amount !== "0") {
+    payCoin.setAmount(long.fromValue(amount));
+  }
+  if (input) {
+    payCoin.setInput(input);
+  }
+  let operation = new chain_pb.Operation();
+  operation.setType(chain_pb.Operation.Type.PAY_COIN);
+  operation.setPayCoin(payCoin);
+  if (metadata) {
+    operation.setMetadata(Uint8Array.from(Buffer.from(metadata, "utf8")));
+  }
+  if (from) {
+    operation.setSourceAddress(from);
+  }
+  return operation;
+}
+
+function activateAccount(args = {}) {
+  const { to, initBalance } = args;
+
+  const defaultTxThreshold = 1;
+  const defaultMasterWeight = 1;
+
+  let threshold = new chain_pb.AccountThreshold();
+  threshold.setTxThreshold(defaultTxThreshold);
+
+  let privilege = new chain_pb.AccountPrivilege();
+  privilege.setThresholds(threshold);
+  privilege.setMasterWeight(defaultMasterWeight);
+
+  let createAccount = new chain_pb.OperationCreateAccount();
+  createAccount.setDestAddress(to);
+  if (initBalance !== 0 && initBalance !== "0") {
+    createAccount.setInitBalance(long.fromValue(initBalance));
+  }
+  createAccount.setPriv(privilege);
+
+  let operation = new chain_pb.Operation();
+  operation.setType(chain_pb.Operation.Type.CREATE_ACCOUNT);
+  operation.setCreateAccount(createAccount);
+  return operation;
+}
+
+function setMetadata(args = {}) {
+  const { key, value, version, deleteFlag } = args;
+
+  const setMetadata = new chain_pb.OperationSetMetadata();
+  setMetadata.setKey(key);
+  setMetadata.setValue(value);
+  setMetadata.setVersion(version);
+  setMetadata.setDeleteFlag(deleteFlag);
+  let operation = new chain_pb.Operation();
+  operation.setType(chain_pb.Operation.Type.SET_METADATA);
+  operation.setSetMetadata(setMetadata);
+  return operation;
+}
+
+function createContract(args = {}) {
+  const { initBalance, payload, sourceAddress, initInput, type } = args;
+
+  const defaultTxThreshold = 1;
+  const defaultMasterWeight = 0;
+
+  const threshold = new chain_pb.AccountThreshold();
+  threshold.setTxThreshold(defaultTxThreshold);
+
+  const privilege = new chain_pb.AccountPrivilege();
+  privilege.setThresholds(threshold);
+  if (defaultMasterWeight !== 0 && defaultMasterWeight !== "0") {
+    privilege.setMasterWeight(defaultMasterWeight);
+  }
+
+  const contractMsg = new chain_pb.Contract();
+  contractMsg.setPayload(payload);
+  contractMsg.setType(type);
+  const createAccount = new chain_pb.OperationCreateAccount();
+  if (initBalance !== 0 && initBalance !== "0") {
+    createAccount.setInitBalance(long.fromValue(initBalance));
+  }
+  createAccount.setPriv(privilege);
+  createAccount.setContract(contractMsg);
+  if (initInput) {
+    createAccount.setInitInput(initInput);
+  }
+
+  const operation = new chain_pb.Operation();
+  operation.setType(chain_pb.Operation.Type.CREATE_ACCOUNT);
+  operation.setCreateAccount(createAccount);
+  if (sourceAddress) {
+    operation.setSourceAddress(sourceAddress);
+  }
+  return operation;
+}
+
+function isAvailableValue(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)
+  );
+}
+
+function accountSetPrivilegeOperation(args = {}) {
+  const { signers } = args;
+  const { typeThresholds } = args;
+  const signerList = [];
+  const typeThresholdsList = [];
+  const signer = new chain_pb.Signer();
+  if (is.array(signers) && signers.length > 0) {
+    let msg = "";
+    signers.some((item) => {
+      if (!keypair.isAddress(item.address)) {
+        msg = "INVALID_SIGNER_ADDRESS_ERROR";
+        return true;
+      }
+      let maxInt32 = Math.pow(2, 32) - 1;
+      if (!isAvailableValue(item.weight, -1, maxInt32)) {
+        msg = "INVALID_SIGNER_WEIGHT_ERROR";
+        return true;
+      }
+      signer.setAddress(item.address);
+      signer.setWeight(item.weight);
+      signerList.push(signer);
+    });
+
+    if (msg !== "") {
+      return this._responseError(errors[msg]);
+    }
+  }
+  const typeThreshold = new chain_pb.OperationTypeThreshold();
+  if (is.array(typeThresholds) && typeThresholds.length > 0) {
+    let msg = "";
+    typeThresholds.some((item) => {
+      if (!isAvailableValue(item.type, -1, 100)) {
+        msg = "INVALID_OPERATION_TYPE_ERROR";
+        return true;
+      }
+
+      if (!isAvailableValue(item.threshold)) {
+        msg = "INVALID_TYPE_THRESHOLD_ERROR";
+        return true;
+      }
+      typeThreshold.setType(item.type);
+      typeThreshold.setThreshold(item.threshold);
+      typeThresholdsList.push(typeThreshold);
+    });
+
+    if (msg !== "") {
+      return this._responseError(errors[msg]);
+    }
+  }
+
+  const setPrivilege = new chain_pb.OperationSetPrivilege();
+  setPrivilege.setSignersList(signerList);
+  setPrivilege.setTxThreshold(args.txThreshold);
+  setPrivilege.setTypeThresholdsList(typeThresholdsList);
+  let maxInt32 = Math.pow(2, 32) - 1;
+  if (isAvailableValue(args.masterWeight, 1, maxInt32)) {
+    setPrivilege.setMasterWeight(args.masterWeight);
+  }
+
+  let operation = new chain_pb.Operation();
+  operation.setType(chain_pb.Operation.Type.SET_PRIVILEGE);
+  operation.setSetPrivilege(setPrivilege);
+  return operation;
+}
+
+module.exports = {
+  payCoin,
+  accountSetPrivilegeOperation,
+  activateAccount,
+  setMetadata,
+  createContract,
+};

package/src/bop-sdk/interface/service/offline/validate/account.js

@@ -0,0 +1,152 @@
+const is = require("is-type-of");
+const keypair = require("@caict/bif-encryption");
+const errors = require("../exception");
+const proto = exports;
+
+proto.accountActivateOperation = function (args) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    sourceAddress: {
+      required: true,
+      address: true,
+    },
+    destAddress: {
+      required: true,
+      address: true,
+    },
+    initBalance: {
+      required: true,
+      numeric: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  return this._responseData(true);
+};
+
+proto.accountSetMetadataOperation = function (args) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    key: {
+      required: true,
+      string: true,
+    },
+    value: {
+      required: true,
+      string: true,
+    },
+    sourceAddress: {
+      required: true,
+      address: true,
+    },
+    deleteFlag: {
+      required: false,
+      boolean: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  let { value } = args;
+
+  if (!is.string(value) || value.trim().length === 0 || value.length > 256000) {
+    return this._responseError(errors.INVALID_DATAVALUE_ERROR);
+  }
+
+  if (args.version && !this._isAvailableVersion(args.version)) {
+    return this._responseError(errors.INVALID_DATAVERSION_ERROR);
+  }
+
+  return this._responseData(true);
+};
+
+proto.accountSetPrivilegeOperation = function (args = {}) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    sourceAddress: {
+      required: false,
+      address: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  let maxInt32 = Math.pow(2, 32) - 1;
+
+  if (
+    !is.undefined(args.masterWeight) &&
+    !this._isAvailableValue(args.masterWeight, -1, maxInt32)
+  ) {
+    return this._responseError(errors.INVALID_MASTERWEIGHT_ERROR);
+  }
+
+  console.log(args.txThreshold);
+  if (
+    !is.undefined(args.txThreshold) &&
+    !this._isAvailableValue(args.txThreshold, -1, maxInt32)
+  ) {
+    return this._responseError(errors.INVALID_TX_THRESHOLD_ERROR);
+  }
+
+  const { signers } = args;
+  const { typeThresholds } = args;
+
+  if (is.array(signers) && signers.length > 0) {
+    let msg = "";
+    signers.some((item) => {
+      if (!keypair.isAddress(item.address)) {
+        msg = "INVALID_SIGNER_ADDRESS_ERROR";
+        return true;
+      }
+
+      if (!this._isAvailableValue(item.weight, -1, maxInt32)) {
+        msg = "INVALID_SIGNER_WEIGHT_ERROR";
+        return true;
+      }
+    });
+
+    if (msg !== "") {
+      return this._responseError(errors[msg]);
+    }
+  }
+
+  if (is.array(typeThresholds) && typeThresholds.length > 0) {
+    let msg = "";
+    typeThresholds.some((item) => {
+      if (!this._isAvailableValue(item.type, -1, 100)) {
+        msg = "INVALID_OPERATION_TYPE_ERROR";
+        return true;
+      }
+
+      if (!this._isAvailableValue(item.threshold)) {
+        msg = "INVALID_TYPE_THRESHOLD_ERROR";
+        return true;
+      }
+    });
+
+    if (msg !== "") {
+      return this._responseError(errors[msg]);
+    }
+  }
+
+  return this._responseData(true);
+};

package/src/bop-sdk/interface/service/offline/validate/contract.js

@@ -0,0 +1,101 @@
+const is = require("is-type-of");
+const errors = require("../exception");
+const proto = exports;
+const chain_pb = require("../proto/chain_pb");
+
+proto.contractCreateOperation = function (args) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    sourceAddress: {
+      required: true,
+      string: true,
+      address: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  const evm = chain_pb.Contract.ContractType.EVM;
+  const javascript = chain_pb.Contract.ContractType.JAVASCRIPT;
+  const system = chain_pb.Contract.ContractType.SYSTEM;
+  if (
+    args.type != evm &&
+    args.type != javascript &&
+    args.type != system &&
+    args.type != null &&
+    args.type != ""
+  ) {
+    return this._responseError(errors.INVALID_CONTRACT_TYPE_ERROR);
+  }
+
+  if (!is.string(args.payload) || args.payload.trim().length === 0) {
+    return this._responseError(errors.PAYLOAD_EMPTY_ERROR);
+  }
+
+  return this._responseData(true);
+};
+
+proto.contractInvokeOperation = function (args) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    contractAddress: {
+      required: true,
+      address: true,
+    },
+    sourceAddress: {
+      required: false,
+      address: true,
+    },
+    amount: {
+      required: true,
+      numeric: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  if (!is.undefined(args.amount)) {
+    if (!this._isAvailableValue(args.amount)) {
+      return this._responseError(errors.INVALID_AMOUNT_ERROR);
+    }
+  }
+
+  return this._responseData(true);
+};
+proto.contractInvokeRequestOperation = function (args) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    senderAddress: {
+      required: true,
+      address: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  if (!is.undefined(args.amount)) {
+    if (!this._isAvailableValue(args.amount)) {
+      return this._responseError(errors.INVALID_AMOUNT_ERROR);
+    }
+  }
+
+  return this._responseData(true);
+};

package/src/bop-sdk/interface/service/offline/validate/index.js

@@ -0,0 +1,10 @@
+const wrap = require("co-wrap-all");
+const merge = require("merge-descriptors");
+module.exports = Operation;
+function Operation() {}
+const proto = Operation.prototype;
+merge(proto, require("../common/util"));
+merge(proto, require("./transaction"));
+merge(proto, require("./account"));
+merge(proto, require("./contract"));
+wrap(proto);

package/src/bop-sdk/interface/service/offline/validate/transaction.js

@@ -0,0 +1,51 @@
+const is = require("is-type-of");
+const errors = require("../exception");
+const proto = exports;
+
+proto.SendOperation = function (args) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    sourceAddress: {
+      required: true,
+      address: true,
+    },
+    destAddress: {
+      required: true,
+      address: true,
+    },
+    amount: {
+      required: true,
+      numeric: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  return this._responseData(true);
+};
+
+proto.GasSendRequestOperation = function (args) {
+  if (is.array(args) || !is.object(args) || JSON.stringify(args) === "{}") {
+    return this._responseError(errors.REQUEST_NULL_ERROR);
+  }
+
+  const schema = {
+    senderAddress: {
+      required: true,
+      address: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const { msg } = this._validate(args, schema);
+    return this._responseError(errors[msg]);
+  }
+
+  return this._responseData(true);
+};