openchain-nodejs-ts-yxl 1.0.1

package/lib/token/asset.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const wrap = require('co-wrap-all');
+const is = require('is-type-of');
+const merge = require('merge-descriptors');
+const errors = require('../exception');
+
+
+module.exports = Asset;
+
+function Asset(options) {
+  if (!(this instanceof Asset)) {
+    return new Asset(options);
+  }
+  this.options = options;
+}
+
+const proto = Asset.prototype;
+
+merge(proto, require('../common/util'));
+
+proto.getInfo = function* (args) {
+  try {
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const { address, code, issuer } = args;
+
+    const schema = {
+      address: {
+        required: true,
+        address: true,
+      },
+      code: {
+        required: true,
+        string: true,
+      },
+      issuer: {
+        required: true,
+        address: true,
+      },
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    const data = yield this._request('get', 'getAccountAssets', {
+      address,
+    });
+    if (data.error_code === 0 && data.result && data.result.length > 0 ) {
+      let obj = [];
+      data.result.some(item => {
+        if (item.key.code === code &&
+            item.key.issuer === issuer) {
+          obj.push(item);
+          return true;
+        }
+      });
+
+
+      return this._responseData({
+        assets: obj,
+      });
+
+    } else {
+      return this._responseData({
+        assets: [],
+      });
+    }
+
+  } catch (err) {
+    throw err;
+  }
+};
+
+wrap(proto);

package/lib/token/ctp10Token.js

@@ -0,0 +1,301 @@
+'use strict';
+
+const wrap = require('co-wrap-all');
+const is = require('is-type-of');
+const merge = require('merge-descriptors');
+const humps = require('humps');
+const JSONbig = require('json-bigint');
+const { keypair } = require('yxchain-encryption-nodejs');
+
+const errors = require('../exception');
+
+
+module.exports = Ctp10Token;
+
+function Ctp10Token(options) {
+  if (!(this instanceof Ctp10Token)) {
+    return new Ctp10Token(options);
+  }
+  this.options = options;
+}
+
+const proto = Ctp10Token.prototype;
+
+merge(proto, require('../common/util'));
+
+proto.checkValid = function* (contractAddress) {
+  try {
+    return yield this._isAvailableToken(contractAddress)
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getInfo = function* (contractAddress) {
+  try {
+    if (!keypair.checkAddress(contractAddress)) {
+      return this._responseError(errors.INVALID_CONTRACTADDRESS_ERROR);
+    }
+
+    const isContractAddress = yield this._isContractAddress(contractAddress);
+
+    if (!isContractAddress) {
+      return this._responseError(errors.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR);
+    }
+
+    let args = {
+      optType: 2,
+      contractAddress,
+      input: JSON.stringify({
+        method: 'contractInfo',
+      }),
+    };
+
+    args = humps.decamelizeKeys(args, { separator: '_' });
+    // convert long to int
+    args = this._longToInt(args);
+    args = JSONbig.stringify(args);
+
+    let info = yield this._request('post', 'callContract', args);
+    info = JSONbig.parse(info.result.query_rets[0].result.value);
+    const contractInfo = info.contractInfo;
+
+    return this._responseData({
+      ctp: contractInfo.ctp,
+      name: contractInfo.name,
+      symbol: contractInfo.symbol,
+      totalSupply: contractInfo.totalSupply,
+      decimals: contractInfo.decimals,
+      contractOwner: contractInfo.contractOwner,
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getName = function* (contractAddress) {
+  try {
+    if (!keypair.checkAddress(contractAddress)) {
+      return this._responseError(errors.INVALID_CONTRACTADDRESS_ERROR);
+    }
+
+    const isContractAddress = yield this._isContractAddress(contractAddress);
+    if (!isContractAddress) {
+      return this._responseError(errors.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR);
+    }
+
+    const data = yield this.getInfo(contractAddress);
+
+    if (data.result === '') {
+      return this._responseData('');
+    }
+
+    return this._responseData({
+      name: data.result.name,
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.getSymbol = function* (contractAddress) {
+  try {
+    if (!keypair.checkAddress(contractAddress)) {
+      return this._responseError(errors.INVALID_CONTRACTADDRESS_ERROR);
+    }
+
+    const isContractAddress = yield this._isContractAddress(contractAddress);
+    if (!isContractAddress) {
+      return this._responseError(errors.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR);
+    }
+
+    const data = yield this.getInfo(contractAddress);
+
+    if (data.result === '') {
+      return this._responseData('');
+    }
+
+    return this._responseData({
+      symbol: data.result.symbol,
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.getDecimals = function* (contractAddress) {
+  try {
+    if (!keypair.checkAddress(contractAddress)) {
+      return this._responseError(errors.INVALID_CONTRACTADDRESS_ERROR);
+    }
+
+    const isContractAddress = yield this._isContractAddress(contractAddress);
+    if (!isContractAddress) {
+      return this._responseError(errors.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR);
+    }
+
+    const data = yield this.getInfo(contractAddress);
+
+    if (data.result === '') {
+      return this._responseData('');
+    }
+
+    return this._responseData({
+      decimals: data.result.decimals,
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.getTotalSupply = function* (contractAddress) {
+  try {
+    if (!keypair.checkAddress(contractAddress)) {
+      return this._responseError(errors.INVALID_CONTRACTADDRESS_ERROR);
+    }
+
+    const isContractAddress = yield this._isContractAddress(contractAddress);
+    if (!isContractAddress) {
+      return this._responseError(errors.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR);
+    }
+
+    const data = yield this.getInfo(contractAddress);
+
+    if (data.result === '') {
+      return this._responseData('');
+    }
+
+    return this._responseData({
+      totalSupply: data.result.totalSupply,
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+proto.getBalance = function* (args) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      contractAddress: {
+        required: true,
+        address: true,
+      },
+      tokenOwner: {
+        required: true,
+        address: true,
+      },
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    const isContractAddress = yield this._isContractAddress(args.contractAddress);
+
+    if (!isContractAddress) {
+      return this._responseError(errors.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR);
+    }
+
+    let data = {
+      optType: 2,
+      contractAddress: args.contractAddress,
+      input: JSON.stringify({
+        method: 'balanceOf',
+        params: {
+          address: args.tokenOwner,
+        }
+      }),
+    };
+
+    data = humps.decamelizeKeys(data, { separator: '_' });
+    // convert long to int
+    data = this._longToInt(data);
+    data = JSONbig.stringify(data);
+
+    let info = yield this._request('post', 'callContract', data);
+
+    if (info.result.query_rets[0].result) {
+      info = JSONbig.parse(info.result.query_rets[0].result.value);
+      return this._responseData(info);
+    } else {
+      return this._responseError(errors.NO_SUCH_TOKEN_ERROR);
+    }
+  } catch (err) {
+    throw err;
+  }
+};
+
+proto.allowance = function* (args) {
+  try {
+
+    if (is.array(args) || !is.object(args)) {
+      return this._responseError(errors.INVALID_ARGUMENTS);
+    }
+
+    const schema = {
+      contractAddress: {
+        required: true,
+        address: true,
+      },
+      tokenOwner: {
+        required: true,
+        address: true,
+      },
+      spender: {
+        required: true,
+        address: true,
+      }
+    };
+
+    if (!this._validate(args, schema).tag) {
+      const msg = this._validate(args, schema).msg;
+      return this._responseError(errors[msg]);
+    }
+
+    const isContractAddress = yield this._isContractAddress(args.contractAddress);
+
+    if (!isContractAddress) {
+      return this._responseError(errors.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR);
+    }
+
+    let data = {
+      optType: 2,
+      contractAddress: args.contractAddress,
+      input: JSON.stringify({
+        method: 'allowance',
+        params: {
+          owner: args.tokenOwner,
+          spender: args.spender,
+        }
+      }),
+    };
+
+    data = humps.decamelizeKeys(data, { separator: '_' });
+    // convert long to int
+    data = this._longToInt(data);
+    data = JSONbig.stringify(data);
+
+    let info = yield this._request('post', 'callContract', data);
+
+    if (info.result.query_rets[0].result) {
+      info = JSONbig.parse(info.result.query_rets[0].result.value);
+      return this._responseData(info);
+    } else {
+      return this._responseError(errors.NO_SUCH_TOKEN_ERROR);
+    }
+  } catch (err) {
+    throw err;
+  }
+};
+
+
+wrap(proto);

package/lib/token/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const Asset = require('./asset');
+const Ctp10Token = require('./ctp10Token');
+
+module.exports = Collection;
+
+function Collection(options) {
+  if (!(this instanceof Collection)) {
+    return new Collection(options);
+  }
+
+  this.options = options;
+
+  this.asset = new Asset(options);
+  this.ctp10Token = new Ctp10Token(options);
+}

package/lib/util/index.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const wrap = require('co-wrap-all');
+const merge = require('merge-descriptors');
+const BigNumber = require('bignumber.js');
+const is = require('is-type-of');
+const long = require('long');
+
+module.exports = Util;
+
+function Util(options) {
+  if (!(this instanceof Util)) {
+    return new Util(options);
+  }
+
+  this.options = options;
+}
+
+const proto = Util.prototype;
+
+merge(proto, require('../common/util'));
+
+proto.isBigNumber = function (object) {
+  return this._isBigNumber(object);
+};
+
+proto.toBigNumber = function(data) {
+  return this._toBigNumber(data);
+};
+
+proto.utfToHex = function(str) {
+  if (!is.string(str)) {
+    return;
+  }
+
+  return Buffer.from(str, 'utf8').toString('hex');
+};
+
+proto.hexToUtf = function(str) {
+  if (!is.string(str) ||
+      str === '' ||
+      !this._isHexString(str)) {
+    return;
+  }
+
+  return Buffer.from(str, 'hex').toString('utf8');
+};
+
+proto.buToMo = function(bu) {
+  if (!this._isAvailableBu(bu)) {
+    return '';
+  }
+
+  const oneMo = Math.pow(10, 8);
+  const mo = new BigNumber(bu).times(oneMo);
+  return mo.toString();
+};
+
+proto.moToBu = function(mo) {
+  if (!this._isAvailableValue(mo)) {
+    return '';
+  }
+
+  const oneMo = Math.pow(10, 8);
+  const bu = new BigNumber(mo).dividedBy(oneMo);
+  return bu.toString();
+};
+
+proto.unitWithDecimals = function(amount, decimals) {
+  const reg = /^[0-9]+$/;
+
+  if (!reg.test(amount) || !reg.test(decimals)) {
+    return false;
+  }
+
+  amount = new BigNumber(amount);
+  decimals = new BigNumber(Math.pow(10, decimals));
+  const amountWithDecimals = amount.times(decimals);
+
+  if (amountWithDecimals.isGreaterThanOrEqualTo(0) && amountWithDecimals.isLessThanOrEqualTo(long.MAX_VALUE.toString())) {
+    return amountWithDecimals.toString();
+  }
+  return false;
+}
+
+wrap(proto);

package/openchain-sdk-nodejs.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "openchain-nodejs-ts-yxl",
+  "version": "1.0.1",
+  "description": "openchain sdk",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "mocha"
+  },
+  "keywords": [
+    "openchain",
+    "openchain-sdk"
+  ],
+  "author": "OpenChain",
+  "license": "ISC",
+  "dependencies": {
+    "bignumber.js": "^7.2.1",
+    "buffer-to-uint8array": "^1.1.0",
+    "co-wrap-all": "^1.0.0",
+    "humps": "^2.0.1",
+    "is-type-of": "^1.2.0",
+    "json-bigint": "^0.2.3",
+    "long": "^4.0.0",
+    "merge-descriptors": "^1.0.1",
+    "protobufjs": "^6.8.8",
+    "request": "^2.87.0",
+    "request-promise": "^4.2.2",
+    "yxchain-encryption-nodejs": "^1.0.1"
+  },
+  "devDependencies": {
+    "chai": "^4.1.2",
+    "mocha": "^5.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "",
+    "web": ""
+  }
+}

package/test/Ctp10Token.test.js

@@ -0,0 +1,96 @@
+'use strict';
+
+require('chai').should();
+const OpenChainSDK = require('../index');
+
+const sdk = new OpenChainSDK({
+  host: 'http://localhost/node/api',
+});
+
+describe('Test token.ctp10Token', function() {
+
+  it('test token.ctp10Token.checkValid()', async() => {
+    let address = 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse';
+    let data = await sdk.token.ctp10Token.checkValid(address);
+    data.result.isValid.should.equal(true);
+    address = 'adxSk4rkz84a4fh5xYxfSqmAsnhcWZzrTfG2t';
+    data = await sdk.token.ctp10Token.checkValid(address);
+    data.errorCode.should.equal(11037)
+  });
+
+
+  it('test token.ctp10Token.getInfo()', async() => {
+    let address = 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse';
+    let data = await sdk.token.ctp10Token.getInfo(address);
+    console.log(data);
+  });
+
+  it('test token.ctp10Token.getName()', async() => {
+    let address = 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse';
+    let data = await sdk.token.ctp10Token.getName(address);
+    console.log(data);
+  });
+
+  it('test token.ctp10Token.getSymbol()', async() => {
+    let address = 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse';
+    let data = await sdk.token.ctp10Token.getSymbol(address);
+    console.log(data);
+  });
+
+  it('test token.ctp10Token.getDecimals()', async() => {
+    let address = 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse';
+    let data = await sdk.token.ctp10Token.getDecimals(address);
+    console.log(data);
+  });
+
+  it('test token.ctp10Token.getTotalSupply()', async() => {
+    let address = 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse';
+    let data = await sdk.token.ctp10Token.getTotalSupply(address);
+    console.log(data);
+  });
+
+  it('test token.ctp10Token.getBalance()', async() => {
+    let data = await sdk.token.ctp10Token.getBalance({
+      contractAddress: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse',
+      tokenOwner: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse',
+    });
+    data.errorCode.should.equal(0);
+
+    data = await sdk.token.ctp10Token.getBalance({
+      contractAddress: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse',
+      tokenOwner: 'adxScpCtbeLP2KGRaCkbtrmz8iB5mu6DQcW3r',
+    });
+    data.errorCode.should.equal(11030);
+
+    data = await sdk.token.ctp10Token.getBalance({
+      contractAddress: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pseA',
+      tokenOwner: 'adxScpCtbeLP2KGRaCkbtrmz8iB5mu6DQcW3r',
+    });
+    data.errorCode.should.equal(11037);
+
+    data = await sdk.token.ctp10Token.getBalance({
+      contractAddress: '',
+      tokenOwner: 'adxScpCtbeLP2KGRaCkbtrmz8iB5mu6DQcW3r',
+    });
+    data.errorCode.should.equal(11037);
+
+    data = await sdk.token.ctp10Token.getBalance({
+      contractAddress: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse',
+      tokenOwner: 'adxScpCtbeLP2KGRaCkbtrmz8iB5mu6DQcW3rA',
+    });
+    data.errorCode.should.equal(11035);
+
+  });
+
+  it('test token.ctp10Token.allowance()', async() => {
+
+    let data = await sdk.token.ctp10Token.allowance({
+      contractAddress: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse',
+      tokenOwner: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse',
+      spender: 'YxLSTjYcKBcCJ3tDnBM6z8u8uvFNaZ7L8pse',
+    });
+    console.log(data);
+  });
+
+
+});