openchain-nodejs-ts-yxl 1.0.1

package/lib/common/operation/accountSetPrivilege.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const errors = require('../../exception/errors');
+
+/**
+ * Account set priviliege
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+
+    const { sourceAddress, masterWeight, txThreshold, metadata, signers, typeThresholds } = args;
+
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+
+    let signersList = [];
+    let typeThresholdsList = [];
+
+    const signer = root.lookupType('protocol.Signer');
+
+    if (is.array(signers)) {
+      signers.forEach(item => {
+        let signerMsg = signer.create({
+          address: item.address,
+          weight: long.fromValue(item.weight),
+        });
+        signersList.push(signerMsg);
+      });
+    }
+
+
+    const typeThreshold = root.lookupType('protocol.OperationTypeThreshold');
+
+    if (is.array(typeThresholds)) {
+      typeThresholds.forEach(item => {
+        let typeThresholdMsg = typeThreshold.create({
+          type: parseInt(item.type),
+          threshold: long.fromValue(item.threshold),
+        });
+        typeThresholdsList.push(typeThresholdMsg);
+      });
+    }
+
+    const setPrivilege = root.lookupType('protocol.OperationSetPrivilege');
+
+    const opt = {};
+
+    if (masterWeight) {
+      opt.masterWeight = masterWeight;
+    }
+
+    if (txThreshold) {
+      opt.txThreshold = txThreshold;
+    }
+
+    if (signersList.length > 0) {
+      opt.signers = signersList;
+    }
+
+    if (typeThresholdsList.length > 0) {
+      opt.typeThresholds = typeThresholdsList;
+    }
+
+    const setPrivilegeMsg = setPrivilege.create(opt);
+    const operation = root.lookupType('protocol.Operation');
+
+    const payload = {
+      sourceAddress,
+      type: operation.Type.SET_PRIVILEGE,
+      setPrivilege: setPrivilegeMsg,
+    };
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+      // const err = operation.verify(payload);
+      //
+      // if (err) {
+      //   throw Error(err);
+      // }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/activateAccount.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const tou8 = require('buffer-to-uint8array');
+
+/**
+ * createAccount operation: Activate Account
+ * @param {string} args
+ * @returns {string}
+ */
+module.exports = function (args) {
+  try {
+    const { sourceAddress, destAddress, initBalance, metadata } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+
+    const accountThreshold = root.lookupType('protocol.AccountThreshold');
+    const accountThresholdMsg = accountThreshold.create({
+      txThreshold: 1,
+    });
+
+    const accountPrivilege = root.lookupType('protocol.AccountPrivilege');
+
+    const accountPrivilegeMsg = accountPrivilege.create({
+      masterWeight: 1,
+      thresholds: accountThresholdMsg,
+    });
+
+    const createAccount = root.lookupType('protocol.OperationCreateAccount');
+    const createAccountMsg = createAccount.create({
+      destAddress,
+      initBalance: long.fromValue(initBalance),
+      priv: accountPrivilegeMsg,
+    });
+
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      createAccount: createAccountMsg,
+      type: operation.Type.CREATE_ACCOUNT,
+      sourceAddress,
+    };
+
+    if (metadata) {
+      payload.metadata = tou8(Buffer.from(metadata, 'utf8'));
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/contractCreate.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const tou8 = require('buffer-to-uint8array');
+
+/**
+ * create contract account
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+    const { initBalance, payload, metadata, sourceAddress, initInput } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+
+    const contract = root.lookupType('protocol.Contract');
+    const contractMsg = contract.create({
+      payload: payload,
+      // type: 0,
+    });
+
+    const accountThreshold = root.lookupType('protocol.AccountThreshold');
+    const accountThresholdMsg = accountThreshold.create({
+      txThreshold: 1,
+    });
+
+    const accountPrivilege = root.lookupType('protocol.AccountPrivilege');
+    const accountPrivilegeMsg = accountPrivilege.create({
+      // masterWeight: 0,
+      thresholds: accountThresholdMsg,
+    });
+
+    const createAccount = root.lookupType('protocol.OperationCreateAccount');
+    const opt = {
+      initBalance: long.fromValue(initBalance),
+      priv: accountPrivilegeMsg,
+      contract: contractMsg,
+    };
+
+    if (initInput) {
+      opt.initInput = initInput;
+    }
+
+    const createAccountMsg = createAccount.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+    const operationPayload = {
+      type: operation.Type.CREATE_ACCOUNT,
+      createAccount: createAccountMsg,
+    };
+
+    if (sourceAddress) {
+      operationPayload.sourceAddress = sourceAddress;
+    }
+
+    if (metadata) {
+      operationPayload.metadata = metadata;
+    }
+
+    const err = operation.verify(operationPayload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(operationPayload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/contractInvokeByAsset.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const tou8 = require('buffer-to-uint8array');
+
+/**
+ * contractInvokeByAsset operation
+ * @param args
+ * @return {object}
+ */
+module.exports = function (args) {
+  try {
+    const { sourceAddress, contractAddress, code, issuer, assetAmount, metadata, input } = args;
+
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+
+    const assetKey = root.lookupType('protocol.AssetKey');
+    const assetKeyMsg = assetKey.create({
+      issuer,
+      code,
+    });
+
+    const asset = root.lookupType('protocol.Asset');
+
+    let arg = {
+      key: assetKeyMsg,
+    };
+
+    if (assetAmount) {
+      arg.amount = long.fromValue(assetAmount);
+    }
+
+    const assetMsg = asset.create(arg);
+
+    const operationPayAsset = root.lookupType('protocol.OperationPayAsset');
+
+    const opt = {
+      destAddress: contractAddress,
+      asset: assetMsg,
+    };
+
+    if (input) {
+      opt.input = input;
+    }
+
+    const operationPayAssetMsg = operationPayAsset.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+
+    const payload = {
+      payAsset: operationPayAssetMsg,
+      type: operation.Type.PAY_ASSET,
+    };
+
+    if (sourceAddress) {
+      payload.sourceAddress = sourceAddress;
+    }
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/contractInvokeByBU.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const tou8 = require('buffer-to-uint8array');
+
+/**
+ * contractInvokeByBU Operation
+ * @param args
+ * @return {object}
+ */
+module.exports = function (args) {
+  try {
+    const { sourceAddress, contractAddress, buAmount, metadata, input } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+    const payCoin = root.lookupType('protocol.OperationPayCoin');
+    let opt = {
+      destAddress: contractAddress,
+    };
+
+    if (buAmount) {
+      opt.amount = long.fromValue(buAmount);
+    }
+
+    if (input) {
+      opt.input = input;
+    }
+
+    const payCoinMsg = payCoin.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      payCoin: payCoinMsg,
+      type: operation.Type.PAY_COIN,
+      sourceAddress,
+    };
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/createLog.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const tou8 = require('buffer-to-uint8array');
+
+/**
+ * log operation: Create Log
+ * @param {string} args
+ * @returns {string}
+ */
+module.exports = function (args) {
+  try {
+    const { sourceAddress, topic, data, metadata } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+    const log = root.lookupType('protocol.OperationLog');
+    const logMsg = log.create({
+      topic,
+      datas: [data],
+    });
+
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      log: logMsg,
+      type: operation.Type.LOG,
+      sourceAddress,
+    };
+
+    if (metadata) {
+      payload.metadata = tou8(Buffer.from(metadata, 'utf8'));
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/ctp10TokenApprove.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const ctp = require('../ctp');
+
+/**
+ * ctp10TokenApproveOperation
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+    const { sourceAddress, contractAddress, spender, tokenAmount, metadata} = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+    const payCoin = root.lookupType('protocol.OperationPayCoin');
+    const opt = {
+      destAddress: contractAddress,
+      // amount: 0,
+    };
+
+    let inputObj = {
+      method: 'approve',
+      params: {
+        spender: spender,
+        value: tokenAmount,
+      },
+    };
+
+    opt.input = JSON.stringify(inputObj);
+
+    const payCoinMsg = payCoin.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      payCoin: payCoinMsg,
+      type: operation.Type.PAY_COIN,
+    };
+
+    if (sourceAddress) {
+      payload.sourceAddress = sourceAddress;
+    }
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/ctp10TokenAssign.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const ctp = require('../ctp');
+
+/**
+ * ctp10TokenTransferOperation
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+    const { contractAddress, destAddress, tokenAmount, sourceAddress, metadata } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+    const payCoin = root.lookupType('protocol.OperationPayCoin');
+    const opt = {
+      destAddress: contractAddress,
+      // amount: 0,
+    };
+
+    let inputObj = {
+      method: 'assign',
+      params: {
+        to: destAddress,
+        value: tokenAmount,
+      },
+    };
+
+    opt.input = JSON.stringify(inputObj);
+
+    const payCoinMsg = payCoin.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      type: operation.Type.PAY_COIN,
+      payCoin: payCoinMsg,
+    };
+
+    if (sourceAddress) {
+      payload.sourceAddress = sourceAddress;
+    }
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/ctp10TokenChangeOwner.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const ctp = require('../ctp');
+
+/**
+ * Ctp10TokenChangeOwnerOperation
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+    const { contractAddress, tokenOwner, sourceAddress, metadata } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+    const payCoin = root.lookupType('protocol.OperationPayCoin');
+    const opt = {
+      destAddress: contractAddress,
+      // amount: 0,
+    };
+
+    let inputObj = {
+      method: 'changeOwner',
+      params: {
+        address: tokenOwner,
+      },
+    };
+
+    opt.input = JSON.stringify(inputObj);
+
+    const payCoinMsg = payCoin.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      payCoin: payCoinMsg,
+      type: operation.Type.PAY_COIN,
+    };
+
+    if (sourceAddress) {
+      payload.sourceAddress = sourceAddress;
+    }
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/ctp10TokenIssue.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const ctp = require('../ctp');
+
+/**
+ * ctp10TokenIssueOperation
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+    const { initBalance, name, symbol, decimals, totalSupply, sourceAddress, metadata } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+
+    const contract = root.lookupType('protocol.Contract');
+    const contractMsg = contract.create({
+      payload: ctp.v10,
+    });
+
+    const accountThreshold = root.lookupType('protocol.AccountThreshold');
+    const accountThresholdMsg = accountThreshold.create({
+      txThreshold: 1,
+    });
+
+    const accountPrivilege = root.lookupType('protocol.AccountPrivilege');
+    const accountPrivilegeMsg = accountPrivilege.create({
+      // masterWeight: 0,
+      thresholds: accountThresholdMsg,
+    });
+
+    const createAccount = root.lookupType('protocol.OperationCreateAccount');
+    const opt = {
+      initBalance: long.fromValue(initBalance),
+      priv: accountPrivilegeMsg,
+      contract: contractMsg,
+    };
+
+    let initInputObj = {
+      params: {
+        name,
+        symbol,
+        decimals,
+        supply: totalSupply,
+      },
+    };
+
+    opt.initInput = JSON.stringify(initInputObj);
+
+    const createAccountMsg = createAccount.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+    const operationPayload = {
+      type: operation.Type.CREATE_ACCOUNT,
+      createAccount: createAccountMsg,
+    };
+
+    if (sourceAddress) {
+      operationPayload.sourceAddress = sourceAddress;
+    }
+
+    if (metadata) {
+      operationPayload.metadata = metadata;
+    }
+
+    const err = operation.verify(operationPayload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(operationPayload);
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/common/operation/ctp10TokenTransfer.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const ctp = require('../ctp');
+
+/**
+ * ctp10TokenTransferOperation
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+    const { contractAddress, destAddress, tokenAmount, sourceAddress, metadata } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+    const payCoin = root.lookupType('protocol.OperationPayCoin');
+    const opt = {
+      destAddress: contractAddress,
+      // amount: 0,
+    };
+
+    let inputObj = {
+      method: 'transfer',
+      params: {
+        to: destAddress,
+        value: tokenAmount,
+      },
+    };
+
+    opt.input = JSON.stringify(inputObj);
+
+    const payCoinMsg = payCoin.create(opt);
+
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      payCoin: payCoinMsg,
+      type: operation.Type.PAY_COIN,
+    };
+
+    if (sourceAddress) {
+      payload.sourceAddress = sourceAddress;
+    }
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};