openchain-nodejs-ts-yxl 1.0.1

package/lib/exception/customErrors.js

@@ -0,0 +1,56 @@
+'use strict';
+// custom error code: from 15001 to 17000
+module.exports = {
+  ACCOUNT_NOT_EXIST: {
+    CODE: 15001,
+    MSG: 'Account not exist',
+  },
+  INVALID_NUMBER_OF_ARG: {
+    CODE: 15006,
+    MSG: 'Invalid number of arguments to the function',
+  },
+  QUERY_RESULT_NOT_EXIST: {
+    CODE: 15014,
+    MSG: 'Query result not exist',
+  },
+  INVALID_ARGUMENTS: {
+    CODE: 15016,
+    MSG: 'Invalid arguments to the function',
+  },
+  FAIL: {
+    CODE: 15017,
+    MSG: 'Fail',
+  },
+  INVALID_FORMAT_OF_ARG: {
+    CODE: 15019,
+    MSG: 'Invalid format of argument to the function',
+  },
+  INVALID_OPERATIONS: {
+    CODE: 15022,
+    MSG: 'Invalid operation',
+  },
+  INVALID_SIGNATURE_ERROR: {
+    CODE: 15027,
+    MSG: 'Invalid signature',
+  },
+  INVALID_METADATA_ERROR: {
+    CODE: 15028,
+    MSG: 'Invalid metadata',
+  },
+  INVALID_INPUT_ERROR: {
+    CODE: 15028,
+    MSG: 'Invalid input',
+  },
+  INVALID_DELETEFLAG_ERROR: {
+    CODE: 15029,
+    MSG: 'DeleteFlag must be a boolean',
+  },
+  INVALID_CONTRACT_BU_AMOUNT_ERROR: {
+    CODE: 15030,
+    MSG: 'BuAmount must between 0 and max(int64)',
+  },
+  INVALID_CONTRACT_ASSET_AMOUNT_ERROR: {
+    CODE: 15031,
+    MSG: 'AssetAmount must between 0 and max(int64)',
+  },
+};

package/lib/exception/errors.js

@@ -0,0 +1,240 @@
+'use strict';
+
+module.exports = {
+  ACCOUNT_CREATE_ERROR: {
+    CODE: 11001,
+    MSG: 'Create account failed',
+  },
+  INVALID_SOURCEADDRESS_ERROR: {
+    CODE: 11002,
+    MSG: 'Invalid sourceAddress',
+  },
+  INVALID_DESTADDRESS_ERROR: {
+    CODE: 11003,
+    MSG: 'Invalid destAddress',
+  },
+  INVALID_INITBALANCE_ERROR: {
+    CODE: 11004,
+    MSG: 'InitBalance must between 1 and max(int64)',
+  },
+  SOURCEADDRESS_EQUAL_DESTADDRESS_ERROR: {
+    CODE: 11005,
+    MSG: 'SourceAddress cannot be equal to destAddress',
+  },
+  INVALID_ADDRESS_ERROR: {
+    CODE: 11006,
+    MSG: 'Invalid address',
+  },
+  CONNECTNETWORK_ERROR: {
+    CODE: 11007,
+    MSG: 'Connect network failed',
+  },
+  INVALID_ISSUE_AMMOUNT_ERROR: {
+    CODE: 11008,
+    MSG: 'AssetAmount this will be issued mustbetween 1 and max(int64)',
+  },
+  NO_METADATA_ERROR: {
+    CODE: 11010,
+    MSG: 'This account does not have this metadata',
+  },
+  INVALID_DATAKEY_ERROR: {
+    CODE: 11011,
+    MSG: 'The length of key must between 1 and 1024',
+  },
+  INVALID_DATAVALUE_ERROR: {
+    CODE: 11012,
+    MSG: 'The length of value must between 0 and 256000',
+  },
+  INVALID_DATAVERSION_ERROR: {
+    CODE: 11013,
+    MSG: 'The version must be equal or bigger than 0',
+  },
+  INVALID_MASTERWEIGHT_ERROR: {
+    CODE: 11015,
+    MSG: 'MasterWeight must between 0 and max(uint32)',
+  },
+  INVALID_SIGNER_ADDRESS_ERROR: {
+    CODE: 11016,
+    MSG: 'Invalid signer address',
+  },
+  INVALID_SIGNER_WEIGHT_ERROR: {
+    CODE: 11017,
+    MSG: 'Signer weight must between 0 and max(uint32)',
+  },
+  INVALID_TX_THRESHOLD_ERROR: {
+    CODE: 11018,
+    MSG: 'TxThreshold must between 0 and max(int64)',
+  },
+  INVALID_OPERATION_TYPE_ERROR: {
+    CODE: 11019,
+    MSG: 'Type of typeThreshold is invalid',
+  },
+  INVALID_TYPE_THRESHOLD_ERROR: {
+    CODE: 11020,
+    MSG: 'TypeThreshold must between 0 and max(int64)',
+  },
+  INVALID_ASSET_CODE_ERROR: {
+    CODE: 11023,
+    MSG: 'Invalid code',
+  },
+  INVALID_ASSET_AMOUNT_ERROR: {
+    CODE: 11024,
+    MSG: 'AssetAmount must between 1 and max(int64)',
+  },
+  INVALID_CONTRACT_HASH_ERROR: {
+    CODE: 11025,
+    MSG: 'Invalid transaction hash to create contract'
+  },
+  INVALID_BU_AMOUNT_ERROR: {
+    CODE: 11026,
+    MSG: 'BuAmount must between 1 and max(int64)',
+  },
+  INVALID_ISSUER_ADDRESS_ERROR: {
+    CODE: 11027,
+    MSG: 'Invalid issuer address',
+  },
+  NO_SUCH_TOKEN_ERROR: {
+    CODE: 11030,
+    MSG: 'No such token',
+  },
+  INVALID_TOKEN_NAME_ERROR: {
+    CODE: 11031,
+    MSG: 'The length of token name must between 1 and 1024',
+  },
+  INVALID_TOKEN_SYMBOL_ERROR: {
+    CODE: 11032,
+    MSG: 'The length of symbol must between 1 and 1024',
+  },
+  INVALID_TOKEN_DECIMALS_ERROR: {
+    CODE: 11033,
+    MSG: 'Decimals must between 0 and 8',
+  },
+  INVALID_TOKEN_TOTALSUPPLY_ERROR: {
+    CODE: 11034,
+    MSG: 'TotalSupply must between 1 and max(int64)',
+  },
+  INVALID_TOKENOWNER_ERRPR: {
+    CODE: 11035,
+    MSG: 'Invalid token owner',
+  },
+  INVALID_CONTRACTADDRESS_ERROR: {
+    CODE: 11037,
+    MSG: 'Invalid contract address',
+  },
+  CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR: {
+    CODE: 11038,
+    MSG: 'ContractAddress is not a contract account',
+  },
+  INVALID_TOKEN_AMOUNT_ERROR: {
+    CODE: 11039,
+    MSG: 'Token amount must between 1 and max(int64)',
+  },
+  SOURCEADDRESS_EQUAL_CONTRACTADDRESS_ERROR: {
+    CODE: 11040,
+    MSG: 'SourceAddress cannot be equal to contractAddress',
+  },
+  INVALID_FROMADDRESS_ERROR: {
+    CODE: 11041,
+    MSG: 'Invalid fromAddress',
+  },
+  FROMADDRESS_EQUAL_DESTADDRESS_ERROR: {
+    CODE: 11042,
+    MSG: 'FromAddress cannot be equal to destAddress',
+  },
+  INVALID_SPENDER_ERROR: {
+    CODE: 11043,
+    MSG: 'Invalid spender',
+  },
+  PAYLOAD_EMPTY_ERROR: {
+    CODE: 11044,
+    MSG: 'Payload must be a non-empty string',
+  },
+  INVALID_LOG_TOPIC_ERROR: {
+    CODE: 11045,
+    MSG: 'The length of log topic must between 1 and 128',
+  },
+  INVALID_LOG_DATA_ERROR: {
+    CODE: 11046,
+    MSG: 'The length of one of log data must between 1 and 1024',
+  },
+  INVALID_CONTRACT_TYPE_ERROR: {
+    CODE: 11047,
+    MSG: 'Invalid contract type',
+  },
+  INVALID_NONCE_ERROR: {
+    CODE: 11048,
+    MSG: 'Nonce must between 1 and max(int64)',
+  },
+  INVALID_GASPRICE_ERROR: {
+    CODE: 11049,
+    MSG: 'GasPrice must between 1 and max(int64)',
+  },
+  INVALID_FEELIMIT_ERROR: {
+    CODE: 11050,
+    MSG: 'FeeLimit must between 1 and max(int64)',
+  },
+  OPERATIONS_EMPTY_ERROR: {
+    CODE: 11051,
+    MSG: 'Operations cannot be empty',
+  },
+  INVALID_CEILLEDGERSEQ_ERROR: {
+    CODE: 11052,
+    MSG: 'CeilLedgerSeq must be equal to or greater than 0',
+  },
+  OPERATIONS_ONE_ERROR: {
+    CODE: 11053,
+    MSG: 'One of operations error',
+  },
+  INVALID_SIGNATURENUMBER_ERROR: {
+    CODE: 11054,
+    MSG: 'SignagureNumber must between 1 and max(int32)',
+  },
+  INVALID_HASH_ERROR: {
+    CODE: 11055,
+    MSG: 'Invalid transaction hash',
+  },
+  INVALID_BLOB_ERROR: {
+    CODE: 11056,
+    MSG: 'Invalid blob',
+  },
+  PRIVATEKEY_NULL_ERROR: {
+    CODE: 11057,
+    MSG: 'PrivateKeys cannot be empty',
+  },
+  PRIVATEKEY_ONE_ERROR: {
+    CODE: 11058,
+    MSG: 'One of privateKeys is invalid',
+  },
+  INVALID_BLOCKNUMBER_ERROR: {
+    CODE: 11060,
+    MSG: 'BlockNumber must bigger than 0',
+  },
+  URL_EMPTY_ERROR: {
+    CODE: 11062,
+    MSG: 'Url cannot be empty',
+  },
+  CONTRACTADDRESS_CODE_BOTH_NULL_ERROR: {
+    CODE: 11063,
+    MSG: 'ContractAddress and code cannot be empty at the same time',
+  },
+  INVALID_OPTTYPE_ERROR: {
+    CODE: 11064,
+    MSG: 'OptType must between 0 and 2',
+  },
+  GET_ALLOWANCE_ERROR: {
+    CODE: 11065,
+    MSG: 'Get allowance failed',
+  },
+  GET_TOKEN_INFO_ERROR: {
+    CODE: 11066,
+    MSG: 'Fail to get token info',
+  },
+  CONNECTN_BLOCKCHAIN_ERROR: {
+    CODE: 19999,
+    MSG: 'Connect blockchain failed',
+  },
+  SYSTEM_ERROR: {
+    CODE: 20000,
+    MSG: 'System error',
+  },
+};

package/lib/exception/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const merge = require('merge-descriptors');
+
+const proto = module.exports = {};
+
+merge(proto, require('./errors'));
+merge(proto, require('./customErrors'));

package/lib/operation/account.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const is = require('is-type-of');
+const { keypair } = require('yxchain-encryption-nodejs');
+const errors = require('../exception');
+
+const proto = exports;
+
+proto.accountActivateOperation = function(args) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      sourceAddress: {
+        required: false,
+        address: true,
+      },
+      destAddress: {
+        required: true,
+        address: true,
+      },
+      initBalance: {
+        required: true,
+        numeric: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      }
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    if (args.sourceAddress && args.destAddress === args.sourceAddress) {
+      return this._responseError(errors.SOURCEADDRESS_EQUAL_DESTADDRESS_ERROR);
+    }
+
+    return this._responseData({
+      operation: {
+        type: 'activateAccount',
+        data: args,
+      },
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.accountSetMetadataOperation = function(args) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      key: {
+        required: true,
+        string: true,
+      },
+      sourceAddress: {
+        required: false,
+        address: true,
+      },
+      deleteFlag: {
+        required: false,
+        boolean: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      }
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    let value = args.value;
+
+    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({
+      operation: {
+        type: 'accountSetMetadata',
+        data: args,
+      },
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.accountSetPrivilegeOperation = function(args = {}) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      sourceAddress: {
+        required: false,
+        address: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      },
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      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)
+    }
+
+    if (!is.undefined(args.txThreshold) && !this._isAvailableValue(args.txThreshold)) {
+      return this._responseError(errors.INVALID_TX_THRESHOLD_ERROR)
+    }
+
+    const signers = args.signers;
+    const typeThresholds = args.typeThresholds;
+
+    if (is.array(signers) && signers.length > 0) {
+      let msg = '';
+      signers.some(item => {
+        if (!keypair.checkAddress(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({
+      operation: {
+        type: 'accountSetPrivilege',
+        data: args,
+      },
+    });
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/operation/asset.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const is = require('is-type-of');
+const errors = require('../exception');
+
+const proto = exports;
+
+proto.assetIssueOperation = function(args) {
+  try {
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      sourceAddress: {
+        required: false,
+        address: true,
+      },
+      code: {
+        required: true,
+        string: true,
+      },
+      assetAmount: {
+        required: true,
+        numeric: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      }
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    if (args.sourceAddress && args.destAddress === args.sourceAddress) {
+      return this._responseError(errors.SOURCEADDRESS_EQUAL_DESTADDRESS_ERROR);
+    }
+
+    return this._responseData({
+      operation: {
+        type: 'issueAsset',
+        data: args,
+      },
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.assetSendOperation = function(args) {
+  try {
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      sourceAddress: {
+        required: false,
+        address: true,
+      },
+      destAddress: {
+        required: true,
+        address: true,
+      },
+      code: {
+        required: true,
+        string: true,
+      },
+      issuer: {
+        required: true,
+        string: true,
+        address: true,
+      },
+      assetAmount: {
+        required: true,
+        numeric: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      }
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    if (args.sourceAddress && args.destAddress === args.sourceAddress) {
+      return this._responseError(errors.SOURCEADDRESS_EQUAL_DESTADDRESS_ERROR);
+    }
+
+    return this._responseData({
+      operation: {
+        type: 'payAsset',
+        data: args,
+      },
+    });
+  } catch (err) {
+    throw err;
+  }
+};

package/lib/operation/bu.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const is = require('is-type-of');
+const errors = require('../exception');
+
+const proto = exports;
+
+proto.buSendOperation = function(args) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      sourceAddress: {
+        required: false,
+        address: true,
+      },
+      destAddress: {
+        required: true,
+        address: true,
+      },
+      buAmount: {
+        required: true,
+        numeric: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      }
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    if (args.sourceAddress && args.destAddress === args.sourceAddress) {
+      return this._responseError(errors.SOURCEADDRESS_EQUAL_DESTADDRESS_ERROR);
+    }
+
+    return this._responseData({
+      operation: {
+        type: 'payCoin',
+        data: args,
+      },
+    });
+  } catch (err) {
+    throw err;
+  }
+};