openchain-nodejs-ts-yxl 1.0.1

package/lib/blockchain/block.js

@@ -0,0 +1,380 @@
+'use strict';
+
+const wrap = require('co-wrap-all');
+const is = require('is-type-of');
+const merge = require('merge-descriptors');
+const humps = require('humps');
+const errors = require('../exception');
+
+module.exports = Block;
+
+function Block(options) {
+  if (!(this instanceof Block)) {
+    return new Block(options);
+  }
+
+  this.options = options;
+}
+
+const proto = Block.prototype;
+
+merge(proto, require('../common/util'));
+
+proto.getNumber = function* () {
+  try {
+    return yield this._getBlockNumber();
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.checkStatus = function* () {
+  try {
+    const data = yield this._request('get', 'getModulesStatus');
+    const info = data.ledger_manager;
+
+    if (info.chain_max_ledger_seq === info.ledger_sequence) {
+      return this._responseData({
+        isSynchronous: true,
+      });
+    }
+    return this._responseData({
+      isSynchronous: false,
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.getTransactions = function* (blockNumber) {
+  try {
+    if (!this._verifyValue(blockNumber)) {
+      return this._responseError(errors.INVALID_BLOCKNUMBER_ERROR);
+    }
+
+    const data = yield this._request('get', 'getTransactionHistory', {
+      ledger_seq: blockNumber,
+    });
+
+    if (data.error_code === 0) {
+      return this._responseData(data.result);
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.getInfo = function* (blockNumber) {
+  try {
+    if (!this._verifyValue(blockNumber)) {
+      return this._responseError(errors.INVALID_BLOCKNUMBER_ERROR);
+    }
+
+    const data = yield this._request('get', 'getLedger', {
+      seq: blockNumber,
+    });
+    if (data.error_code === 0) {
+      let info = {};
+
+      if (data.result && data.result.header) {
+        const header = data.result.header;
+        const closeTime = header.close_time || '';
+        const number = header.seq;
+        const txCount = header.tx_count || '';
+        const version = header.version || '';
+        info = {
+          closeTime,
+          number,
+          txCount,
+          version,
+        }
+      }
+
+      return this._responseData(info);
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getLatestInfo = function* () {
+  try {
+    const data = yield this._request('get', 'getLedger');
+
+    if (data.error_code === 0) {
+      let info = {};
+
+      if (data.result && data.result.header) {
+        const header = data.result.header;
+        const closeTime = header.close_time || '';
+        const number = header.seq;
+        const txCount = header.tx_count || '';
+        const version = header.version || '';
+        info = {
+          closeTime,
+          number,
+          txCount,
+          version,
+        }
+      }
+
+      return this._responseData(info);
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.getValidators  = function* (blockNumber) {
+  try {
+    if (!this._verifyValue(blockNumber)) {
+      return this._responseError(errors.INVALID_BLOCKNUMBER_ERROR);
+    }
+
+    const data = yield this._request('get', 'getLedger', {
+      seq: blockNumber,
+      with_validator: true,
+    });
+
+    if (data.error_code === 0) {
+      let validatorsInfo = data.result.validators;
+      let validators = [];
+      if (!is.array(validatorsInfo) && validatorsInfo.length === 0) {
+        validators = [];
+      }
+      // [{a_b: 'demo'}] => [{aB: 'demo'}]
+      // validatorsInfo = humps.camelizeKeys(validatorsInfo);
+
+      validatorsInfo.forEach(item => {
+        if (!item.pledge_coin_amount) {
+          item.pledge_coin_amount = '0';
+        }
+        validators.push(item);
+      });
+      return this._responseData({
+        validators,
+      });
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getLatestValidators = function* () {
+  try {
+    const data = yield this._request('get', 'getLedger', {
+      with_validator: true,
+    });
+
+    if (data.error_code === 0) {
+      let validatorsInfo = data.result.validators;
+      let validators = [];
+      if (!is.array(validatorsInfo) && validatorsInfo.length === 0) {
+        validators = [];
+      }
+      // [{a_b: 'demo'}] => [{aB: 'demo'}]
+      // validatorsInfo = humps.camelizeKeys(validatorsInfo);
+
+      validatorsInfo.forEach(item => {
+        if (!item.pledge_coin_amount) {
+          item.pledge_coin_amount = '0';
+        }
+        validators.push(item);
+      });
+      return this._responseData({
+        validators,
+      });
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getReward = function* (blockNumber) {
+  try {
+    if (!this._verifyValue(blockNumber)) {
+      return this._responseError(errors.INVALID_BLOCKNUMBER_ERROR);
+    }
+
+    const data = yield this._request('get', 'getLedger', {
+      seq: blockNumber,
+      with_block_reward: true,
+    });
+
+    if (data.error_code === 0) {
+      // console.log(data)
+      const result = data.result;
+      const blockReward = result.block_reward;
+      const validatorsReward = result.validators_reward;
+      const validatorItems = [];
+      const keys = Object.keys(validatorsReward);
+
+      if (keys.length > 0) {
+        keys.forEach(item => {
+            validatorItems.push({
+              validator: item,
+              reward: validatorsReward[item],
+            });
+        })
+      }
+
+      return this._responseData({
+        blockReward,
+        validatorsReward: validatorItems,
+      });
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getLatestReward = function* () {
+  try {
+    const data = yield this._request('get', 'getLedger', {
+      with_block_reward: true,
+    });
+
+    if (data.error_code === 0) {
+      // console.log(data)
+      const result = data.result;
+      const blockReward = result.block_reward;
+      const validatorsReward = result.validators_reward;
+      const validatorItems = [];
+      const keys = Object.keys(validatorsReward);
+
+      if (keys.length > 0) {
+        keys.forEach(item => {
+          validatorItems.push({
+            validator: item,
+            reward: validatorsReward[item],
+          });
+        })
+      }
+
+      return this._responseData({
+        blockReward,
+        validatorsReward: validatorItems,
+      });
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getFees = function* (blockNumber) {
+  try {
+    if (!this._verifyValue(blockNumber)) {
+      return this._responseError(errors.INVALID_BLOCKNUMBER_ERROR);
+    }
+
+    const data = yield this._request('get', 'getLedger', {
+      seq: blockNumber,
+      with_fee: true,
+    });
+
+    if (data.error_code === 0) {
+      // console.log(data)
+      const result = data.result;
+      const fees = result.fees;
+
+      return this._responseData({
+        // fees: humps.camelizeKeys(fees),
+        fees,
+      });
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getLatestFees = function* () {
+  try {
+    const data = yield this._request('get', 'getLedger', {
+      with_fee: true,
+    });
+
+    if (data.error_code === 0) {
+      // console.log(data)
+      const result = data.result;
+      const fees = result.fees;
+
+      return this._responseData({
+        // fees: humps.camelizeKeys(fees),
+        fees,
+      });
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+wrap(proto);

package/lib/blockchain/transaction.js

@@ -0,0 +1,264 @@
+'use strict';
+
+const wrap = require('co-wrap-all');
+const is = require('is-type-of');
+const merge = require('merge-descriptors');
+const long = require('long');
+const humps = require('humps');
+const JSONbig = require('json-bigint');
+const errors = require('../exception');
+
+
+module.exports = Transaction;
+
+function Transaction(options) {
+  if (!(this instanceof Transaction)) {
+    return new Transaction(options);
+  }
+
+  this.options = options;
+}
+
+const proto = Transaction.prototype;
+
+merge(proto, require('../common/util'));
+
+ proto.buildBlob = function(args) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      sourceAddress: {
+        required: true,
+        string: true,
+        address: true,
+      },
+      gasPrice: {
+        required: true,
+        numeric: true,
+      },
+      feeLimit: {
+        required: true,
+        numeric: true,
+      },
+      nonce: {
+        required: true,
+        numeric: true,
+      },
+      ceilLedgerSeq: {
+        required: false,
+        numeric: true,
+      },
+      operations: {
+        required: true,
+        operations: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      }
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    return this._responseData(this._buildBlob(args));
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.sign = function(args) {
+  // privateKeys, blob
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      privateKeys: {
+        required: true,
+        privateKeys: true,
+      },
+      blob: {
+        required: true,
+        hex: true,
+      },
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    return this._responseData(this._signBlob(args));
+  } catch (err) {
+    throw err;
+  }
+
+};
+
+// blob, signData, publicKey
+proto.submit = function* (args) {
+
+  if (is.array(args) || !is.object(args)) {
+    return this._responseError(errors.INVALID_ARGUMENTS);
+  }
+
+  // blob, signature
+  const schema = {
+    signature: {
+      required: true,
+      signatures: true,
+    },
+    blob: {
+      required: true,
+      hex: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const msg = this._validate(args, schema).msg;
+    return this._responseError(errors[msg]);
+  }
+
+  args = humps.decamelizeKeys(args, { separator: '_' });
+
+  return yield this._submit(args);
+};
+
+proto.evaluateFee = function* (args) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    let { sourceAddress, nonce, operations, signtureNumber, metadata, ceilLedgerSeq } = args;
+    signtureNumber = signtureNumber || '1';
+    const schema = {
+      sourceAddress: {
+        required: true,
+        string: true,
+        address: true,
+      },
+      nonce: {
+        required: true,
+        string: true,
+        numeric: true,
+      },
+      operations: {
+        required: true,
+        operations: true,
+      },
+      signtureNumber: {
+        required: false,
+        string: true,
+        numeric: true,
+      },
+      metadata: {
+        required: false,
+        string: true,
+      },
+      ceilLedgerSeq: {
+        required: false,
+        numeric: true,
+      },
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    signtureNumber = signtureNumber || 1;
+
+    const operationList = [];
+
+    operations.forEach(item => {
+      const type = item.type;
+      const argsData = item.data;
+
+      const operationItem =  this._buildOperation(type, argsData);
+      let operationMsg = humps.decamelizeKeys(operationItem, { separator: '_' });
+      // convert long to int
+      operationMsg = this._longToInt(operationMsg);
+
+      operationList.push(operationMsg);
+    });
+
+
+
+    let data = {
+      items: [
+        {
+          transaction_json: {
+            source_address: sourceAddress,
+            metadata: metadata,
+            nonce: nonce,
+            operations: operationList,
+            ceil_ledger_seq: ceilLedgerSeq,
+            chain_id: this.options.chainId,
+          },
+        }
+      ]
+    };
+
+    data = JSONbig.stringify(data);
+    const response = yield this._request('post', 'testTransaction', data);
+    if (is.object(response)) {
+      const info = response;
+      if (info.error_code === 0) {
+        if (info.result.txs && info.result.txs.length > 0) {
+          const fee = info.result.txs[0].transaction_env.transaction;
+          return this._responseData({
+            feeLimit: fee.fee_limit,
+            gasPrice: fee.gas_price,
+          });
+        }
+      }
+
+      return {
+        errorCode: info.error_code,
+        errorDesc: info.error_desc,
+      };
+    }
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.getInfo = function* (hash) {
+  try {
+
+    if (!is.string(hash) || this._isEmptyString(hash)) {
+      return this._responseError(errors.INVALID_HASH_ERROR);
+    }
+
+    const data = yield this._request('get', 'getTransactionHistory', {
+      hash: hash,
+    });
+
+    if (data.error_code === 0) {
+      return this._responseData(data.result);
+    }
+
+    if (data.error_code === 4) {
+      return this._responseError(errors.QUERY_RESULT_NOT_EXIST, data.result);
+    }
+
+    return this._responseError(errors.FAIL);
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+wrap(proto);

package/lib/common/ctp.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  v10: `'use strict';let globalAttribute={};function globalAttributeKey(){return'global_attribute';}function loadGlobalAttribute(){if(Object.keys(globalAttribute).length===0){let value=storageLoad(globalAttributeKey());assert(value!==false,'Get global attribute from metadata failed.');globalAttribute=JSON.parse(value);}}function storeGlobalAttribute(){let value=JSON.stringify(globalAttribute);storageStore(globalAttributeKey(),value);}function powerOfBase10(exponent){let i=0;let power=1;while(i<exponent){power=power*10;i=i+1;}return power;}function makeBalanceKey(address){return'balance_'+address;}function makeAllowanceKey(owner,spender){return'allow_'+owner+'_to_'+spender;}function valueCheck(value){if(value.startsWith('-')||value==='0'){return false;}return true;}function approve(spender,value){assert(addressCheck(spender)===true,'Arg-spender is not a valid address.');assert(stoI64Check(value)===true,'Arg-value must be alphanumeric.');assert(valueCheck(value)===true,'Arg-value must be positive number.');let key=makeAllowanceKey(sender,spender);storageStore(key,value);tlog('approve',sender,spender,value);return true;}function allowance(owner,spender){assert(addressCheck(owner)===true,'Arg-owner is not a valid address.');assert(addressCheck(spender)===true,'Arg-spender is not a valid address.');let key=makeAllowanceKey(owner,spender);let value=storageLoad(key);assert(value!==false,'Get allowance '+owner+' to '+spender+' from metadata failed.');return value;}function transfer(to,value){assert(addressCheck(to)===true,'Arg-to is not a valid address.');assert(stoI64Check(value)===true,'Arg-value must be alphanumeric.');assert(valueCheck(value)===true,'Arg-value must be positive number.');if(sender===to){tlog('transfer',sender,to,value);return true;}let senderKey=makeBalanceKey(sender);let senderValue=storageLoad(senderKey);assert(senderValue!==false,'Get balance of '+sender+' from metadata failed.');assert(int64Compare(senderValue,value)>=0,'Balance:'+senderValue+' of sender:'+sender+' < transfer value:'+value+'.');let toKey=makeBalanceKey(to);let toValue=storageLoad(toKey);toValue=(toValue===false)?value:int64Add(toValue,value);storageStore(toKey,toValue);senderValue=int64Sub(senderValue,value);storageStore(senderKey,senderValue);tlog('transfer',sender,to,value);return true;}function assign(to,value){assert(addressCheck(to)===true,'Arg-to is not a valid address.');assert(stoI64Check(value)===true,'Arg-value must be alphanumeric.');assert(valueCheck(value)===true,'Arg-value must be positive number.');if(thisAddress===to){tlog('assign',to,value);return true;}loadGlobalAttribute();assert(sender===globalAttribute.contractOwner,sender+' has no permission to assign contract balance.');assert(int64Compare(globalAttribute.balance,value)>=0,'Balance of contract:'+globalAttribute.balance+' < assign value:'+value+'.');let toKey=makeBalanceKey(to);let toValue=storageLoad(toKey);toValue=(toValue===false)?value:int64Add(toValue,value);storageStore(toKey,toValue);globalAttribute.balance=int64Sub(globalAttribute.balance,value);storeGlobalAttribute();tlog('assign',to,value);return true;}function transferFrom(from,to,value){assert(addressCheck(from)===true,'Arg-from is not a valid address.');assert(addressCheck(to)===true,'Arg-to is not a valid address.');assert(stoI64Check(value)===true,'Arg-value must be alphanumeric.');assert(valueCheck(value)===true,'Arg-value must be positive number.');if(from===to){tlog('transferFrom',sender,from,to,value);return true;}let fromKey=makeBalanceKey(from);let fromValue=storageLoad(fromKey);assert(fromValue!==false,'Get value failed, maybe '+from+' has no value.');assert(int64Compare(fromValue,value)>=0,from+' balance:'+fromValue+' < transfer value:'+value+'.');let allowValue=allowance(from,sender);assert(int64Compare(allowValue,value)>=0,'Allowance value:'+allowValue+' < transfer value:'+value+' from '+from+' to '+to+'.');let toKey=makeBalanceKey(to);let toValue=storageLoad(toKey);toValue=(toValue===false)?value:int64Add(toValue,value);storageStore(toKey,toValue);fromValue=int64Sub(fromValue,value);storageStore(fromKey,fromValue);let allowKey=makeAllowanceKey(from,sender);allowValue=int64Sub(allowValue,value);storageStore(allowKey,allowValue);tlog('transferFrom',sender,from,to,value);return true;}function changeOwner(address){assert(addressCheck(address)===true,'Arg-address is not a valid address.');loadGlobalAttribute();assert(sender===globalAttribute.contractOwner,sender+' has no permission to modify contract ownership.');globalAttribute.contractOwner=address;storeGlobalAttribute();tlog('changeOwner',sender,address);}function name(){return globalAttribute.name;}function symbol(){return globalAttribute.symbol;}function decimals(){return globalAttribute.decimals;}function totalSupply(){return globalAttribute.totalSupply;}function ctp(){return globalAttribute.ctp;}function contractInfo(){return globalAttribute;}function balanceOf(address){assert(addressCheck(address)===true,'Arg-address is not a valid address.');if(address===globalAttribute.contractOwner||address===thisAddress){return globalAttribute.balance;}let key=makeBalanceKey(address);let value=storageLoad(key);assert(value!==false,'Get balance of '+address+' from metadata failed.');return value;}function init(input_str){let input=JSON.parse(input_str);assert(stoI64Check(input.params.supply)===true&&typeof input.params.name==='string'&&typeof input.params.symbol==='string'&&typeof input.params.decimals==='number','Args check failed.');globalAttribute.ctp='1.0';globalAttribute.name=input.params.name;globalAttribute.symbol=input.params.symbol;globalAttribute.decimals=input.params.decimals;globalAttribute.totalSupply=int64Mul(input.params.supply,powerOfBase10(globalAttribute.decimals));globalAttribute.contractOwner=sender;globalAttribute.balance=globalAttribute.totalSupply;storageStore(globalAttributeKey(),JSON.stringify(globalAttribute));}function main(input_str){let input=JSON.parse(input_str);if(input.method==='transfer'){transfer(input.params.to,input.params.value);}else if(input.method==='transferFrom'){transferFrom(input.params.from,input.params.to,input.params.value);}else if(input.method==='approve'){approve(input.params.spender,input.params.value);}else if(input.method==='assign'){assign(input.params.to,input.params.value);}else if(input.method==='changeOwner'){changeOwner(input.params.address);}else{throw'<unidentified operation type>';}}function query(input_str){loadGlobalAttribute();let result={};let input=JSON.parse(input_str);if(input.method==='name'){result.name=name();}else if(input.method==='symbol'){result.symbol=symbol();}else if(input.method==='decimals'){result.decimals=decimals();}else if(input.method==='totalSupply'){result.totalSupply=totalSupply();}else if(input.method==='ctp'){result.ctp=ctp();}else if(input.method==='contractInfo'){result.contractInfo=contractInfo();}else if(input.method==='balanceOf'){result.balance=balanceOf(input.params.address);}else if(input.method==='allowance'){result.allowance=allowance(input.params.owner,input.params.spender);}else{throw'<unidentified operation type>';}log(result);return JSON.stringify(result);}`,
+};

package/lib/common/operation/accountSetMetadata.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const is = require('is-type-of');
+const protobuf = require('protobufjs');
+const long = require('long');
+const tou8 = require('buffer-to-uint8array');
+
+/**
+ * Account set metadata
+ * @param args
+ * @return {payload}
+ */
+module.exports = function (args) {
+  try {
+
+    const { key, value, version, sourceAddress, deleteFlag, metadata } = args;
+    const root = protobuf.Root.fromJSON(require('../../crypto/protobuf/bundle.json'));
+    const setMetadata = root.lookupType('protocol.OperationSetMetadata');
+
+    const opt = {
+      key,
+      value,
+    };
+
+    if (version) {
+      opt.version = parseInt(version);
+    }
+
+    if (deleteFlag) {
+      opt.deleteFlag = deleteFlag;
+    }
+
+    const setMetadataMsg = setMetadata.create(opt);
+    const operation = root.lookupType('protocol.Operation');
+    const payload = {
+      setMetadata: setMetadataMsg,
+      type: operation.Type.SET_METADATA,
+      sourceAddress,
+    };
+
+    if (metadata) {
+      payload.metadata = metadata;
+    }
+
+    const err = operation.verify(payload);
+
+    if (err) {
+      throw Error(err);
+    }
+
+    return operation.create(payload);
+  } catch (err) {
+    throw err;
+  }
+};