├── .editorconfig
├── .gitignore
├── .npmignore
├── LICENSE
├── README.md
├── assets
    └── TronWeb-logo.png
├── karma.conf.js
├── package.json
├── pre-commit-result
├── scripts
    ├── pre-commit.js
    ├── test-browser.js
    └── test-node.js
├── src
    ├── index.js
    ├── lib
    │   ├── contract
    │   │   ├── index.js
    │   │   └── method.js
    │   ├── event.js
    │   ├── plugin.js
    │   ├── providers
    │   │   ├── HttpProvider.js
    │   │   └── index.js
    │   ├── transactionBuilder.js
    │   └── trx.js
    ├── paramValidator
    │   └── index.js
    └── utils
    │   ├── abi.js
    │   ├── accounts.js
    │   ├── address.js
    │   ├── base58.js
    │   ├── base64.js
    │   ├── bytes.js
    │   ├── code.js
    │   ├── crypto.js
    │   ├── ethersUtils.js
    │   ├── help.js
    │   └── index.js
├── test-git-hash
├── test-report
├── test
    ├── fixtures
    │   └── contracts.js
    ├── helpers
    │   ├── BlockLib.js
    │   ├── GetNowBlock.js
    │   ├── MetaCoin.json
    │   ├── assertEqualHex.js
    │   ├── assertThrow.js
    │   ├── broadcaster.js
    │   ├── config.js
    │   ├── jlog.js
    │   ├── log.js
    │   ├── newAccounts.js
    │   ├── pollAccountFor.js
    │   ├── tronWebBuilder.js
    │   ├── txPars.js
    │   ├── wait.js
    │   └── waitChainData.js
    ├── index.test.js
    ├── lib
    │   ├── contract
    │   │   └── method.test.js
    │   ├── event.test.js
    │   ├── plugin.test.js
    │   ├── providers.test.js
    │   ├── transactionBuilder.test.js
    │   └── trx.test.js
    ├── setup
    │   ├── browser.js
    │   └── node.js
    └── utils
    │   ├── abi.test.js
    │   ├── accounts.test.js
    │   ├── base58.test.js
    │   ├── bytes.test.js
    │   ├── code.test.js
    │   └── index.test.js
├── webpack.config.js
└── yarn.lock


/.editorconfig:
--------------------------------------------------------------------------------
 1 | ; editorconfig.org
 2 | root = true
 3 | 
 4 | [*]
 5 | indent_style = space
 6 | indent_size = 4
 7 | end_of_line = lf
 8 | charset = utf-8
 9 | trim_trailing_whitespace = true
10 | insert_final_newline = true
11 | 
12 | [*.json]
13 | indent_size = 4
14 | 
15 | [*.js]
16 | indent_size = 4
17 | 
18 | [*.html]
19 | indent_size = 4
20 | 
21 | [*.yaml]
22 | indent_size = 4
23 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .next
 2 | node_modules
 3 | .DS_Store
 4 | package-lock.json
 5 | test/setup/TronWeb.js
 6 | coverage
 7 | yarn-error.log
 8 | /dist
 9 | .env
10 | .vscode/
11 | .idea/
12 | example/
13 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .next
2 | .DS_Store
3 | test
4 | coverage
5 | .idea
6 | .scratch
7 | scripts
8 | src
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 TRON Foundation
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <h1 align="center">
  2 |   <img align="center" src="https://raw.githubusercontent.com/tron-us/tronweb/master/assets/TronWeb-logo.png" width="400"/>
  3 | </h1>
  4 | 
  5 | <p align="center">
  6 |   <a href="https://discord.gg/GsRgsTD">
  7 |     <img src="https://img.shields.io/badge/chat-on%20discord-brightgreen.svg">
  8 |   </a>
  9 | 
 10 |   <a href="https://github.com/tron-us/tronweb/issues">
 11 |     <img src="https://img.shields.io/github/issues/tron-us/tronweb.svg">
 12 |   </a>
 13 | 
 14 |   <a href="https://github.com/tron-us/tronweb/pulls">
 15 |     <img src="https://img.shields.io/github/issues-pr/tron-us/tronweb.svg">
 16 |   </a>
 17 | 
 18 |   <a href="https://github.com/tron-us/tronweb/graphs/contributors">
 19 |     <img src="https://img.shields.io/github/contributors/tron-us/tronweb.svg">
 20 |   </a>
 21 | 
 22 |   <a href="LICENSE">
 23 |     <img src="https://img.shields.io/github/license/tron-us/tronweb.svg">
 24 |   </a>
 25 | </p>
 26 | 
 27 | ## What is TronWeb?
 28 | 
 29 | __[Tron Web - Developer Document](https://developers.tron.network/docs/tron-web-intro)__
 30 | 
 31 | TronWeb aims to deliver a unified, seamless development experience influenced by Ethereum's [Web3](https://github.com/ethereum/web3.js/) implementation. We have taken the core ideas and expanded upon it to unlock the functionality of TRON's unique feature set along with offering new tools for integrating DApps in the browser, Node.js and IoT devices.
 32 | 
 33 | ## Compatibility
 34 | - Version built for Node.js v6 and above
 35 | - Version built for browsers with more than 0.25% market share
 36 | 
 37 | You can access either version specifically from the [dist](dist) folder.
 38 | 
 39 | TronWeb is also compatible with frontend frameworks such as:
 40 | - Angular
 41 | - React
 42 | - Vue.
 43 | 
 44 | You can also ship TronWeb in a Chrome extension.
 45 | 
 46 | ## Installation
 47 | 
 48 | ### Node.js
 49 | ```bash
 50 | npm install tronweb
 51 | ```
 52 | or
 53 | ```bash
 54 | yarn add tronweb
 55 | ```
 56 | 
 57 | ### Browser
 58 | First, don't use the release section of this repo, it has not updated in a long time.
 59 | 
 60 | Then easiest way to use TronWeb in a browser is to install it as above and copy the dist file to your working folder. For example:
 61 | ```
 62 | cp node_modules/tronweb/dist/TronWeb.js ./js/tronweb.js
 63 | ```
 64 | so that you can call it in your HTML page as
 65 | ```
 66 | <script src="./js/tronweb.js"><script>
 67 | ```
 68 | 
 69 | ## Testnet
 70 | 
 71 | Shasta is the official Tron testnet. To use it use the following endpoint:
 72 | ```
 73 | https://api.shasta.trongrid.io
 74 | ```
 75 | Get some Shasta TRX at https://www.trongrid.io/shasta and play with it.
 76 | Anything you do should be explorable on https://shasta.tronscan.org
 77 | 
 78 | ## Your local private network for heavy testing
 79 | 
 80 | You can set up your own private network, running Tron Quickstart. To do it you must [install Docker](https://docs.docker.com/install/) and, when ready, run a command like
 81 | 
 82 | ```bash
 83 | docker run -it --rm \
 84 |   -p 9090:9090 \
 85 |   -e "defaultBalance=100000" \
 86 |   -e "showQueryString=true" \
 87 |   -e "showBody=true" \
 88 |   -e "formatJson=true" \
 89 |   --name tron \
 90 |   trontools/quickstart
 91 | ```
 92 | 
 93 | [More details about Tron Quickstart on GitHub](https://github.com/tron-us/docker-tron-quickstart)
 94 | 
 95 | ## Creating an Instance
 96 | 
 97 | First off, in your javascript file, define TronWeb:
 98 | 
 99 | ```js
100 | const TronWeb = require('tronweb')
101 | ```
102 | 
103 | When you instantiate TronWeb you can define
104 | 
105 | * fullNode
106 | * solidityNode
107 | * eventServer
108 | * privateKey
109 | 
110 | you can also set a
111 | 
112 | * fullHost
113 | 
114 | which works as a jolly. If you do so, though, the more precise specification has priority.
115 | Supposing you are using a server which provides everything, like TronGrid, you can instantiate TronWeb as:
116 | 
117 | ```js
118 | const tronWeb = new TronWeb({
119 |     fullHost: 'https://api.trongrid.io',
120 |     privateKey: 'your private key'
121 | })
122 | ```
123 | 
124 | For retro-compatibility, though, you can continue to use the old approach, where any parameter is passed separately:
125 | ```js
126 | const tronWeb = new TronWeb(fullNode, solidityNode, eventServer, privateKey)
127 | 
128 | ```
129 | 
130 | If you are, for example, using a server as full and solidity node, and another server for the events, you can set it as:
131 | 
132 | ```js
133 | const tronWeb = new TronWeb({
134 |     fullHost: 'https://api.trongrid.io',
135 |     eventServer: 'https://api.someotherevent.io',
136 |     privateKey: 'your private key'
137 |   }
138 | )
139 | ```
140 | 
141 | If you are using different servers for anything, you can do
142 | ```js
143 | const tronWeb = new TronWeb({
144 |     fullNode: 'https://some-node.tld',
145 |     solidityNode: 'https://some-other-node.tld',
146 |     eventServer: 'https://some-event-server.tld',
147 |     privateKey: 'your private key'
148 |   }
149 | )
150 | ```
151 | 
152 | ## A full example
153 | 
154 | The better way to understand how to work with Tron is to clone the [MetaCoin example](https://github.com/Tronbox-boxes/metacoin-box) and follow the instructions at
155 | https://github.com/Tronbox-boxes/metacoin-box
156 | 
157 | ## Contributions
158 | 
159 | In order to contribute you can
160 | 
161 | * fork this repo and clone it locally
162 | * install the dependencies — `npm i`
163 | * do your changes to the code
164 | * build the TronWeb dist files — `npm run build`
165 | * run a local private network using Tron Quickstart
166 | * run the tests — `npm test:node`
167 | * push your changes and open a pull request
168 | 
169 | ## Recent History
170 | 
171 | __2.10.1__
172 | * Fix `trx.listExchangesPaginated`
173 | 
174 | __2.10.0__
175 | * Fix `trx.getTokenListByName`
176 | 
177 | __2.9.0__
178 | * Support smart contracts with function that requires an array of addresses as a parameter, included the constructor during the deployment
179 | 
180 | __2.8.1__
181 | * Add options `keepTxID` to show also the txID when triggering a contract with `shouldPollResponse`
182 | 
183 | __2.8.0__
184 | * Improve in the plugin architecture allows someone to implement a full lib at the same level of Trx and TransactionBuilder
185 | 
186 | __2.7.4__
187 | * Fix bugs of trx.getBrokerage and trx.getReward function
188 | 
189 | __2.7.3__
190 | * Support new apis related to Java-Tron 3.6.5
191 | * Original withdrawBlockRewards method support to withdraw user's reward
192 | 
193 | __2.6.8__
194 | * Support extension of transaction expiration
195 | * Allow to add data to the transaction
196 | * Many minor changes and fixes
197 | 
198 | __2.6.3__
199 | * Support get unconfirmed transaction function
200 | 
201 | __2.6.0__
202 | * Support trigger constant contract, clear abi and add account by id
203 | * Add permission id option in functions related to creating transaction
204 | * Support multi-sign without permission id
205 | 
206 | __2.5.6__
207 | * Reverse PR #6
208 | 
209 | __2.5.5__
210 | * Ignore `receiverAddress` during `freezeBalance` and `unfreezeBalance` if it is equal to the owner address
211 | 
212 | __2.5.4__
213 | * Adds cache in Trx to cache Contracts locally and make the process more efficient
214 | 
215 | __2.5.2__
216 | * Adds static methods `Trx.signString` and `Trx.verifySignature
217 | 
218 | __2.5.0__
219 | * Allows freeBandwidth, freeBandwidthLimit, frozenAmount and frozenDuration to be zero
220 | 
221 | __2.3.7__
222 | * Get rid of jssha to reduce the size of the package a little bit.
223 | 
224 | __2.3.6__
225 | * Supports `/wallet/getapprovedlist` and `/wallet/getsignweight` JavaTron API.
226 | * Adds test for multi-sign workflow.
227 | 
228 | __2.3.5__
229 | * Fixes a typo in `#event.getEventsByContractAddress` naming.
230 | 
231 | __2.3.4__
232 | * Adds options to `#plugin.register` to pass parameters to `pluginInterface`.
233 | 
234 | __2.3.3__
235 | * Adds filters during event watching.
236 | 
237 | __2.3.2__
238 | * Removes mixed approach instantiating tronWeb. Before you could pass the servers as an object, and the privateKey as a separate parameter. Now, you pass them either in the options object or in the params.
239 | 
240 | __2.3.1__
241 | * Adds support for not-tld domain, like http://localhost
242 | * Improve the new format, allow passing the privateKey as a property in the option object
243 | 
244 | __2.3.0__
245 | * Introduces new format to instantiate tronWeb, passing an options object instead that `fullNode`, `solidityNode` and `eventServer` as separate params
246 | * Fixes bug in `_watch` which causes a continuous update of the `since` parameter
247 | 
248 | ## Licence
249 | 
250 | TronWeb is distributed under a MIT licence.
251 | 
252 | 
253 | -----
254 | 
255 | For more historic data, check the original repo at
256 | [https://github.com/tronprotocol/tron-web](https://github.com/tronprotocol/tron-web)
257 | 


--------------------------------------------------------------------------------
/assets/TronWeb-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TRON-US/tronweb/235db6015467c9a72aba26f01d0e8168893f0ea5/assets/TronWeb-logo.png


--------------------------------------------------------------------------------
/karma.conf.js:
--------------------------------------------------------------------------------
 1 | const globby = require('globby');
 2 | const puppeteer = require('puppeteer');
 3 | 
 4 | process.env.CHROME_BIN = puppeteer.executablePath();
 5 | 
 6 | const basePlugins = [
 7 |     '@babel/plugin-proposal-numeric-separator',
 8 |     '@babel/plugin-proposal-class-properties',
 9 |     '@babel/plugin-transform-runtime',
10 |     '@babel/plugin-proposal-object-rest-spread',
11 |     'source-map-support'
12 | ];
13 | 
14 | const files = globby.sync([ 'test/**/*.test.js' ]);
15 | 
16 | module.exports = function (config) {
17 |     config.set({
18 |         frameworks: [ 'mocha' ],
19 |         browsers : [ 'ChromeHeadless', /* 'Firefox'  , 'Edge' */ ],
20 |         preprocessors: {
21 |             'test/**/*.test.js': [ 'webpack', 'sourcemap' ]
22 |         },
23 |         reporters: [ 'spec', 'coverage' ],
24 |         coverageReporter: {
25 |             dir: 'coverage/',
26 |             reporters: [
27 |                 { type: 'html' },
28 |                 { type: 'text' },
29 |                 { type: 'text-summary' }
30 |             ],
31 |             instrumenterOptions: {
32 |                 istanbul: { noCompact: true }
33 |             }
34 |         },
35 |         webpack: {
36 |             output: {
37 |                 libraryTarget: 'umd',
38 |                 libraryExport: 'default',
39 |                 umdNamedDefine: true
40 |             },
41 |             devtool: 'inline-source-map',
42 |             module: {
43 |                 rules: [
44 |                     {
45 |                         test: /\.js$/,
46 |                         exclude: /(test|node_modules|bower_components)/,
47 |                         loader: 'babel-loader',
48 |                         options: {
49 |                             presets: [
50 |                                 ['@babel/env', {
51 |                                     targets: {
52 |                                         browsers: [
53 |                                             '>0.25%',
54 |                                             'not dead'
55 |                                         ]
56 |                                     }
57 |                                 }]
58 |                             ],
59 |                             plugins: [
60 |                                 ...basePlugins,
61 |                                 "istanbul"
62 |                             ]
63 |                         },
64 |                     }
65 |                 ]
66 |             },
67 |             resolve: {
68 |                 modules: [
69 |                     'node_modules',
70 |                     'src'
71 |                 ],
72 |             },
73 |             mode: process.env.NODE_ENV || 'development',
74 |             target: 'web',
75 |             node: {
76 |                 fs: "empty",
77 |                 module: "empty"
78 |             }
79 |         },
80 |         webpackMiddleware: {
81 |             noInfo: true
82 |         },
83 |         plugins: [
84 |             require("karma-webpack"),
85 |             require("istanbul-instrumenter-loader"),
86 |             require("karma-mocha"),
87 |             require("karma-coverage"),
88 |             require("karma-chrome-launcher"),
89 |             require("karma-spec-reporter"),
90 |             require('karma-sourcemap-loader'),
91 |             require('karma-coverage-istanbul-reporter'),
92 |             require('karma-firefox-launcher'),
93 |             require('karma-edge-launcher')
94 |         ],
95 |         files
96 |     });
97 | };
98 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "tronweb",
 3 |     "version": "2.10.1",
 4 |     "description": "JavaScript SDK that encapsulates the TRON HTTP API",
 5 |     "main": "dist/TronWeb.node.js",
 6 |     "scripts": {
 7 |         "prepare": "npm run build",
 8 |         "build": "npm run clean && webpack --config webpack.config.js --progress --colors",
 9 |         "build:dev": "NODE_ENV=development npm run build",
10 |         "clean": "rimraf dist",
11 |         "newaccount": "node scripts/test-node.js && node test/helpers/newAccounts 50",
12 |         "test": "node scripts/test-node.js && node test/helpers/newAccounts 50 npm run-script newaccount && npx mocha 'test/**/*.test.js'",
13 |         "test-no-accounts": "node scripts/test-node.js && npx mocha 'test/**/*.test.js'",
14 |         "test:browser": "npm run-script newaccount && node scripts/test-browser.js && npx karma start --single-run --browsers ChromeHeadless",
15 |         "coverage": "npm run-script test:browser && npm run-script test",
16 |         "btest": "npm run build:dev && npm run test"
17 |     },
18 |     "husky": {
19 |         "hooks": {
20 |             "pre-commit": "node ./scripts/pre-commit.js"
21 |         }
22 |     },
23 |     "dependencies": {
24 |         "@babel/runtime": "^7.0.0",
25 |         "axios": "^0.19.0",
26 |         "babel-runtime": "^6.26.0",
27 |         "bignumber.js": "^7.2.1",
28 |         "elliptic": "^6.4.1",
29 |         "ethers": "^4.0.7",
30 |         "eventemitter3": "^3.1.0",
31 |         "injectpromise": "^1.0.0",
32 |         "lodash": "^4.17.14",
33 |         "semver": "^5.6.0",
34 |         "validator": "^10.7.1"
35 |     },
36 |     "devDependencies": {
37 |         "@babel/core": "^7.0.0",
38 |         "@babel/plugin-proposal-class-properties": "^7.0.0",
39 |         "@babel/plugin-proposal-numeric-separator": "^7.0.0",
40 |         "@babel/plugin-proposal-object-rest-spread": "^7.0.0",
41 |         "@babel/plugin-transform-runtime": "^7.0.0",
42 |         "@babel/preset-env": "^7.0.0",
43 |         "babel-loader": "^8.0.2",
44 |         "babel-minify-webpack-plugin": "^0.3.1",
45 |         "babel-plugin-istanbul": "^5.0.1",
46 |         "babel-plugin-source-map-support": "^2.0.1",
47 |         "chai": "^4.1.2",
48 |         "chalk": "^2.4.1",
49 |         "eth-sig-util": "^2.1.0",
50 |         "globby": "^8.0.1",
51 |         "grunt": "^1.0.4",
52 |         "grunt-cli": "^1.3.1",
53 |         "grunt-karma": "^3.0.0",
54 |         "husky": "^1.0.0-rc.14",
55 |         "istanbul": "^0.4.5",
56 |         "istanbul-instrumenter-loader": "^3.0.1",
57 |         "karma": "^4.0.1",
58 |         "karma-chrome-launcher": "^2.2.0",
59 |         "karma-coverage": "^1.1.2",
60 |         "karma-coverage-istanbul-reporter": "^2.0.4",
61 |         "karma-edge-launcher": "^0.4.2",
62 |         "karma-firefox-launcher": "^1.1.0",
63 |         "karma-mocha": "^1.3.0",
64 |         "karma-sourcemap-loader": "^0.3.7",
65 |         "karma-spec-reporter": "^0.0.32",
66 |         "karma-webpack": "4.0.0-rc.2",
67 |         "matchdep": "^2.0.0",
68 |         "mocha": "^5.2.0",
69 |         "puppeteer": "^1.20.0",
70 |         "rimraf": "^2.6.2",
71 |         "source-map-support": "^0.5.9",
72 |         "webpack": "^4.17.2",
73 |         "webpack-cli": "^3.1.0",
74 |         "webpack-node-externals": "^1.7.2"
75 |     },
76 |     "author": {
77 |         "name": "Kondax",
78 |         "url": "https://github.com/Kondax"
79 |     },
80 |     "contributors": [
81 |         {
82 |             "name": "Francesco Sullo",
83 |             "url": "https://github.com/sullof"
84 |         },
85 |         {
86 |             "name": "TRON-US",
87 |             "url": "https://github.com/tron-us"
88 |         }
89 |     ],
90 |     "homepage": "https://github.com/tron-us/tronweb",
91 |     "license": "MIT",
92 |     "repository": "https://github.com/tron-us/tronweb.git"
93 | }
94 | 


--------------------------------------------------------------------------------
/pre-commit-result:
--------------------------------------------------------------------------------
1 | Test skipped before git commit.


--------------------------------------------------------------------------------
/scripts/pre-commit.js:
--------------------------------------------------------------------------------
 1 | const {execSync, spawn} = require('child_process')
 2 | const path = require('path')
 3 | const fs = require('fs')
 4 | const resultFile = path.resolve(__dirname, '../pre-commit-result')
 5 | 
 6 | if (!process.env.SKIPPRECOMMIT) {
 7 | 
 8 |     const chalk = require('chalk')
 9 | 
10 |     const branch = execSync('git name-rev --name-only HEAD').toString().split('\n')[0];
11 |     let unpushed;
12 | 
13 |     try {
14 |         unpushed = execSync(`git log origin/${branch}..${branch} --name-status`).toString().split('\n');
15 |     } catch (ex) {
16 |         unpushed = execSync(`git log HEAD...origin --name-status`).toString().split('\n');
17 |     }
18 | 
19 |     let errors = false
20 | 
21 | 
22 |     const build = spawn('yarn', ['build'])
23 | 
24 |     build.stdout.on('data', function (data) {
25 |         process.stdout.write(data.toString())
26 |     })
27 | 
28 |     build.stderr.on('data', function (data) {
29 |         process.stdout.write(data.toString())
30 |     })
31 | 
32 |     build.on('exit', function (code) {
33 |         const test = spawn('yarn', ['test'])
34 | 
35 |         test.stdout.on('data', function (data) {
36 |             process.stdout.write(data.toString())
37 |         })
38 | 
39 |         test.stderr.on('data', function (data) {
40 |             errors = true
41 |             console.log('stderr: ' + data.toString())
42 |         })
43 | 
44 |         test.on('exit', function (code) {
45 |             if (errors) {
46 |                 console.log(chalk.red('Tests have failed. Please verify tests are passing before pushing'));
47 |                 process.exit(1);
48 |             }
49 |             if (fs.existsSync(resultFile)) {
50 |                 fs.unlinkSync(resultFile)
51 |             }
52 |             execSync('git add -A')
53 |             process.exit(0);
54 |         })
55 |     })
56 | 
57 | } else {
58 |     console.log('echo "Test skipped before git commit" >> ' + resultFile)
59 |     fs.writeFileSync(resultFile, 'Test skipped before git commit.')
60 |     execSync('git add -A')
61 |     process.exit(0);
62 | }
63 | 


--------------------------------------------------------------------------------
/scripts/test-browser.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs');
 2 | const path = require('path');
 3 | const target = path.resolve(__dirname, '..', 'test', 'setup', 'TronWeb.js');
 4 | 
 5 | try {
 6 |     fs.unlinkSync(target);
 7 | } catch(ex) {}
 8 | 
 9 | fs.copyFileSync(
10 |     path.resolve(__dirname, '..', 'test', 'setup', 'browser.js'),
11 |     target
12 | );


--------------------------------------------------------------------------------
/scripts/test-node.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs');
 2 | const path = require('path');
 3 | const target = path.resolve(__dirname, '..', 'test', 'setup', 'TronWeb.js');
 4 | 
 5 | try {
 6 |     fs.unlinkSync(target);
 7 | } catch(ex) {}
 8 | 
 9 | fs.copyFileSync(
10 |     path.resolve(__dirname, '..', 'test', 'setup', 'node.js'),
11 |     target
12 | );


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
  1 | import providers from 'lib/providers';
  2 | import utils from 'utils';
  3 | import BigNumber from 'bignumber.js';
  4 | import EventEmitter from 'eventemitter3';
  5 | import {version} from '../package.json';
  6 | import semver from 'semver';
  7 | import injectpromise from 'injectpromise';
  8 | 
  9 | import TransactionBuilder from 'lib/transactionBuilder';
 10 | import Trx from 'lib/trx';
 11 | import Contract from 'lib/contract';
 12 | import Plugin from 'lib/plugin';
 13 | import Event from 'lib/event';
 14 | import {keccak256} from 'utils/ethersUtils';
 15 | import {ADDRESS_PREFIX} from 'utils/address';
 16 | 
 17 | const DEFAULT_VERSION = '3.5.0';
 18 | 
 19 | export default class TronWeb extends EventEmitter {
 20 |     static providers = providers;
 21 |     static BigNumber = BigNumber;
 22 |     static TransactionBuilder = TransactionBuilder;
 23 |     static Trx = Trx;
 24 |     static Contract = Contract;
 25 |     static Plugin = Plugin;
 26 |     static Event = Event;
 27 |     static version = version;
 28 |     static utils = utils;
 29 | 
 30 |     constructor(options = false,
 31 |                 // for retro-compatibility:
 32 |                 solidityNode = false, eventServer = false, privateKey = false) {
 33 |         super();
 34 | 
 35 |         let fullNode;
 36 |         if (typeof options === 'object' && (options.fullNode || options.fullHost)) {
 37 |             fullNode = options.fullNode || options.fullHost;
 38 |             solidityNode = options.solidityNode || options.fullHost;
 39 |             eventServer = options.eventServer || options.fullHost;
 40 |             privateKey = options.privateKey;
 41 |         } else {
 42 |             fullNode = options;
 43 |         }
 44 | 
 45 |         if (utils.isString(fullNode))
 46 |             fullNode = new providers.HttpProvider(fullNode);
 47 | 
 48 |         if (utils.isString(solidityNode))
 49 |             solidityNode = new providers.HttpProvider(solidityNode);
 50 | 
 51 |         if (utils.isString(eventServer))
 52 |             eventServer = new providers.HttpProvider(eventServer);
 53 | 
 54 |         this.event = new Event(this);
 55 |         this.transactionBuilder = new TransactionBuilder(this);
 56 |         this.trx = new Trx(this);
 57 |         this.plugin = new Plugin(this, options);
 58 |         this.utils = utils;
 59 | 
 60 |         this.setFullNode(fullNode);
 61 |         this.setSolidityNode(solidityNode);
 62 |         this.setEventServer(eventServer);
 63 | 
 64 |         this.providers = providers;
 65 |         this.BigNumber = BigNumber;
 66 | 
 67 |         this.defaultBlock = false;
 68 |         this.defaultPrivateKey = false;
 69 |         this.defaultAddress = {
 70 |             hex: false,
 71 |             base58: false
 72 |         };
 73 | 
 74 |         [
 75 |             'sha3', 'toHex', 'toUtf8', 'fromUtf8',
 76 |             'toAscii', 'fromAscii', 'toDecimal', 'fromDecimal',
 77 |             'toSun', 'fromSun', 'toBigNumber', 'isAddress',
 78 |             'createAccount', 'address', 'version'
 79 |         ].forEach(key => {
 80 |             this[key] = TronWeb[key];
 81 |         });
 82 | 
 83 |         if (privateKey)
 84 |             this.setPrivateKey(privateKey);
 85 | 
 86 |         this.fullnodeVersion = DEFAULT_VERSION;
 87 |         this.injectPromise = injectpromise(this);
 88 |     }
 89 | 
 90 |     async getFullnodeVersion() {
 91 |         try {
 92 |             const nodeInfo = await this.trx.getNodeInfo()
 93 |             this.fullnodeVersion = nodeInfo.configNodeInfo.codeVersion
 94 |             if (this.fullnodeVersion.split('.').length === 2) {
 95 |                 this.fullnodeVersion += '.0';
 96 |             }
 97 |         } catch (err) {
 98 |             this.fullnodeVersion = DEFAULT_VERSION;
 99 |         }
100 |     }
101 | 
102 |     setDefaultBlock(blockID = false) {
103 |         if ([false, 'latest', 'earliest', 0].includes(blockID)) {
104 |             return this.defaultBlock = blockID;
105 |         }
106 | 
107 |         if (!utils.isInteger(blockID) || !blockID)
108 |             throw new Error('Invalid block ID provided');
109 | 
110 |         this.defaultBlock = Math.abs(blockID);
111 |     }
112 | 
113 |     setPrivateKey(privateKey) {
114 |         try {
115 |             this.setAddress(
116 |                 this.address.fromPrivateKey(privateKey)
117 |             );
118 |         } catch {
119 |             throw new Error('Invalid private key provided');
120 |         }
121 | 
122 |         this.defaultPrivateKey = privateKey;
123 |         this.emit('privateKeyChanged', privateKey);
124 |     }
125 | 
126 |     setAddress(address) {
127 |         if (!this.isAddress(address))
128 |             throw new Error('Invalid address provided');
129 | 
130 |         const hex = this.address.toHex(address);
131 |         const base58 = this.address.fromHex(address);
132 | 
133 |         if (this.defaultPrivateKey && this.address.fromPrivateKey(this.defaultPrivateKey) !== base58)
134 |             this.defaultPrivateKey = false;
135 | 
136 |         this.defaultAddress = {
137 |             hex,
138 |             base58
139 |         };
140 | 
141 |         this.emit('addressChanged', {hex, base58});
142 |     }
143 | 
144 |     fullnodeSatisfies(version) {
145 |         return semver.satisfies(this.fullnodeVersion, version);
146 |     }
147 | 
148 |     isValidProvider(provider) {
149 |         return Object.values(providers).some(knownProvider => provider instanceof knownProvider);
150 |     }
151 | 
152 |     setFullNode(fullNode) {
153 |         if (utils.isString(fullNode))
154 |             fullNode = new providers.HttpProvider(fullNode);
155 | 
156 |         if (!this.isValidProvider(fullNode))
157 |             throw new Error('Invalid full node provided');
158 | 
159 |         this.fullNode = fullNode;
160 |         this.fullNode.setStatusPage('wallet/getnowblock');
161 | 
162 |         this.getFullnodeVersion();
163 |     }
164 | 
165 |     setSolidityNode(solidityNode) {
166 |         if (utils.isString(solidityNode))
167 |             solidityNode = new providers.HttpProvider(solidityNode);
168 | 
169 |         if (!this.isValidProvider(solidityNode))
170 |             throw new Error('Invalid solidity node provided');
171 | 
172 |         this.solidityNode = solidityNode;
173 |         this.solidityNode.setStatusPage('walletsolidity/getnowblock');
174 |     }
175 | 
176 |     setEventServer(...params) {
177 |         this.event.setServer(...params)
178 |     }
179 | 
180 |     currentProviders() {
181 |         return {
182 |             fullNode: this.fullNode,
183 |             solidityNode: this.solidityNode,
184 |             eventServer: this.eventServer
185 |         };
186 |     }
187 | 
188 |     currentProvider() {
189 |         return this.currentProviders();
190 |     }
191 | 
192 | 
193 |     getEventResult(...params) {
194 | 
195 |         if (typeof params[1] !== 'object') {
196 |             params[1] = {
197 |                 sinceTimestamp: params[1] || 0,
198 |                 eventName: params[2] || false,
199 |                 blockNumber: params[3] || false,
200 |                 size: params[4] || 20,
201 |                 page: params[5] || 1
202 |             }
203 |             params.splice(2, 4)
204 | 
205 |             // callback:
206 |             if (!utils.isFunction(params[2])) {
207 | 
208 |                 if (utils.isFunction(params[1].page)) {
209 |                     params[2] = params[1].page;
210 |                     params[1].page = 1;
211 |                 } else if (utils.isFunction(params[1].size)) {
212 |                     params[2] = params[1].size;
213 |                     params[1].size = 20;
214 |                     params[1].page = 1;
215 |                 }
216 |             }
217 |         }
218 | 
219 |         return this.event.getEventsByContractAddress(...params);
220 |     }
221 | 
222 |     getEventByTransactionID(...params) {
223 |         return this.event.getEventsByTransactionID(...params)
224 |     }
225 | 
226 |     contract(abi = [], address = false) {
227 |         return new Contract(this, abi, address);
228 |     }
229 | 
230 |     static get address() {
231 |         return {
232 |             fromHex(address) {
233 |                 if (!utils.isHex(address))
234 |                     return address;
235 | 
236 |                 return utils.crypto.getBase58CheckAddress(
237 |                     utils.code.hexStr2byteArray(address.replace(/^0x/, ADDRESS_PREFIX))
238 |                 );
239 |             },
240 |             toHex(address) {
241 |                 if (utils.isHex(address))
242 |                     return address.toLowerCase().replace(/^0x/, ADDRESS_PREFIX);
243 | 
244 |                 return utils.code.byteArray2hexStr(
245 |                     utils.crypto.decodeBase58Address(address)
246 |                 ).toLowerCase();
247 |             },
248 |             fromPrivateKey(privateKey) {
249 |                 try {
250 |                     return utils.crypto.pkToAddress(privateKey);
251 |                 } catch {
252 |                     return false;
253 |                 }
254 |             }
255 |         }
256 |     }
257 | 
258 |     static sha3(string, prefix = true) {
259 |         return (prefix ? '0x' : '') + keccak256(Buffer.from(string, 'utf-8')).toString().substring(2);
260 |     }
261 | 
262 |     static toHex(val) {
263 |         if (utils.isBoolean(val))
264 |             return TronWeb.fromDecimal(+val);
265 | 
266 |         if (utils.isBigNumber(val))
267 |             return TronWeb.fromDecimal(val);
268 | 
269 |         if (typeof val === 'object')
270 |             return TronWeb.fromUtf8(JSON.stringify(val));
271 | 
272 |         if (utils.isString(val)) {
273 |             if (/^(-|)0x/.test(val))
274 |                 return val;
275 | 
276 |             if (!isFinite(val))
277 |                 return TronWeb.fromUtf8(val);
278 |         }
279 | 
280 |         let result = TronWeb.fromDecimal(val);
281 |         if (result === '0xNaN') {
282 |             throw new Error('The passed value is not convertible to a hex string');
283 |         } else {
284 |             return result;
285 |         }
286 |     }
287 | 
288 |     static toUtf8(hex) {
289 |         if (utils.isHex(hex)) {
290 |             hex = hex.replace(/^0x/, '');
291 |             return Buffer.from(hex, 'hex').toString('utf8');
292 |         } else {
293 |             throw new Error('The passed value is not a valid hex string');
294 |         }
295 |     }
296 | 
297 |     static fromUtf8(string) {
298 |         if (!utils.isString(string)) {
299 |             throw new Error('The passed value is not a valid utf-8 string')
300 |         }
301 |         return '0x' + Buffer.from(string, 'utf8').toString('hex');
302 |     }
303 | 
304 |     static toAscii(hex) {
305 |         if (utils.isHex(hex)) {
306 |             let str = "";
307 |             let i = 0, l = hex.length;
308 |             if (hex.substring(0, 2) === '0x') {
309 |                 i = 2;
310 |             }
311 |             for (; i < l; i += 2) {
312 |                 let code = parseInt(hex.substr(i, 2), 16);
313 |                 str += String.fromCharCode(code);
314 |             }
315 |             return str;
316 |         } else {
317 |             throw new Error('The passed value is not a valid hex string');
318 |         }
319 |     }
320 | 
321 |     static fromAscii(string, padding) {
322 |         if (!utils.isString(string)) {
323 |             throw new Error('The passed value is not a valid utf-8 string')
324 |         }
325 |         return '0x' + Buffer.from(string, 'ascii').toString('hex').padEnd(padding, '0');
326 |     }
327 | 
328 | 
329 |     static toDecimal(value) {
330 |         return TronWeb.toBigNumber(value).toNumber();
331 |     }
332 | 
333 |     static fromDecimal(value) {
334 |         const number = TronWeb.toBigNumber(value);
335 |         const result = number.toString(16);
336 | 
337 |         return number.isLessThan(0) ? '-0x' + result.substr(1) : '0x' + result;
338 |     }
339 | 
340 |     static fromSun(sun) {
341 |         const trx = TronWeb.toBigNumber(sun).div(1_000_000);
342 |         return utils.isBigNumber(sun) ? trx : trx.toString(10);
343 |     }
344 | 
345 |     static toSun(trx) {
346 |         const sun = TronWeb.toBigNumber(trx).times(1_000_000);
347 |         return utils.isBigNumber(trx) ? sun : sun.toString(10);
348 |     }
349 | 
350 |     static toBigNumber(amount = 0) {
351 |         if (utils.isBigNumber(amount))
352 |             return amount;
353 | 
354 |         if (utils.isString(amount) && /^(-|)0x/.test(amount))
355 |             return new BigNumber(amount.replace('0x', ''), 16);
356 | 
357 |         return new BigNumber(amount.toString(10), 10);
358 |     }
359 | 
360 |     static isAddress(address = false) {
361 |         if (!utils.isString(address))
362 |             return false;
363 | 
364 |         // Convert HEX to Base58
365 |         if (address.length === 42) {
366 |             try {
367 |                 return TronWeb.isAddress(
368 |                     utils.crypto.getBase58CheckAddress(
369 |                         utils.code.hexStr2byteArray(address) // it throws an error if the address starts with 0x
370 |                     )
371 |                 );
372 |             } catch (err) {
373 |                 return false;
374 |             }
375 |         }
376 |         try {
377 |             return utils.crypto.isAddressValid(address);
378 |         } catch (err) {
379 |             return false;
380 |         }
381 |     }
382 | 
383 |     static async createAccount() {
384 |         const account = utils.accounts.generateAccount();
385 | 
386 |         return account;
387 |     }
388 | 
389 |     async isConnected(callback = false) {
390 |         if (!callback)
391 |             return this.injectPromise(this.isConnected);
392 | 
393 |         return callback(null, {
394 |             fullNode: await this.fullNode.isConnected(),
395 |             solidityNode: await this.solidityNode.isConnected(),
396 |             eventServer: this.eventServer && await this.eventServer.isConnected()
397 |         });
398 |     }
399 | };
400 | 


--------------------------------------------------------------------------------
/src/lib/contract/index.js:
--------------------------------------------------------------------------------
  1 | import TronWeb from 'index';
  2 | import utils from 'utils';
  3 | import Method from './method';
  4 | import injectpromise from 'injectpromise';
  5 | 
  6 | export default class Contract {
  7 |     constructor(tronWeb = false, abi = [], address = false) {
  8 |         if (!tronWeb || !tronWeb instanceof TronWeb)
  9 |             throw new Error('Expected instance of TronWeb');
 10 | 
 11 |         this.tronWeb = tronWeb;
 12 |         this.injectPromise = injectpromise(this);
 13 | 
 14 |         this.address = address;
 15 |         this.abi = abi;
 16 | 
 17 |         this.eventListener = false;
 18 |         this.bytecode = false;
 19 |         this.deployed = false;
 20 |         this.lastBlock = false;
 21 | 
 22 |         this.methods = {};
 23 |         this.methodInstances = {};
 24 |         this.props = [];
 25 | 
 26 |         if (this.tronWeb.isAddress(address))
 27 |             this.deployed = true;
 28 |         else this.address = false;
 29 | 
 30 |         this.loadAbi(abi);
 31 |     }
 32 | 
 33 |     async _getEvents(options = {}) {
 34 |         const events = await this.tronWeb.event.getEventsByContractAddress(this.address, options);
 35 |         const [latestEvent] = events.sort((a, b) => b.block - a.block);
 36 |         const newEvents = events.filter((event, index) => {
 37 | 
 38 |             if (options.resourceNode && event.resourceNode &&
 39 |                 options.resourceNode.toLowerCase() !== event.resourceNode.toLowerCase()) {
 40 |                 return false
 41 |             }
 42 | 
 43 |             const duplicate = events.slice(0, index).some(priorEvent => (
 44 |                 JSON.stringify(priorEvent) == JSON.stringify(event)
 45 |             ));
 46 | 
 47 |             if (duplicate)
 48 |                 return false;
 49 | 
 50 |             if (!this.lastBlock)
 51 |                 return true;
 52 | 
 53 |             return event.block > this.lastBlock;
 54 |         });
 55 | 
 56 |         if (latestEvent)
 57 |             this.lastBlock = latestEvent.block;
 58 | 
 59 |         return newEvents;
 60 |     }
 61 | 
 62 |     async _startEventListener(options = {}, callback) {
 63 |         if (utils.isFunction(options)) {
 64 |             callback = options;
 65 |             options = {};
 66 |         }
 67 | 
 68 |         if (this.eventListener)
 69 |             clearInterval(this.eventListener);
 70 | 
 71 |         if (!this.tronWeb.eventServer)
 72 |             throw new Error('Event server is not configured');
 73 | 
 74 |         if (!this.address)
 75 |             throw new Error('Contract is not configured with an address');
 76 | 
 77 |         this.eventCallback = callback;
 78 |         await this._getEvents(options);
 79 | 
 80 |         this.eventListener = setInterval(() => {
 81 |             this._getEvents(options).then(newEvents => newEvents.forEach(event => {
 82 |                 this.eventCallback && this.eventCallback(event)
 83 |             })).catch(err => {
 84 |                 console.error('Failed to get event list', err);
 85 |             });
 86 |         }, 3000);
 87 |     }
 88 | 
 89 |     _stopEventListener() {
 90 |         if (!this.eventListener)
 91 |             return;
 92 | 
 93 |         clearInterval(this.eventListener);
 94 |         this.eventListener = false;
 95 |         this.eventCallback = false;
 96 |     }
 97 | 
 98 |     hasProperty(property) {
 99 |         return this.hasOwnProperty(property) || this.__proto__.hasOwnProperty(property);
100 |     }
101 | 
102 |     loadAbi(abi) {
103 |         this.abi = abi;
104 |         this.methods = {};
105 | 
106 |         this.props.forEach(prop => delete this[prop]);
107 | 
108 |         abi.forEach(func => {
109 |             // Don't build a method for constructor function. That's handled through contract create.
110 |             if (!func.type || /constructor/i.test(func.type))
111 |                 return;
112 | 
113 |             const method = new Method(this, func);
114 |             const methodCall = method.onMethod.bind(method);
115 | 
116 |             const {
117 |                 name,
118 |                 functionSelector,
119 |                 signature
120 |             } = method;
121 | 
122 |             this.methods[name] = methodCall;
123 |             this.methods[functionSelector] = methodCall;
124 |             this.methods[signature] = methodCall;
125 | 
126 |             this.methodInstances[name] = method;
127 |             this.methodInstances[functionSelector] = method;
128 |             this.methodInstances[signature] = method;
129 | 
130 |             if (!this.hasProperty(name)) {
131 |                 this[name] = methodCall;
132 |                 this.props.push(name);
133 |             }
134 | 
135 |             if (!this.hasProperty(functionSelector)) {
136 |                 this[functionSelector] = methodCall;
137 |                 this.props.push(functionSelector);
138 |             }
139 | 
140 |             if (!this.hasProperty(signature)) {
141 |                 this[signature] = methodCall;
142 |                 this.props.push(signature);
143 |             }
144 |         });
145 |     }
146 | 
147 |     decodeInput(data) {
148 | 
149 |         const methodName = data.substring(0, 8);
150 |         const inputData = data.substring(8);
151 | 
152 |         if (!this.methodInstances[methodName])
153 |             throw new Error('Contract method ' + methodName + " not found");
154 | 
155 |         const methodInstance = this.methodInstances[methodName];
156 | 
157 |         return {
158 |             name: methodInstance.name,
159 |             params: this.methodInstances[methodName].decodeInput(inputData),
160 |         }
161 |     }
162 | 
163 |     async new(options, privateKey = this.tronWeb.defaultPrivateKey, callback = false) {
164 |         if (utils.isFunction(privateKey)) {
165 |             callback = privateKey;
166 |             privateKey = this.tronWeb.defaultPrivateKey;
167 |         }
168 | 
169 |         if (!callback)
170 |             return this.injectPromise(this.new, options, privateKey);
171 | 
172 |         try {
173 |             const address = this.tronWeb.address.fromPrivateKey(privateKey);
174 |             const transaction = await this.tronWeb.transactionBuilder.createSmartContract(options, address);
175 |             const signedTransaction = await this.tronWeb.trx.sign(transaction, privateKey);
176 |             const contract = await this.tronWeb.trx.sendRawTransaction(signedTransaction);
177 | 
178 |             if (contract.code)
179 |                 return callback({
180 |                     error: contract.code,
181 |                     message: this.tronWeb.toUtf8(contract.message)
182 |                 })
183 | 
184 |             await utils.sleep(3000);
185 |             return this.at(signedTransaction.contract_address, callback);
186 |         } catch (ex) {
187 |             return callback(ex);
188 |         }
189 |     }
190 | 
191 |     async at(contractAddress, callback = false) {
192 |         if (!callback)
193 |             return this.injectPromise(this.at, contractAddress);
194 | 
195 |         try {
196 |             const contract = await this.tronWeb.trx.getContract(contractAddress);
197 | 
198 |             if (!contract.contract_address)
199 |                 return callback('Unknown error: ' + JSON.stringify(contract, null, 2));
200 | 
201 |             this.address = contract.contract_address;
202 |             this.bytecode = contract.bytecode;
203 |             this.deployed = true;
204 | 
205 |             this.loadAbi(contract.abi ? contract.abi.entrys : []);
206 | 
207 |             return callback(null, this);
208 |         } catch (ex) {
209 |             if (ex.toString().includes('does not exist'))
210 |                 return callback('Contract has not been deployed on the network');
211 | 
212 |             return callback(ex);
213 |         }
214 |     }
215 | 
216 |     events(options = {}, callback = false) {
217 |         if (utils.isFunction(options)) {
218 |             callback = options;
219 |             options = {};
220 |         }
221 | 
222 |         if (!utils.isFunction(callback))
223 |             throw new Error('Callback function expected');
224 | 
225 |         const self = this;
226 | 
227 |         return {
228 |             start(startCallback = false) {
229 |                 if (!startCallback) {
230 |                     self._startEventListener(options, callback);
231 |                     return this;
232 |                 }
233 | 
234 |                 self._startEventListener(options, callback).then(() => {
235 |                     startCallback();
236 |                 }).catch(err => {
237 |                     startCallback(err)
238 |                 });
239 | 
240 |                 return this;
241 |             },
242 |             stop() {
243 |                 self._stopEventListener();
244 |             }
245 |         };
246 |     }
247 | }
248 | 


--------------------------------------------------------------------------------
/src/lib/contract/method.js:
--------------------------------------------------------------------------------
  1 | import utils from 'utils';
  2 | import {ADDRESS_PREFIX_REGEX} from 'utils/address';
  3 | import injectpromise from 'injectpromise';
  4 | 
  5 | const getFunctionSelector = abi => {
  6 |     return abi.name + '(' + getParamTypes(abi.inputs || []).join(',') + ')';
  7 | }
  8 | 
  9 | const getParamTypes = params => {
 10 |     return params.map(({type}) => type);
 11 | }
 12 | 
 13 | const decodeOutput = (abi, output) => {
 14 |     const names = abi.map(({name}) => name).filter(name => !!name);
 15 |     const types = abi.map(({type}) => type);
 16 | 
 17 |     return utils.abi.decodeParams(names, types, output);
 18 | };
 19 | 
 20 | export default class Method {
 21 |     constructor(contract, abi) {
 22 |         this.tronWeb = contract.tronWeb;
 23 |         this.contract = contract;
 24 | 
 25 |         this.abi = abi;
 26 |         this.name = abi.name || (abi.name = abi.type);
 27 | 
 28 |         this.inputs = abi.inputs || [];
 29 |         this.outputs = abi.outputs || [];
 30 | 
 31 |         this.functionSelector = getFunctionSelector(abi);
 32 |         this.signature = this.tronWeb.sha3(this.functionSelector, false).slice(0, 8);
 33 |         this.injectPromise = injectpromise(this);
 34 | 
 35 |         this.defaultOptions = {
 36 |             feeLimit: 1000000000,
 37 |             callValue: 0,
 38 |             userFeePercentage: 100,
 39 |             shouldPollResponse: false // Only used for sign()
 40 |         };
 41 |     }
 42 | 
 43 |     decodeInput(data) {
 44 |         return decodeOutput(this.inputs, '0x' + data);
 45 |     }
 46 | 
 47 |     onMethod(...args) {
 48 |         const types = getParamTypes(this.inputs);
 49 | 
 50 |         args.forEach((arg, index) => {
 51 |             if (types[index] == 'address')
 52 |                 args[index] = this.tronWeb.address.toHex(arg).replace(ADDRESS_PREFIX_REGEX, '0x')
 53 | 
 54 |             if (types[index] == 'address[]') {
 55 |                 args[index] = args[index].map(address => {
 56 |                     return this.tronWeb.address.toHex(address).replace(ADDRESS_PREFIX_REGEX, '0x')
 57 |                 })
 58 |             }
 59 |         });
 60 | 
 61 |         return {
 62 |             call: (...methodArgs) => this._call(types, args, ...methodArgs),
 63 |             send: (...methodArgs) => this._send(types, args, ...methodArgs),
 64 |             watch: (...methodArgs) => this._watch(...methodArgs)
 65 |         }
 66 |     }
 67 | 
 68 |     async _call(types, args, options = {}, callback = false) {
 69 |         if (utils.isFunction(options)) {
 70 |             callback = options;
 71 |             options = {};
 72 |         }
 73 | 
 74 |         if (!callback)
 75 |             return this.injectPromise(this._call, types, args, options);
 76 | 
 77 |         if (types.length !== args.length)
 78 |             return callback('Invalid argument count provided');
 79 | 
 80 |         if (!this.contract.address)
 81 |             return callback('Smart contract is missing address');
 82 | 
 83 |         if (!this.contract.deployed)
 84 |             return callback('Calling smart contracts requires you to load the contract first');
 85 | 
 86 |         const {stateMutability} = this.abi;
 87 | 
 88 |         if (!['pure', 'view'].includes(stateMutability.toLowerCase()))
 89 |             return callback(`Methods with state mutability "${stateMutability}" must use send()`);
 90 | 
 91 |         options = {
 92 |             ...this.defaultOptions,
 93 |             from: this.tronWeb.defaultAddress.hex,
 94 |             ...options,
 95 |         };
 96 | 
 97 |         const parameters = args.map((value, index) => ({
 98 |             type: types[index],
 99 |             value
100 |         }));
101 | 
102 |         this.tronWeb.transactionBuilder.triggerSmartContract(
103 |             this.contract.address,
104 |             this.functionSelector,
105 |             options,
106 |             parameters,
107 |             options.from ? this.tronWeb.address.toHex(options.from) : false,
108 |             (err, transaction) => {
109 |                 if (err)
110 |                     return callback(err);
111 | 
112 |                 if (!utils.hasProperty(transaction, 'constant_result'))
113 |                     return callback('Failed to execute');
114 | 
115 |                 try {
116 | 
117 |                     const len = transaction.constant_result[0].length
118 |                     if (len === 0 || len % 64 === 8) {
119 |                         let msg = 'The call has been reverted or has thrown an error.'
120 |                         if (len !== 0) {
121 |                             msg += ' Error message: '
122 |                             let msg2 = ''
123 |                             let chunk = transaction.constant_result[0].substring(8)
124 |                             for (let i = 0; i < len - 8; i += 64) {
125 |                                 msg2 += this.tronWeb.toUtf8(chunk.substring(i, i + 64))
126 |                             }
127 |                             msg += msg2.replace(/(\u0000|\u000b|\f)+/g, ' ').replace(/ +/g, ' ').replace(/\s+$/g, '');
128 |                         }
129 |                         return callback(msg)
130 |                     }
131 | 
132 |                     let output = decodeOutput(this.outputs, '0x' + transaction.constant_result[0]);
133 | 
134 |                     if (output.length === 1)
135 |                         output = output[0];
136 | 
137 |                     return callback(null, output);
138 |                 } catch (ex) {
139 |                     return callback(ex);
140 |                 }
141 |             });
142 |     }
143 | 
144 |     async _send(types, args, options = {}, privateKey = this.tronWeb.defaultPrivateKey, callback = false) {
145 |         if (utils.isFunction(privateKey)) {
146 |             callback = privateKey;
147 |             privateKey = this.tronWeb.defaultPrivateKey;
148 |         }
149 | 
150 |         if (utils.isFunction(options)) {
151 |             callback = options;
152 |             options = {};
153 |         }
154 | 
155 |         if (!callback)
156 |             return this.injectPromise(this._send, types, args, options, privateKey);
157 | 
158 |         if (types.length !== args.length)
159 |             throw new Error('Invalid argument count provided');
160 | 
161 |         if (!this.contract.address)
162 |             return callback('Smart contract is missing address');
163 | 
164 |         if (!this.contract.deployed)
165 |             return callback('Calling smart contracts requires you to load the contract first');
166 | 
167 |         const {stateMutability} = this.abi;
168 | 
169 |         if (['pure', 'view'].includes(stateMutability.toLowerCase()))
170 |             return callback(`Methods with state mutability "${stateMutability}" must use call()`);
171 | 
172 |         // If a function isn't payable, dont provide a callValue.
173 |         if (!['payable'].includes(stateMutability.toLowerCase()))
174 |             options.callValue = 0;
175 | 
176 |         options = {
177 |             ...this.defaultOptions,
178 |             from: this.tronWeb.defaultAddress.hex,
179 |             ...options,
180 |         };
181 | 
182 |         const parameters = args.map((value, index) => ({
183 |             type: types[index],
184 |             value
185 |         }));
186 | 
187 |         try {
188 |             const address = privateKey ? this.tronWeb.address.fromPrivateKey(privateKey) : this.tronWeb.defaultAddress.base58;
189 |             const transaction = await this.tronWeb.transactionBuilder.triggerSmartContract(
190 |                 this.contract.address,
191 |                 this.functionSelector,
192 |                 options,
193 |                 parameters,
194 |                 this.tronWeb.address.toHex(address)
195 |             );
196 | 
197 |             if (!transaction.result || !transaction.result.result)
198 |                 return callback('Unknown error: ' + JSON.stringify(transaction, null, 2));
199 | 
200 |             // If privateKey is false, this won't be signed here. We assume sign functionality will be replaced.
201 |             const signedTransaction = await this.tronWeb.trx.sign(transaction.transaction, privateKey);
202 | 
203 |             if (!signedTransaction.signature) {
204 |                 if (!privateKey)
205 |                     return callback('Transaction was not signed properly');
206 | 
207 |                 return callback('Invalid private key provided');
208 |             }
209 | 
210 |             const broadcast = await this.tronWeb.trx.sendRawTransaction(signedTransaction);
211 | 
212 |             if (broadcast.code) {
213 |                 const err = {
214 |                     error: broadcast.code,
215 |                     message: broadcast.code
216 |                 };
217 |                 if (broadcast.message)
218 |                     err.message = this.tronWeb.toUtf8(broadcast.message);
219 |                 return callback(err)
220 |             }
221 | 
222 |             if (!options.shouldPollResponse)
223 |                 return callback(null, signedTransaction.txID);
224 | 
225 |             const checkResult = async (index = 0) => {
226 |                 if (index === 20) {
227 |                     return callback({
228 |                         error: 'Cannot find result in solidity node',
229 |                         transaction: signedTransaction
230 |                     });
231 |                 }
232 | 
233 |                 const output = await this.tronWeb.trx.getTransactionInfo(signedTransaction.txID);
234 | 
235 |                 if (!Object.keys(output).length) {
236 |                     return setTimeout(() => {
237 |                         checkResult(index + 1);
238 |                     }, 3000);
239 |                 }
240 | 
241 |                 if (output.result && output.result === 'FAILED') {
242 |                     return callback({
243 |                         error: this.tronWeb.toUtf8(output.resMessage),
244 |                         transaction: signedTransaction,
245 |                         output
246 |                     });
247 |                 }
248 | 
249 |                 if (!utils.hasProperty(output, 'contractResult')) {
250 |                     return callback({
251 |                         error: 'Failed to execute: ' + JSON.stringify(output, null, 2),
252 |                         transaction: signedTransaction,
253 |                         output
254 |                     });
255 |                 }
256 | 
257 |                 if (options.rawResponse)
258 |                     return callback(null, output);
259 | 
260 |                 let decoded = decodeOutput(this.outputs, '0x' + output.contractResult[0]);
261 | 
262 |                 if (decoded.length === 1)
263 |                     decoded = decoded[0];
264 | 
265 |                 if (options.keepTxID) {
266 |                     return callback(null, [signedTransaction.txID, decoded]);
267 |                 }
268 | 
269 |                 return callback(null, decoded);
270 |             }
271 | 
272 |             checkResult();
273 |         } catch (ex) {
274 |             return callback(ex);
275 |         }
276 |     }
277 | 
278 |     async _watch(options = {}, callback = false) {
279 |         if (utils.isFunction(options)) {
280 |             callback = options;
281 |             options = {};
282 |         }
283 | 
284 |         if (!utils.isFunction(callback))
285 |             throw new Error('Expected callback to be provided');
286 | 
287 |         if (!this.contract.address)
288 |             return callback('Smart contract is missing address');
289 | 
290 |         if (!this.abi.type || !/event/i.test(this.abi.type))
291 |             return callback('Invalid method type for event watching');
292 | 
293 |         if (!this.tronWeb.eventServer)
294 |             return callback('No event server configured');
295 | 
296 |         let listener = false;
297 |         let lastBlock = false;
298 |         let since = Date.now() - 1000;
299 | 
300 |         const getEvents = async () => {
301 |             try {
302 | 
303 |                 const params = {
304 |                     since,
305 |                     eventName: this.name,
306 |                     sort: 'block_timestamp',
307 |                     blockNumber: 'latest',
308 |                     filters: options.filters
309 |                 }
310 |                 if (options.resourceNode) {
311 |                     if (/full/i.test(options.resourceNode))
312 |                         params.onlyUnconfirmed = true
313 |                     else
314 |                         params.onlyConfirmed = true
315 |                 }
316 | 
317 |                 const events = await this.tronWeb.event.getEventsByContractAddress(this.contract.address, params);
318 |                 const [latestEvent] = events.sort((a, b) => b.block - a.block);
319 |                 const newEvents = events.filter((event, index) => {
320 | 
321 |                     if (options.resourceNode && event.resourceNode &&
322 |                         options.resourceNode.toLowerCase() !== event.resourceNode.toLowerCase()) {
323 |                         return false
324 |                     }
325 | 
326 |                     const duplicate = events.slice(0, index).some(priorEvent => (
327 |                         JSON.stringify(priorEvent) == JSON.stringify(event)
328 |                     ));
329 | 
330 |                     if (duplicate)
331 |                         return false;
332 | 
333 |                     if (!lastBlock)
334 |                         return true;
335 | 
336 |                     return event.block > lastBlock;
337 |                 });
338 | 
339 |                 if (latestEvent)
340 |                     lastBlock = latestEvent.block;
341 | 
342 |                 return newEvents;
343 |             } catch (ex) {
344 |                 return Promise.reject(ex);
345 |             }
346 | 
347 |         };
348 | 
349 |         const bindListener = () => {
350 |             if (listener)
351 |                 clearInterval(listener);
352 | 
353 |             listener = setInterval(() => {
354 |                 getEvents().then(events => events.forEach(event => {
355 |                     callback(null, utils.parseEvent(event, this.abi))
356 |                 })).catch(err => callback(err));
357 |             }, 3000);
358 |         };
359 | 
360 |         await getEvents();
361 |         bindListener();
362 | 
363 |         return {
364 |             start: bindListener(),
365 |             stop: () => {
366 |                 if (!listener)
367 |                     return;
368 | 
369 |                 clearInterval(listener);
370 |                 listener = false;
371 |             }
372 |         }
373 |     }
374 | }
375 | 


--------------------------------------------------------------------------------
/src/lib/event.js:
--------------------------------------------------------------------------------
  1 | import TronWeb from 'index';
  2 | import utils from 'utils';
  3 | import providers from "./providers";
  4 | import querystring from "querystring";
  5 | import injectpromise from 'injectpromise';
  6 | 
  7 | export default class Event {
  8 | 
  9 |     constructor(tronWeb = false) {
 10 |         if (!tronWeb || !(tronWeb instanceof TronWeb))
 11 |             throw new Error('Expected instance of TronWeb');
 12 |         this.tronWeb = tronWeb;
 13 |         this.injectPromise = injectpromise(this);
 14 |     }
 15 | 
 16 |     setServer(eventServer = false, healthcheck = 'healthcheck') {
 17 |         if (!eventServer)
 18 |             return this.tronWeb.eventServer = false;
 19 | 
 20 |         if (utils.isString(eventServer))
 21 |             eventServer = new providers.HttpProvider(eventServer);
 22 | 
 23 |         if (!this.tronWeb.isValidProvider(eventServer))
 24 |             throw new Error('Invalid event server provided');
 25 | 
 26 |         this.tronWeb.eventServer = eventServer;
 27 |         this.tronWeb.eventServer.isConnected = () => this.tronWeb.eventServer.request(healthcheck).then(() => true).catch(() => false);
 28 |     }
 29 | 
 30 |     getEventsByContractAddress(contractAddress = false, options = {}, callback = false) {
 31 | 
 32 |         let {
 33 |             sinceTimestamp,
 34 |             since,
 35 |             fromTimestamp,
 36 |             eventName,
 37 |             blockNumber,
 38 |             size,
 39 |             page,
 40 |             onlyConfirmed,
 41 |             onlyUnconfirmed,
 42 |             previousLastEventFingerprint,
 43 |             previousFingerprint,
 44 |             fingerprint,
 45 |             rawResponse,
 46 |             sort,
 47 |             filters
 48 |         } = Object.assign({
 49 |             sinceTimestamp: 0,
 50 |             eventName: false,
 51 |             blockNumber: false,
 52 |             size: 20,
 53 |             page: 1
 54 |         }, options)
 55 | 
 56 |         if (!callback)
 57 |             return this.injectPromise(this.getEventsByContractAddress, contractAddress, options);
 58 | 
 59 |         fromTimestamp = fromTimestamp || sinceTimestamp || since;
 60 | 
 61 |         if (!this.tronWeb.eventServer)
 62 |             return callback('No event server configured');
 63 | 
 64 |         const routeParams = [];
 65 | 
 66 |         if (!this.tronWeb.isAddress(contractAddress))
 67 |             return callback('Invalid contract address provided');
 68 | 
 69 |         if (eventName && !contractAddress)
 70 |             return callback('Usage of event name filtering requires a contract address');
 71 | 
 72 |         if (typeof fromTimestamp !== 'undefined' && !utils.isInteger(fromTimestamp))
 73 |             return callback('Invalid fromTimestamp provided');
 74 | 
 75 |         if (!utils.isInteger(size))
 76 |             return callback('Invalid size provided');
 77 | 
 78 |         if (size > 200) {
 79 |             console.warn('Defaulting to maximum accepted size: 200');
 80 |             size = 200;
 81 |         }
 82 | 
 83 |         if (!utils.isInteger(page))
 84 |             return callback('Invalid page provided');
 85 | 
 86 |         if (blockNumber && !eventName)
 87 |             return callback('Usage of block number filtering requires an event name');
 88 | 
 89 |         if (contractAddress)
 90 |             routeParams.push(this.tronWeb.address.fromHex(contractAddress));
 91 | 
 92 |         if (eventName)
 93 |             routeParams.push(eventName);
 94 | 
 95 |         if (blockNumber)
 96 |             routeParams.push(blockNumber);
 97 | 
 98 |         const qs = {
 99 |             size,
100 |             page
101 |         }
102 | 
103 |         if (typeof filters === 'object' && Object.keys(filters).length > 0) {
104 |             qs.filters = JSON.stringify(filters);
105 |         }
106 | 
107 |         if (fromTimestamp) {
108 |             qs.fromTimestamp = qs.since = fromTimestamp;
109 |         }
110 | 
111 |         if (onlyConfirmed)
112 |             qs.onlyConfirmed = onlyConfirmed
113 | 
114 |         if (onlyUnconfirmed && !onlyConfirmed)
115 |             qs.onlyUnconfirmed = onlyUnconfirmed
116 | 
117 |         if (sort)
118 |             qs.sort = sort
119 | 
120 |         fingerprint = fingerprint || previousFingerprint || previousLastEventFingerprint
121 |         if (fingerprint)
122 |             qs.fingerprint = fingerprint
123 | 
124 |         return this.tronWeb.eventServer.request(`event/contract/${routeParams.join('/')}?${querystring.stringify(qs)}`).then((data = false) => {
125 |             if (!data)
126 |                 return callback('Unknown error occurred');
127 | 
128 |             if (!utils.isArray(data))
129 |                 return callback(data);
130 | 
131 |             return callback(null,
132 |                 rawResponse === true ? data : data.map(event => utils.mapEvent(event))
133 |             );
134 |         }).catch(err => callback((err.response && err.response.data) || err));
135 |     }
136 | 
137 | 
138 |     getEventsByTransactionID(transactionID = false, options = {}, callback = false) {
139 | 
140 |         if (utils.isFunction(options)) {
141 |             callback = options;
142 |             options = {};
143 |         }
144 | 
145 |         if (!callback)
146 |             return this.injectPromise(this.getEventsByTransactionID, transactionID, options);
147 | 
148 |         if (!this.tronWeb.eventServer)
149 |             return callback('No event server configured');
150 | 
151 |         return this.tronWeb.eventServer.request(`event/transaction/${transactionID}`).then((data = false) => {
152 |             if (!data)
153 |                 return callback('Unknown error occurred');
154 | 
155 |             if (!utils.isArray(data))
156 |                 return callback(data);
157 | 
158 |             return callback(null,
159 |                 options.rawResponse === true ? data : data.map(event => utils.mapEvent(event))
160 |             );
161 |         }).catch(err => callback((err.response && err.response.data) || err));
162 |     }
163 | 
164 | }
165 | 
166 | 


--------------------------------------------------------------------------------
/src/lib/plugin.js:
--------------------------------------------------------------------------------
 1 | import TronWeb from 'index';
 2 | import utils from 'utils';
 3 | import semver from 'semver';
 4 | 
 5 | export default class Plugin {
 6 | 
 7 |     constructor(tronWeb = false, options = {}) {
 8 |         if (!tronWeb || !tronWeb instanceof TronWeb)
 9 |             throw new Error('Expected instance of TronWeb');
10 |         this.tronWeb = tronWeb;
11 |         this.pluginNoOverride = ['register'];
12 |         this.disablePlugins = options.disablePlugins;
13 |     }
14 | 
15 |     register(Plugin, options) {
16 |         let pluginInterface = {
17 |             requires: '0.0.0',
18 |             components: {}
19 |         }
20 |         let result = {
21 |             libs: [],
22 |             plugged: [],
23 |             skipped: []
24 |         }
25 |         if (this.disablePlugins) {
26 |             result.error = 'This instance of TronWeb has plugins disabled.'
27 |             return result;
28 |         }
29 |         const plugin = new Plugin(this.tronWeb)
30 |         if (utils.isFunction(plugin.pluginInterface)) {
31 |             pluginInterface = plugin.pluginInterface(options)
32 |         }
33 |         if (semver.satisfies(TronWeb.version, pluginInterface.requires)) {
34 |             if (pluginInterface.fullClass) {
35 |                 // plug the entire class at the same level of tronWeb.trx
36 |                 let className = plugin.constructor.name
37 |                 let classInstanceName = className.substring(0, 1).toLowerCase() + className.substring(1)
38 |                 if (className !== classInstanceName) {
39 |                     TronWeb[className] = Plugin
40 |                     this.tronWeb[classInstanceName] = plugin
41 |                     result.libs.push(className)
42 |                 }
43 |             } else {
44 |                 // plug methods into a class, like trx
45 |                 for (let component in pluginInterface.components) {
46 |                     if (!this.tronWeb.hasOwnProperty(component)) {
47 |                         continue
48 |                     }
49 |                     let methods = pluginInterface.components[component]
50 |                     let pluginNoOverride = this.tronWeb[component].pluginNoOverride || []
51 |                     for (let method in methods) {
52 |                         if (method === 'constructor' || (this.tronWeb[component][method] &&
53 |                             (pluginNoOverride.includes(method) // blacklisted methods
54 |                                 || /^_/.test(method)) // private methods
55 |                         )) {
56 |                             result.skipped.push(method)
57 |                             continue
58 |                         }
59 |                         this.tronWeb[component][method] = methods[method].bind(this.tronWeb[component])
60 |                         result.plugged.push(method)
61 |                     }
62 |                 }
63 |             }
64 |         } else {
65 |             throw new Error('The plugin is not compatible with this version of TronWeb')
66 |         }
67 |         return result
68 |     }
69 | }
70 | 
71 | 


--------------------------------------------------------------------------------
/src/lib/providers/HttpProvider.js:
--------------------------------------------------------------------------------
 1 | import axios from 'axios';
 2 | import utils from 'utils';
 3 | 
 4 | export default class HttpProvider {
 5 |     constructor(host, timeout = 30000, user = false, password = false, headers = {}, statusPage = '/') {
 6 |         if (!utils.isValidURL(host))
 7 |             throw new Error('Invalid URL provided to HttpProvider');
 8 | 
 9 |         if (isNaN(timeout) || timeout < 0)
10 |             throw new Error('Invalid timeout duration provided');
11 | 
12 |         if (!utils.isObject(headers))
13 |             throw new Error('Invalid headers object provided');
14 | 
15 |         host = host.replace(/\/+$/, '');
16 | 
17 |         this.host = host;
18 |         this.timeout = timeout;
19 |         this.user = user;
20 |         this.password = password;
21 |         this.headers = headers;
22 |         this.statusPage = statusPage;
23 | 
24 |         this.instance = axios.create({
25 |             baseURL: host,
26 |             timeout: timeout,
27 |             headers: headers,
28 |             auth: user && {
29 |                 user,
30 |                 password
31 |             },
32 |         });
33 |     }
34 | 
35 |     setStatusPage(statusPage = '/') {
36 |         this.statusPage = statusPage;
37 |     }
38 | 
39 |     async isConnected(statusPage = this.statusPage) {
40 |         return this.request(statusPage).then(data => {
41 |             return utils.hasProperties(data, 'blockID', 'block_header');
42 |         }).catch(() => false);
43 |     }
44 | 
45 |     request(url, payload = {}, method = 'get') {
46 |         method = method.toLowerCase();
47 | 
48 |         return this.instance.request({
49 |             data: method == 'post' && Object.keys(payload).length ? payload : null,
50 |             params: method == 'get' && payload,
51 |             url,
52 |             method
53 |         }).then(({data}) => data);
54 |     }
55 | };
56 | 


--------------------------------------------------------------------------------
/src/lib/providers/index.js:
--------------------------------------------------------------------------------
1 | import HttpProvider from './HttpProvider';
2 | 
3 | export default {
4 |     HttpProvider
5 | };


--------------------------------------------------------------------------------
/src/paramValidator/index.js:
--------------------------------------------------------------------------------
  1 | import TronWeb from 'index';
  2 | import utils from 'utils';
  3 | 
  4 | export default class Validator {
  5 | 
  6 |     constructor(tronWeb = false) {
  7 |         if (!tronWeb || !tronWeb instanceof TronWeb)
  8 |             throw new Error('Expected instance of TronWeb');
  9 |         this.tronWeb = tronWeb;
 10 |     }
 11 | 
 12 |     invalid(param) {
 13 |         return param.msg || `Invalid ${param.name}${param.type === 'address' ? ' address' : ''} provided`;
 14 |     }
 15 | 
 16 |     notPositive(param) {
 17 |         return `${param.name} must be a positive integer`;
 18 |     }
 19 | 
 20 |     notEqual(param) {
 21 |         return param.msg || `${param.names[0]} can not be equal to ${param.names[1]}`;
 22 |     }
 23 | 
 24 |     notValid(params = [], callback = new Function) {
 25 | 
 26 |         let normalized = {};
 27 |         let no = false;
 28 |         for (const param of params) {
 29 |             let {
 30 |                 name,
 31 |                 names,
 32 |                 value,
 33 |                 type,
 34 |                 gt,
 35 |                 lt,
 36 |                 gte,
 37 |                 lte,
 38 |                 se,
 39 |                 optional
 40 |             } = param;
 41 |             if (optional && (
 42 |                 !utils.isNotNullOrUndefined(value)
 43 |                 || (type !== 'boolean' && value === false)))
 44 |                 continue;
 45 |             normalized[param.name] = param.value;
 46 |             switch (type) {
 47 | 
 48 |                 case 'address':
 49 |                     if (!this.tronWeb.isAddress(value)) {
 50 |                         no = true;
 51 |                     } else {
 52 |                         normalized[name] = this.tronWeb.address.toHex(value);
 53 |                     }
 54 |                     break;
 55 | 
 56 |                 case 'integer':
 57 |                     if (!utils.isInteger(value) ||
 58 |                         (typeof gt === 'number' && value <= param.gt) ||
 59 |                         (typeof lt === 'number' && value >= param.lt) ||
 60 |                         (typeof gte === 'number' && value < param.gte) ||
 61 |                         (typeof lte === 'number' && value > param.lte)) {
 62 |                         no = true;
 63 |                     }
 64 |                     break;
 65 | 
 66 |                 case 'positive-integer':
 67 |                     if (!utils.isInteger(value) || value <= 0) {
 68 |                         callback(this.notPositive(param));
 69 |                         return;
 70 |                     }
 71 |                     break;
 72 | 
 73 |                 case 'tokenId':
 74 |                     if (!utils.isString(value) || !value.length) {
 75 |                         no = true;
 76 |                     }
 77 |                     break;
 78 | 
 79 |                 case 'notEmptyObject':
 80 |                     if (!utils.isObject(value) || !Object.keys(value).length) {
 81 |                         no = true;
 82 |                     }
 83 |                     break;
 84 | 
 85 |                 case 'notEqual':
 86 |                     if (normalized[names[0]] === normalized[names[1]]) {
 87 |                         callback(this.notEqual(param));
 88 |                         return true;
 89 |                     }
 90 |                     break;
 91 | 
 92 |                 case 'resource':
 93 |                     if (!['BANDWIDTH', 'ENERGY'].includes(value)) {
 94 |                         no = true;
 95 |                     }
 96 |                     break;
 97 | 
 98 |                 case 'url':
 99 |                     if (!utils.isValidURL(value)) {
100 |                         no = true;
101 |                     }
102 |                     break;
103 | 
104 |                 case 'hex':
105 |                     if (!utils.isHex(value)) {
106 |                         no = true;
107 |                     }
108 |                     break;
109 | 
110 |                 case 'array':
111 |                     if (!Array.isArray(value)) {
112 |                         no = true;
113 |                     }
114 |                     break;
115 | 
116 |                 case 'not-empty-string':
117 |                     if (!utils.isString(value) || !value.length) {
118 |                         no = true;
119 |                     }
120 |                     break;
121 | 
122 |                 case 'boolean':
123 |                     if (!utils.isBoolean(value)) {
124 |                         no = true;
125 |                     }
126 |                     break;
127 |                 case 'string':
128 |                     if (!utils.isString(value) ||
129 |                         (typeof gt === 'number' && value.length <= param.gt) ||
130 |                         (typeof lt === 'number' && value.length >= param.lt) ||
131 |                         (typeof gte === 'number' && value.length < param.gte) ||
132 |                         (typeof lte === 'number' && value.length > param.lte)) {
133 |                         no = true;
134 |                     }
135 |                     break;
136 |             }
137 |             if (no) {
138 |                 callback(this.invalid(param));
139 |                 return true;
140 |             }
141 |         }
142 |         return false;
143 |     }
144 | }
145 | 
146 | 


--------------------------------------------------------------------------------
/src/utils/abi.js:
--------------------------------------------------------------------------------
 1 | import {AbiCoder} from './ethersUtils';
 2 | import TronWeb from 'index';
 3 | import {ADDRESS_PREFIX, ADDRESS_PREFIX_REGEX} from 'utils/address';
 4 | 
 5 | const abiCoder = new AbiCoder();
 6 | 
 7 | export function decodeParams(names, types, output, ignoreMethodHash) {
 8 | 
 9 |     if (!output || typeof output === 'boolean') {
10 |         ignoreMethodHash = output;
11 |         output = types;
12 |         types = names;
13 |         names = [];
14 |     }
15 | 
16 |     if (ignoreMethodHash && output.replace(/^0x/, '').length % 64 === 8)
17 |         output = '0x' + output.replace(/^0x/, '').substring(8);
18 | 
19 |     if (output.replace(/^0x/, '').length % 64)
20 |         throw new Error('The encoded string is not valid. Its length must be a multiple of 64.');
21 | 
22 |     // workaround for unsupported trcToken type
23 |     types = types.map(type => {
24 |         if (/trcToken/.test(type)) {
25 |             type = type.replace(/trcToken/, 'uint256')
26 |         }
27 |         return type
28 |     })
29 | 
30 |     return abiCoder.decode(types, output).reduce((obj, arg, index) => {
31 |         if (types[index] == 'address')
32 |             arg = ADDRESS_PREFIX + arg.substr(2).toLowerCase();
33 | 
34 |         if (names.length)
35 |             obj[names[index]] = arg;
36 |         else obj.push(arg);
37 | 
38 |         return obj;
39 |     }, names.length ? {} : []);
40 | }
41 | 
42 | export function encodeParams(types, values) {
43 | 
44 |     for (let i = 0; i < types.length; i++) {
45 |         if (types[i] === 'address') {
46 |             values[i] = TronWeb.address.toHex(values[i]).replace(ADDRESS_PREFIX_REGEX, '0x');
47 |         }
48 |     }
49 | 
50 |     return abiCoder.encode(types, values);
51 | }
52 | 


--------------------------------------------------------------------------------
/src/utils/accounts.js:
--------------------------------------------------------------------------------
 1 | import {byteArray2hexStr} from './bytes';
 2 | import {
 3 |     getBase58CheckAddress,
 4 |     genPriKey,
 5 |     getAddressFromPriKey,
 6 |     getPubKeyFromPriKey
 7 | } from './crypto';
 8 | 
 9 | export function generateAccount() {
10 |     const priKeyBytes = genPriKey();
11 |     const pubKeyBytes = getPubKeyFromPriKey(priKeyBytes);
12 |     const addressBytes = getAddressFromPriKey(priKeyBytes);
13 | 
14 |     const privateKey = byteArray2hexStr(priKeyBytes);
15 |     const publicKey = byteArray2hexStr(pubKeyBytes);
16 | 
17 |     return {
18 |         privateKey,
19 |         publicKey,
20 |         address: {
21 |             base58: getBase58CheckAddress(addressBytes),
22 |             hex: byteArray2hexStr(addressBytes)
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/utils/address.js:
--------------------------------------------------------------------------------
1 | export const ADDRESS_SIZE = 34;
2 | export const ADDRESS_PREFIX = "41";
3 | export const ADDRESS_PREFIX_BYTE = 0x41;
4 | export const ADDRESS_PREFIX_REGEX = /^(41)/;
5 | 


--------------------------------------------------------------------------------
/src/utils/base58.js:
--------------------------------------------------------------------------------
 1 | const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 2 | const ALPHABET_MAP = {};
 3 | 
 4 | for (let i = 0; i < ALPHABET.length; i++)
 5 |     ALPHABET_MAP[ALPHABET.charAt(i)] = i;
 6 | 
 7 | const BASE = 58;
 8 | 
 9 | export function encode58(buffer) {
10 |     if (buffer.length === 0)
11 |         return '';
12 | 
13 |     let i;
14 |     let j;
15 | 
16 |     const digits = [0];
17 | 
18 |     for (i = 0; i < buffer.length; i++) {
19 |         for (j = 0; j < digits.length; j++)
20 |             digits[j] <<= 8;
21 | 
22 |         digits[0] += buffer[i];
23 |         let carry = 0;
24 | 
25 |         for (j = 0; j < digits.length; ++j) {
26 |             digits[j] += carry;
27 |             carry = (digits[j] / BASE) | 0;
28 |             digits[j] %= BASE
29 |         }
30 | 
31 |         while (carry) {
32 |             digits.push(carry % BASE);
33 |             carry = (carry / BASE) | 0
34 |         }
35 |     }
36 | 
37 |     for (i = 0; buffer[i] === 0 && i < buffer.length - 1; i++)
38 |         digits.push(0);
39 | 
40 |     return digits.reverse().map(digit => ALPHABET[digit]).join('');
41 | }
42 | 
43 | export function decode58(string) {
44 |     if (string.length === 0)
45 |         return [];
46 | 
47 |     let i;
48 |     let j;
49 | 
50 |     const bytes = [0];
51 | 
52 |     for (i = 0; i < string.length; i++) {
53 |         const c = string[i];
54 | 
55 |         if (!(c in ALPHABET_MAP))
56 |             throw new Error('Non-base58 character');
57 | 
58 |         for (j = 0; j < bytes.length; j++)
59 |             bytes[j] *= BASE;
60 | 
61 |         bytes[0] += ALPHABET_MAP[c];
62 |         let carry = 0;
63 | 
64 |         for (j = 0; j < bytes.length; ++j) {
65 |             bytes[j] += carry;
66 |             carry = bytes[j] >> 8;
67 |             bytes[j] &= 0xff;
68 |         }
69 | 
70 |         while (carry) {
71 |             bytes.push(carry & 0xff);
72 |             carry >>= 8;
73 |         }
74 |     }
75 | 
76 |     for (i = 0; string[i] === '1' && i < string.length - 1; i++)
77 |         bytes.push(0);
78 | 
79 |     return bytes.reverse();
80 | }
81 | 


--------------------------------------------------------------------------------
/src/utils/base64.js:
--------------------------------------------------------------------------------
  1 | export function Base64() {
  2 |     this._keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  3 | 
  4 |     this.encode = input => {
  5 |         let output = "";
  6 |         let chr1;
  7 |         let chr2;
  8 |         let chr3;
  9 |         let enc1;
 10 |         let enc2;
 11 |         let enc3;
 12 |         let enc4;
 13 |         let i = 0;
 14 | 
 15 |         while (i < input.length) {
 16 |             chr1 = input.charCodeAt(i++);
 17 |             chr2 = input.charCodeAt(i++);
 18 |             chr3 = input.charCodeAt(i++);
 19 | 
 20 |             enc1 = chr1 >> 2;
 21 |             enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
 22 |             enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
 23 |             enc4 = chr3 & 63;
 24 | 
 25 |             if (isNaN(chr2))
 26 |                 enc3 = enc4 = 64;
 27 |             else if (isNaN(chr3))
 28 |                 enc4 = 64;
 29 | 
 30 |             output = output +
 31 |                 this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
 32 |                 this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
 33 |         }
 34 | 
 35 |         return output;
 36 |     }
 37 | 
 38 |     this.encodeIgnoreUtf8 = inputBytes => {
 39 |         let output = "";
 40 |         let chr1;
 41 |         let chr2;
 42 |         let chr3;
 43 |         let enc1;
 44 |         let enc2;
 45 |         let enc3;
 46 |         let enc4;
 47 |         let i = 0;
 48 | 
 49 |         while (i < inputBytes.length) {
 50 |             chr1 = inputBytes[i++];
 51 |             chr2 = inputBytes[i++];
 52 |             chr3 = inputBytes[i++];
 53 | 
 54 |             enc1 = chr1 >> 2;
 55 |             enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
 56 |             enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
 57 |             enc4 = chr3 & 63;
 58 | 
 59 |             if (isNaN(chr2))
 60 |                 enc3 = enc4 = 64;
 61 |             else if (isNaN(chr3))
 62 |                 enc4 = 64;
 63 | 
 64 |             output = output +
 65 |                 this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
 66 |                 this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
 67 |         }
 68 | 
 69 |         return output;
 70 |     }
 71 | 
 72 |     this.decode = input => {
 73 |         let output = "";
 74 |         let chr1;
 75 |         let chr2;
 76 |         let chr3;
 77 |         let enc1;
 78 |         let enc2;
 79 |         let enc3;
 80 |         let enc4;
 81 |         let i = 0;
 82 | 
 83 |         input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
 84 | 
 85 |         while (i < input.length) {
 86 |             enc1 = this._keyStr.indexOf(input.charAt(i++));
 87 |             enc2 = this._keyStr.indexOf(input.charAt(i++));
 88 |             enc3 = this._keyStr.indexOf(input.charAt(i++));
 89 |             enc4 = this._keyStr.indexOf(input.charAt(i++));
 90 | 
 91 |             chr1 = (enc1 << 2) | (enc2 >> 4);
 92 |             chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
 93 |             chr3 = ((enc3 & 3) << 6) | enc4;
 94 | 
 95 |             output = output + String.fromCharCode(chr1);
 96 | 
 97 |             if (enc3 != 64)
 98 |                 output = output + String.fromCharCode(chr2);
 99 | 
100 |             if (enc4 != 64)
101 |                 output = output + String.fromCharCode(chr3);
102 |         }
103 | 
104 |         return this._utf8_decode(output);
105 |     }
106 | 
107 |     this.decodeToByteArray = input => {
108 |         let output = "";
109 |         let chr1;
110 |         let chr2;
111 |         let chr3;
112 |         let enc1;
113 |         let enc2;
114 |         let enc3;
115 |         let enc4;
116 |         let i = 0;
117 | 
118 |         input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
119 | 
120 |         while (i < input.length) {
121 |             enc1 = this._keyStr.indexOf(input.charAt(i++));
122 |             enc2 = this._keyStr.indexOf(input.charAt(i++));
123 |             enc3 = this._keyStr.indexOf(input.charAt(i++));
124 |             enc4 = this._keyStr.indexOf(input.charAt(i++));
125 | 
126 |             chr1 = (enc1 << 2) | (enc2 >> 4);
127 |             chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
128 |             chr3 = ((enc3 & 3) << 6) | enc4;
129 | 
130 |             output = output + String.fromCharCode(chr1);
131 | 
132 |             if (enc3 != 64)
133 |                 output = output + String.fromCharCode(chr2);
134 | 
135 |             if (enc4 != 64)
136 |                 output = output + String.fromCharCode(chr3);
137 |         }
138 | 
139 |         return this._out2ByteArray(output);
140 |     }
141 | 
142 |     this._out2ByteArray = utftext => {
143 |         const byteArray = new Array(utftext.length);
144 | 
145 |         let i = 0;
146 |         let c = 0;
147 | 
148 |         while (i < utftext.length) {
149 |             c = utftext.charCodeAt(i);
150 |             byteArray[i] = c;
151 |             i++;
152 |         }
153 | 
154 |         return byteArray;
155 |     }
156 | 
157 |     this._utf8_encode = string => {
158 |         string = string.replace(/\r\n/g, "\n");
159 |         let utftext = "";
160 | 
161 |         for (let n = 0; n < string.length; n++) {
162 |             const c = string.charCodeAt(n);
163 | 
164 |             if (c < 128) {
165 |                 utftext += String.fromCharCode(c);
166 |             } else if ((c > 127) && (c < 2048)) {
167 |                 utftext += String.fromCharCode((c >> 6) | 192);
168 |                 utftext += String.fromCharCode((c & 63) | 128);
169 |             } else {
170 |                 utftext += String.fromCharCode((c >> 12) | 224);
171 |                 utftext += String.fromCharCode(((c >> 6) & 63) | 128);
172 |                 utftext += String.fromCharCode((c & 63) | 128);
173 |             }
174 |         }
175 | 
176 |         return utftext;
177 |     }
178 | 
179 |     this._utf8_decode = utftext => {
180 |         let string = "";
181 |         let i = 0;
182 |         let c = 0;
183 |         let c2 = 0;
184 |         let c3 = 0;
185 | 
186 |         while (i < utftext.length) {
187 |             c = utftext.charCodeAt(i);
188 | 
189 |             if (c < 128) {
190 |                 string += String.fromCharCode(c);
191 |                 i++;
192 |             } else if ((c > 191) && (c < 224)) {
193 |                 c2 = utftext.charCodeAt(i + 1);
194 |                 string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
195 |                 i += 2;
196 |             } else {
197 |                 c2 = utftext.charCodeAt(i + 1);
198 |                 c3 = utftext.charCodeAt(i + 2);
199 | 
200 |                 string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
201 | 
202 |                 i += 3;
203 |             }
204 |         }
205 | 
206 |         return string;
207 |     }
208 | }
209 | 


--------------------------------------------------------------------------------
/src/utils/bytes.js:
--------------------------------------------------------------------------------
 1 | import {Base64} from './base64';
 2 | 
 3 | export function byte2hexStr(byte) {
 4 |     if (typeof byte !== 'number')
 5 |         throw new Error('Input must be a number');
 6 | 
 7 |     if (byte < 0 || byte > 255)
 8 |         throw new Error('Input must be a byte');
 9 | 
10 |     const hexByteMap = '0123456789ABCDEF';
11 | 
12 |     let str = '';
13 |     str += hexByteMap.charAt(byte >> 4);
14 |     str += hexByteMap.charAt(byte & 0x0f);
15 | 
16 |     return str;
17 | }
18 | 
19 | export function bytesToString(arr) {
20 |     if (typeof arr === 'string')
21 |         return arr;
22 | 
23 |     let str = '';
24 | 
25 |     for (let i = 0; i < arr.length; i++) {
26 |         const one = arr[i].toString(2);
27 |         const v = one.match(/^1+?(?=0)/);
28 | 
29 |         if (v && one.length === 8) {
30 |             const bytesLength = v[0].length;
31 |             let store = arr[i].toString(2).slice(7 - bytesLength);
32 | 
33 |             for (let st = 1; st < bytesLength; st++)
34 |                 store += arr[st + i].toString(2).slice(2);
35 | 
36 |             str += String.fromCharCode(parseInt(store, 2));
37 |             i += bytesLength - 1;
38 |         } else {
39 |             str += String.fromCharCode(arr[i]);
40 |         }
41 |     }
42 | 
43 |     return str;
44 | }
45 | 
46 | export function hextoString(hex) {
47 |     const arr = hex.replace(/^0x/, '').split('');
48 |     let out = '';
49 | 
50 |     for (let i = 0; i < arr.length / 2; i++) {
51 |         let tmp = `0x${arr[i * 2]}${arr[i * 2 + 1]}`;
52 |         out += String.fromCharCode(tmp);
53 |     }
54 | 
55 |     return out;
56 | }
57 | 
58 | export function byteArray2hexStr(byteArray) {
59 |     let str = '';
60 | 
61 |     for (let i = 0; i < (byteArray.length); i++)
62 |         str += byte2hexStr(byteArray[i]);
63 | 
64 |     return str;
65 | }
66 | 
67 | export function base64DecodeFromString(string64) {
68 |     return new Base64().decodeToByteArray(string64);
69 | }
70 | 
71 | export function base64EncodeToString(bytes) {
72 |     const b = new Base64();
73 |     const string64 = b.encodeIgnoreUtf8(bytes);
74 | 
75 |     return string64
76 | }
77 | 
78 | 


--------------------------------------------------------------------------------
/src/utils/code.js:
--------------------------------------------------------------------------------
  1 | import {
  2 |     byte2hexStr,
  3 |     bytesToString,
  4 |     hextoString,
  5 |     byteArray2hexStr,
  6 |     base64DecodeFromString,
  7 |     base64EncodeToString
  8 | } from './bytes';
  9 | 
 10 | export function bin2String(array) {
 11 |     // TODO Do we need this alias?
 12 |     return bytesToString(array);
 13 | }
 14 | 
 15 | export function arrayEquals(array1, array2, strict) {
 16 |     if (array1.length != array2.length)
 17 |         return false;
 18 | 
 19 |     let i;
 20 | 
 21 |     for (i = 0; i < array1.length; i++) {
 22 |         if (strict) {
 23 |             if (array1[i] != array2[i])
 24 |                 return false;
 25 |         } else if (JSON.stringify(array1[i]) != JSON.stringify(array2[i]))
 26 |             return false;
 27 |     }
 28 | 
 29 |     return true;
 30 | }
 31 | 
 32 | export function stringToBytes(str) {
 33 | 
 34 |     if (typeof str !== 'string')
 35 |         throw new Error('The passed string is not a string')
 36 | 
 37 |     const bytes = new Array();
 38 |     let len;
 39 |     let c;
 40 | 
 41 |     len = str.length;
 42 | 
 43 |     for (let i = 0; i < len; i++) {
 44 |         c = str.charCodeAt(i);
 45 | 
 46 |         if (c >= 0x010000 && c <= 0x10FFFF) {
 47 |             bytes.push(((c >> 18) & 0x07) | 0xF0);
 48 |             bytes.push(((c >> 12) & 0x3F) | 0x80);
 49 |             bytes.push(((c >> 6) & 0x3F) | 0x80);
 50 |             bytes.push((c & 0x3F) | 0x80);
 51 |         } else if (c >= 0x000800 && c <= 0x00FFFF) {
 52 |             bytes.push(((c >> 12) & 0x0F) | 0xE0);
 53 |             bytes.push(((c >> 6) & 0x3F) | 0x80);
 54 |             bytes.push((c & 0x3F) | 0x80);
 55 |         } else if (c >= 0x000080 && c <= 0x0007FF) {
 56 |             bytes.push(((c >> 6) & 0x1F) | 0xC0);
 57 |             bytes.push((c & 0x3F) | 0x80);
 58 |         } else bytes.push(c & 0xFF);
 59 |     }
 60 | 
 61 |     return bytes;
 62 | }
 63 | 
 64 | export {byte2hexStr, bytesToString, hextoString, byteArray2hexStr, base64DecodeFromString, base64EncodeToString}
 65 | 
 66 | export function hexChar2byte(c) {
 67 |     let d;
 68 | 
 69 |     if (c >= 'A' && c <= 'F')
 70 |         d = c.charCodeAt(0) - 'A'.charCodeAt(0) + 10;
 71 |     else if (c >= 'a' && c <= 'f')
 72 |         d = c.charCodeAt(0) - 'a'.charCodeAt(0) + 10;
 73 |     else if (c >= '0' && c <= '9')
 74 |         d = c.charCodeAt(0) - '0'.charCodeAt(0);
 75 | 
 76 |     if (typeof d === 'number')
 77 |         return d;
 78 |     else
 79 |         throw new Error('The passed hex char is not a valid hex char');
 80 | }
 81 | 
 82 | export function isHexChar(c) {
 83 |     if ((c >= 'A' && c <= 'F') ||
 84 |         (c >= 'a' && c <= 'f') ||
 85 |         (c >= '0' && c <= '9')) {
 86 |         return 1;
 87 |     }
 88 | 
 89 |     return 0;
 90 | }
 91 | 
 92 | export function hexStr2byteArray(str) {
 93 |     if (typeof str !== 'string')
 94 |         throw new Error('The passed string is not a string')
 95 | 
 96 |     const byteArray = Array();
 97 |     let d = 0;
 98 |     let j = 0;
 99 |     let k = 0;
100 | 
101 |     for (let i = 0; i < str.length; i++) {
102 |         const c = str.charAt(i);
103 | 
104 |         if (isHexChar(c)) {
105 |             d <<= 4;
106 |             d += hexChar2byte(c);
107 |             j++;
108 | 
109 |             if (0 === (j % 2)) {
110 |                 byteArray[k++] = d;
111 |                 d = 0;
112 |             }
113 |         } else
114 |             throw new Error('The passed hex char is not a valid hex string')
115 |     }
116 | 
117 |     return byteArray;
118 | }
119 | 
120 | //yyyy-MM-DD HH-mm-ss
121 | export function strToDate(str) {
122 | 
123 |     if (!/^\d{4}-\d{2}-\d{2}( \d{2}-\d{2}-\d{2}|)/.test(str))
124 |         throw new Error('The passed date string is not valid')
125 | 
126 |     const tempStrs = str.split(" ");
127 |     const dateStrs = tempStrs[0].split("-");
128 |     const year = parseInt(dateStrs[0], 10);
129 |     const month = parseInt(dateStrs[1], 10) - 1;
130 |     const day = parseInt(dateStrs[2], 10);
131 | 
132 |     if (tempStrs.length > 1) {
133 |         const timeStrs = tempStrs[1].split("-");
134 |         const hour = parseInt(timeStrs[0], 10);
135 |         const minute = parseInt(timeStrs[1], 10);
136 |         const second = parseInt(timeStrs[2], 10);
137 | 
138 |         return new Date(year, month, day, hour, minute, second);
139 |     }
140 | 
141 |     return new Date(year, month, day);
142 | }
143 | 
144 | export function isNumber(c) {
145 |     if (c >= '0' && c <= '9')
146 |         return 1;
147 | 
148 |     return 0;
149 | }
150 | 
151 | //return 1: address  --- 20Bytes HexString
152 | //return 2: blockNumber ------ Decimal number
153 | //return 3: assetName ------ String
154 | //return other: error
155 | export function getStringType(str) {
156 |     if (null == str)
157 |         return -1;
158 | 
159 |     if (typeof (str) != 'string')
160 |         return -1;
161 | 
162 |     if (str.length == 0 || str == "")
163 |         return -1;
164 | 
165 |     let i = 0;
166 | 
167 |     // TODO Should we return 1 if someone passes a full, 42-chars long address?
168 |     // if (str.length == 42 && /^41/.test(str)) {
169 |     //     for (; i < 40; i++) {
170 |     //         var c = str.charAt(i+2);
171 |     //
172 |     //         if (!isHexChar(c))
173 |     //             break;
174 |     //     }
175 |     // } else
176 |     if (str.length == 40) {
177 |         for (; i < 40; i++) {
178 |             var c = str.charAt(i);
179 | 
180 |             if (!isHexChar(c))
181 |                 break;
182 |         }
183 |     }
184 | 
185 |     if (i == 40)
186 |         return 1; //40 Hex, Address
187 | 
188 |     for (i = 0; i < str.length; i++) {
189 |         var c = str.charAt(i);
190 | 
191 |         if (!isNumber(c))
192 |             break;
193 |     }
194 | 
195 |     if (i == str.length)
196 |         return 2; // All Decimal number, BlockNumber
197 | 
198 |     for (i = 0; i < str.length; i++) {
199 |         var c = str.charAt(i);
200 | 
201 |         if (c > ' ')
202 |             return 3; // At least one visible character
203 |     }
204 | 
205 |     return -1;
206 | }
207 | 


--------------------------------------------------------------------------------
/src/utils/crypto.js:
--------------------------------------------------------------------------------
  1 | import {ADDRESS_PREFIX, ADDRESS_PREFIX_BYTE, ADDRESS_SIZE} from './address';
  2 | import {base64EncodeToString} from './code';
  3 | import {base64DecodeFromString, hexStr2byteArray} from './code';
  4 | import {encode58, decode58} from './base58';
  5 | import {byte2hexStr, byteArray2hexStr} from './bytes';
  6 | import {ec as EC} from 'elliptic';
  7 | import {keccak256, sha256} from './ethersUtils';
  8 | 
  9 | export function getBase58CheckAddress(addressBytes) {
 10 |     const hash0 = SHA256(addressBytes);
 11 |     const hash1 = SHA256(hash0);
 12 | 
 13 |     let checkSum = hash1.slice(0, 4);
 14 |     checkSum = addressBytes.concat(checkSum);
 15 | 
 16 |     return encode58(checkSum);
 17 | }
 18 | 
 19 | export function decodeBase58Address(base58Sting) {
 20 |     if (typeof (base58Sting) != 'string')
 21 |         return false;
 22 | 
 23 |     if (base58Sting.length <= 4)
 24 |         return false;
 25 | 
 26 |     let address = decode58(base58Sting);
 27 | 
 28 |     if (base58Sting.length <= 4)
 29 |         return false;
 30 | 
 31 |     const len = address.length;
 32 |     const offset = len - 4;
 33 |     const checkSum = address.slice(offset);
 34 | 
 35 |     address = address.slice(0, offset);
 36 | 
 37 |     const hash0 = SHA256(address);
 38 |     const hash1 = SHA256(hash0);
 39 |     const checkSum1 = hash1.slice(0, 4);
 40 | 
 41 |     if (checkSum[0] == checkSum1[0] && checkSum[1] == checkSum1[1] && checkSum[2] ==
 42 |         checkSum1[2] && checkSum[3] == checkSum1[3]
 43 |     ) {
 44 |         return address;
 45 |     }
 46 | 
 47 |     throw new Error('Invalid address provided');
 48 | }
 49 | 
 50 | export function signTransaction(priKeyBytes, transaction) {
 51 |     if (typeof priKeyBytes === 'string')
 52 |         priKeyBytes = hexStr2byteArray(priKeyBytes);
 53 | 
 54 |     const txID = transaction.txID;
 55 |     const signature = ECKeySign(hexStr2byteArray(txID), priKeyBytes);
 56 | 
 57 |     if (Array.isArray(transaction.signature)) {
 58 |         if (!transaction.signature.includes(signature))
 59 |             transaction.signature.push(signature);
 60 |     } else
 61 |         transaction.signature = [signature];
 62 |     return transaction;
 63 | }
 64 | 
 65 | export function arrayToBase64String(a) {
 66 |     return btoa(String.fromCharCode(...a));
 67 | }
 68 | 
 69 | export function signBytes(privateKey, contents) {
 70 |     if (typeof privateKey === 'string')
 71 |         privateKey = hexStr2byteArray(privateKey);
 72 | 
 73 |     const hashBytes = SHA256(contents);
 74 |     const signBytes = ECKeySign(hashBytes, privateKey);
 75 | 
 76 |     return signBytes;
 77 | }
 78 | 
 79 | export function getRowBytesFromTransactionBase64(base64Data) {
 80 |     const bytesDecode = base64DecodeFromString(base64Data);
 81 |     const transaction = proto.protocol.Transaction.deserializeBinary(bytesDecode);
 82 |     const raw = transaction.getRawData();
 83 | 
 84 |     return raw.serializeBinary();
 85 | }
 86 | 
 87 | export function genPriKey() {
 88 |     const ec = new EC('secp256k1');
 89 |     const key = ec.genKeyPair();
 90 |     const priKey = key.getPrivate();
 91 | 
 92 |     let priKeyHex = priKey.toString('hex');
 93 | 
 94 |     while (priKeyHex.length < 64) {
 95 |         priKeyHex = `0${priKeyHex}`;
 96 |     }
 97 | 
 98 |     return hexStr2byteArray(priKeyHex);
 99 | }
100 | 
101 | export function computeAddress(pubBytes) {
102 |     if (pubBytes.length === 65)
103 |         pubBytes = pubBytes.slice(1);
104 | 
105 |     const hash = keccak256(pubBytes).toString().substring(2);
106 |     const addressHex = ADDRESS_PREFIX + hash.substring(24);
107 | 
108 |     return hexStr2byteArray(addressHex);
109 | }
110 | 
111 | export function getAddressFromPriKey(priKeyBytes) {
112 |     let pubBytes = getPubKeyFromPriKey(priKeyBytes);
113 |     return computeAddress(pubBytes);
114 | }
115 | 
116 | export function decode58Check(addressStr) {
117 |     const decodeCheck = decode58(addressStr);
118 | 
119 |     if (decodeCheck.length <= 4)
120 |         return false;
121 | 
122 |     const decodeData = decodeCheck.slice(0, decodeCheck.length - 4);
123 |     const hash0 = SHA256(decodeData);
124 |     const hash1 = SHA256(hash0);
125 | 
126 |     if (hash1[0] === decodeCheck[decodeData.length] &&
127 |         hash1[1] === decodeCheck[decodeData.length + 1] &&
128 |         hash1[2] === decodeCheck[decodeData.length + 2] &&
129 |         hash1[3] === decodeCheck[decodeData.length + 3]) {
130 |         return decodeData;
131 |     }
132 | 
133 |     return false;
134 | }
135 | 
136 | export function isAddressValid(base58Str) {
137 |     if (typeof (base58Str) !== 'string')
138 |         return false;
139 | 
140 |     if (base58Str.length !== ADDRESS_SIZE)
141 |         return false;
142 | 
143 |     let address = decode58(base58Str);
144 | 
145 |     if (address.length !== 25)
146 |         return false;
147 | 
148 |     if (address[0] !== ADDRESS_PREFIX_BYTE)
149 |         return false;
150 | 
151 |     const checkSum = address.slice(21);
152 |     address = address.slice(0, 21);
153 | 
154 |     const hash0 = SHA256(address);
155 |     const hash1 = SHA256(hash0);
156 |     const checkSum1 = hash1.slice(0, 4);
157 | 
158 |     if (checkSum[0] == checkSum1[0] && checkSum[1] == checkSum1[1] && checkSum[2] ==
159 |         checkSum1[2] && checkSum[3] == checkSum1[3]
160 |     ) {
161 |         return true
162 |     }
163 | 
164 |     return false;
165 | }
166 | 
167 | export function getBase58CheckAddressFromPriKeyBase64String(priKeyBase64String) {
168 |     const priKeyBytes = base64DecodeFromString(priKeyBase64String);
169 |     const pubBytes = getPubKeyFromPriKey(priKeyBytes);
170 |     const addressBytes = computeAddress(pubBytes);
171 | 
172 |     return getBase58CheckAddress(addressBytes);
173 | }
174 | 
175 | export function getHexStrAddressFromPriKeyBase64String(priKeyBase64String) {
176 |     const priKeyBytes = base64DecodeFromString(priKeyBase64String);
177 |     const pubBytes = getPubKeyFromPriKey(priKeyBytes);
178 |     const addressBytes = computeAddress(pubBytes);
179 |     const addressHex = byteArray2hexStr(addressBytes);
180 | 
181 |     return addressHex;
182 | }
183 | 
184 | export function getAddressFromPriKeyBase64String(priKeyBase64String) {
185 |     const priKeyBytes = base64DecodeFromString(priKeyBase64String);
186 |     const pubBytes = getPubKeyFromPriKey(priKeyBytes);
187 |     const addressBytes = computeAddress(pubBytes);
188 |     const addressBase64 = base64EncodeToString(addressBytes);
189 | 
190 |     return addressBase64;
191 | }
192 | 
193 | export function getPubKeyFromPriKey(priKeyBytes) {
194 |     const ec = new EC('secp256k1');
195 |     const key = ec.keyFromPrivate(priKeyBytes, 'bytes');
196 |     const pubkey = key.getPublic();
197 |     const x = pubkey.x;
198 |     const y = pubkey.y;
199 | 
200 |     let xHex = x.toString('hex');
201 | 
202 |     while (xHex.length < 64) {
203 |         xHex = `0${xHex}`;
204 |     }
205 | 
206 |     let yHex = y.toString('hex');
207 | 
208 |     while (yHex.length < 64) {
209 |         yHex = `0${yHex}`;
210 |     }
211 | 
212 |     const pubkeyHex = `04${xHex}${yHex}`;
213 |     const pubkeyBytes = hexStr2byteArray(pubkeyHex);
214 | 
215 |     return pubkeyBytes;
216 | }
217 | 
218 | export function ECKeySign(hashBytes, priKeyBytes) {
219 |     const ec = new EC('secp256k1');
220 |     const key = ec.keyFromPrivate(priKeyBytes, 'bytes');
221 |     const signature = key.sign(hashBytes);
222 |     const r = signature.r;
223 |     const s = signature.s;
224 |     const id = signature.recoveryParam;
225 | 
226 |     let rHex = r.toString('hex');
227 | 
228 |     while (rHex.length < 64) {
229 |         rHex = `0${rHex}`;
230 |     }
231 | 
232 |     let sHex = s.toString('hex');
233 | 
234 |     while (sHex.length < 64) {
235 |         sHex = `0${sHex}`;
236 |     }
237 | 
238 |     const idHex = byte2hexStr(id);
239 |     const signHex = rHex + sHex + idHex;
240 | 
241 |     return signHex;
242 | }
243 | 
244 | export function SHA256(msgBytes) {
245 |     const msgHex = byteArray2hexStr(msgBytes);
246 |     const hashHex = sha256('0x' + msgHex).replace(/^0x/, '')
247 |     return hexStr2byteArray(hashHex);
248 | }
249 | 
250 | export function passwordToAddress(password) {
251 |     const com_priKeyBytes = base64DecodeFromString(password);
252 |     const com_addressBytes = getAddressFromPriKey(com_priKeyBytes);
253 | 
254 |     return getBase58CheckAddress(com_addressBytes);
255 | }
256 | 
257 | export function pkToAddress(privateKey) {
258 |     const com_priKeyBytes = hexStr2byteArray(privateKey);
259 |     const com_addressBytes = getAddressFromPriKey(com_priKeyBytes);
260 | 
261 |     return getBase58CheckAddress(com_addressBytes);
262 | }
263 | 


--------------------------------------------------------------------------------
/src/utils/ethersUtils.js:
--------------------------------------------------------------------------------
 1 | 
 2 | import {utils} from 'ethers';
 3 | 
 4 | const keccak256 = utils.keccak256;
 5 | const sha256 = utils.sha256;
 6 | const toUtf8Bytes = utils.toUtf8Bytes;
 7 | const recoverAddress = utils.recoverAddress;
 8 | const SigningKey = utils.SigningKey;
 9 | const AbiCoder = utils.AbiCoder;
10 | 
11 | export {
12 |     keccak256,
13 |     sha256,
14 |     toUtf8Bytes,
15 |     recoverAddress,
16 |     SigningKey,
17 |     AbiCoder
18 | }
19 | 


--------------------------------------------------------------------------------
/src/utils/help.js:
--------------------------------------------------------------------------------
 1 | import {hexStr2byteArray} from './code';
 2 | import {ADDRESS_PREFIX} from 'utils/address';
 3 | import {
 4 |     getBase58CheckAddress,
 5 |     decodeBase58Address,
 6 |     byteArray2hexStr
 7 | } from './crypto';
 8 | 
 9 | export function hexStringToBase58(sHexString) {
10 |     if (sHexString.length < 2 || (sHexString.length & 1) != 0)
11 |         return '';
12 | 
13 |     const bytes = hexStr2byteArray(sHexString);
14 |     return getBase58CheckAddress(bytes);
15 | }
16 | 
17 | export function base58ToHexString(sBase58) {
18 |     const bytes = decodeBase58Address(sBase58);
19 |     return byteArray2hexStr(bytes);
20 | }
21 | 
22 | export function hexStringToUtf8(hex) {
23 |     const arr = hex.split("");
24 |     let out = "";
25 | 
26 |     for (let i = 0; i < arr.length / 2; i++) {
27 |         const tmp = `0x${arr[i * 2]}${arr[i * 2 + 1]}`;
28 |         const charValue = String.fromCharCode(tmp);
29 |         out += charValue
30 |     }
31 | 
32 |     return out
33 | }
34 | 
35 | export function stringUtf8tHex(str) {
36 |     let val = "";
37 | 
38 |     for (let i = 0; i < str.length; i++) {
39 |         if (val == "")
40 |             val = str.charCodeAt(i).toString(16);
41 |         else
42 |             val += str.charCodeAt(i).toString(16);
43 |     }
44 | 
45 |     return val
46 | }
47 | 
48 | export function address2HexString(sHexAddress) {
49 |     if (sHexAddress.length == 42 && sHexAddress.indexOf(ADDRESS_PREFIX) == 0)
50 |         return sHexAddress;
51 | 
52 |     return base58ToHexString(sHexAddress)
53 | }
54 | 
55 | export function hexString2Address(sAddress) {
56 |     return hexStringToBase58(sAddress)
57 | }
58 | 
59 | export function hexString2Utf8(sHexString) {
60 |     return hexStringToUtf8(sHexString)
61 | }
62 | 
63 | export function stringUtf8toHex(sUtf8) {
64 |     return stringUtf8tHex(sUtf8)
65 | }
66 | 


--------------------------------------------------------------------------------
/src/utils/index.js:
--------------------------------------------------------------------------------
  1 | import * as accounts from './accounts';
  2 | import * as base58 from './base58';
  3 | import * as bytes from './bytes';
  4 | import * as crypto from './crypto';
  5 | import * as code from './code';
  6 | import * as abi from './abi';
  7 | import * as ethersUtils from './ethersUtils';
  8 | 
  9 | import validator from 'validator';
 10 | import BigNumber from 'bignumber.js';
 11 | import {ADDRESS_PREFIX} from 'utils/address';
 12 | 
 13 | const utils = {
 14 |     isValidURL(url) {
 15 |         if (typeof url !== 'string')
 16 |             return false;
 17 |         return validator.isURL(url.toString(), {
 18 |             protocols: ['http', 'https'],
 19 |             require_tld: false
 20 |         });
 21 |     },
 22 | 
 23 |     isObject(obj) {
 24 |         return obj === Object(obj) && Object.prototype.toString.call(obj) !== '[object Array]';
 25 |     },
 26 | 
 27 |     isArray(array) {
 28 |         return Array.isArray(array);
 29 |     },
 30 | 
 31 |     isJson(string) {
 32 |         try {
 33 |             return !!JSON.parse(string);
 34 |         } catch (ex) {
 35 |             return false;
 36 |         }
 37 |     },
 38 | 
 39 |     isBoolean(bool) {
 40 |         return typeof bool === 'boolean';
 41 |     },
 42 | 
 43 |     isBigNumber(number) {
 44 |         return number && (number instanceof BigNumber || (number.constructor && number.constructor.name === 'BigNumber'));
 45 |     },
 46 | 
 47 |     isString(string) {
 48 |         return typeof string === 'string' || (string && string.constructor && string.constructor.name === 'String');
 49 |     },
 50 | 
 51 |     isFunction(obj) {
 52 |         return typeof obj === 'function';
 53 |     },
 54 | 
 55 |     isHex(string) {
 56 |         return (typeof string === 'string'
 57 |             && !isNaN(parseInt(string, 16))
 58 |             && /^(0x|)[a-fA-F0-9]+$/.test(string));
 59 |     },
 60 | 
 61 |     isInteger(number) {
 62 |         if (number === null)
 63 |             return false
 64 |         return Number.isInteger(
 65 |             Number(number)
 66 |         );
 67 |     },
 68 | 
 69 |     hasProperty(obj, property) {
 70 |         return Object.prototype.hasOwnProperty.call(obj, property);
 71 |     },
 72 | 
 73 |     hasProperties(obj, ...properties) {
 74 |         return properties.length && !properties.map(property => {
 75 |             return this.hasProperty(obj, property)
 76 |         }).includes(false);
 77 |     },
 78 | 
 79 |     mapEvent(event) {
 80 |         let data = {
 81 |             block: event.block_number,
 82 |             timestamp: event.block_timestamp,
 83 |             contract: event.contract_address,
 84 |             name: event.event_name,
 85 |             transaction: event.transaction_id,
 86 |             result: event.result,
 87 |             resourceNode: event.resource_Node || (event._unconfirmed ? 'fullNode' : 'solidityNode')
 88 |         };
 89 |         if (event._unconfirmed) {
 90 |             data.unconfirmed = event._unconfirmed
 91 |         }
 92 |         if (event._fingerprint) {
 93 |             data.fingerprint = event._fingerprint;
 94 |         }
 95 |         return data;
 96 |     },
 97 | 
 98 |     parseEvent(event, {inputs: abi}) {
 99 |         if (!event.result)
100 |             return event;
101 | 
102 |         if (this.isObject(event.result)) {
103 |             for (var i = 0; i < abi.length; i++) {
104 |                 let obj = abi[i];
105 |                 if (obj.type == 'address' && obj.name in event.result)
106 |                     event.result[obj.name] = ADDRESS_PREFIX + event.result[obj.name].substr(2).toLowerCase();
107 |             }
108 |         } else if (this.isArray(event.result)) {
109 |             event.result = event.result.reduce((obj, result, index) => {
110 |                 const {
111 |                     name,
112 |                     type
113 |                 } = abi[index];
114 | 
115 |                 if (type == 'address')
116 |                     result = ADDRESS_PREFIX + result.substr(2).toLowerCase();
117 | 
118 |                 obj[name] = result;
119 | 
120 |                 return obj;
121 |             }, {});
122 |         }
123 | 
124 |         return event;
125 |     },
126 | 
127 |     padLeft(input, padding, amount) {
128 |         let res = input.toString();
129 | 
130 |         while (res.length < amount)
131 |             res = padding + res;
132 | 
133 |         return res;
134 |     },
135 | 
136 |     isNotNullOrUndefined(val) {
137 |         return val !== null && typeof val !== 'undefined';
138 |     },
139 | 
140 |     async sleep(millis = 1000){
141 |         return new Promise(resolve => setTimeout(resolve, millis));
142 |     }
143 | }
144 | 
145 | export default {
146 |     ...utils,
147 |     code,
148 |     accounts,
149 |     base58,
150 |     bytes,
151 |     crypto,
152 |     abi,
153 |     ethersUtils
154 | };
155 | 


--------------------------------------------------------------------------------
/test-git-hash:
--------------------------------------------------------------------------------
1 | Test failed.
2 | 


--------------------------------------------------------------------------------
/test-report:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 |   TronWeb.lib.event
 4 |     Trongrid-compatible version
 5 |       #getEventsByTransactionID
 6 | Sleeping for 0.5 seconds... Slept.
 7 | Sleeping for 0.5 seconds... Slept.
 8 | Sleeping for 0.5 seconds... Slept.
 9 |         ✓ should emit an unconfirmed event and get it (1562ms)
10 |         ✓ should emit an event, wait for confirmation and get it (9139ms)
11 |       #getEventsByContractAddress
12 |         1) should emit an event and wait for it
13 |       #contract.method.watch
14 |         2) should watch for an event
15 |         3) should only watch for an event with given filters
16 | 
17 | 
18 |   2 passing (11s)
19 |   3 failing
20 | 
21 |   1) TronWeb.lib.event
22 |        Trongrid-compatible version
23 |          #getEventsByContractAddress
24 |            should emit an event and wait for it:
25 |      Error: the object {
26 |   "error": {
27 |     "code": 404
28 |     "status": "Not Found"
29 |   }
30 | } was thrown, throw an Error :)
31 |       at processTicksAndRejections (internal/process/task_queues.js:93:5)
32 | 
33 |   2) TronWeb.lib.event
34 |        Trongrid-compatible version
35 |          #contract.method.watch
36 |            should watch for an event:
37 |      Error: the object {
38 |   "error": {
39 |     "code": 404
40 |     "status": "Not Found"
41 |   }
42 | } was thrown, throw an Error :)
43 |       at processTicksAndRejections (internal/process/task_queues.js:93:5)
44 | 
45 |   3) TronWeb.lib.event
46 |        Trongrid-compatible version
47 |          #contract.method.watch
48 |            should only watch for an event with given filters:
49 |      Error: the object {
50 |   "error": {
51 |     "code": 404
52 |     "status": "Not Found"
53 |   }
54 | } was thrown, throw an Error :)
55 |       at processTicksAndRejections (internal/process/task_queues.js:93:5)
56 | 
57 | 
58 | 
59 | 


--------------------------------------------------------------------------------
/test/fixtures/contracts.js:
--------------------------------------------------------------------------------
  1 | module.exports = {
  2 |     testRevert: {
  3 |         /*
  4 |         pragma solidity ^0.4.18;
  5 |         contract TestRevert {
  6 |             address owner;
  7 |             constructor() public {
  8 |             }
  9 |             function setOwner(address addr) public {
 10 |                 require(addr != 0xb6e447d1d576dE6c7f767C32a649F0AD50aE5975, "Address forbidden :-)");
 11 |                 // TSeFTBYCy3r2kZNYsj86G6Yz6rsmPdYdFs
 12 |                 owner = addr;
 13 |             }
 14 |             function getOwner(uint check) public view returns (address) {
 15 |                 require(check == 1, "Wrong check");
 16 |                 return owner;
 17 |             }
 18 |             function getOwner2(uint check) public view returns (address) {
 19 |                 require(check == 1);
 20 |                 return owner;
 21 |             }
 22 |         }
 23 |         */
 24 |         contractName: "TestRevert",
 25 |         abi: [
 26 |             {
 27 |                 "inputs": [],
 28 |                 "payable": false,
 29 |                 "stateMutability": "nonpayable",
 30 |                 "type": "constructor"
 31 |             },
 32 |             {
 33 |                 "constant": false,
 34 |                 "inputs": [
 35 |                     {
 36 |                         "name": "addr",
 37 |                         "type": "address"
 38 |                     }
 39 |                 ],
 40 |                 "name": "setOwner",
 41 |                 "outputs": [],
 42 |                 "payable": false,
 43 |                 "stateMutability": "nonpayable",
 44 |                 "type": "function"
 45 |             },
 46 |             {
 47 |                 "constant": true,
 48 |                 "inputs": [
 49 |                     {
 50 |                         "name": "check",
 51 |                         "type": "uint256"
 52 |                     }
 53 |                 ],
 54 |                 "name": "getOwner",
 55 |                 "outputs": [
 56 |                     {
 57 |                         "name": "",
 58 |                         "type": "address"
 59 |                     }
 60 |                 ],
 61 |                 "payable": false,
 62 |                 "stateMutability": "view",
 63 |                 "type": "function"
 64 |             },
 65 |             {
 66 |                 "constant": true,
 67 |                 "inputs": [
 68 |                     {
 69 |                         "name": "check",
 70 |                         "type": "uint256"
 71 |                     }
 72 |                 ],
 73 |                 "name": "getOwner2",
 74 |                 "outputs": [
 75 |                     {
 76 |                         "name": "",
 77 |                         "type": "address"
 78 |                     }
 79 |                 ],
 80 |                 "payable": false,
 81 |                 "stateMutability": "view",
 82 |                 "type": "function"
 83 |             }
 84 |         ],
 85 |         bytecode: "0x608060405234801561001057600080fd5b5061037d806100206000396000f300608060405260043610610057576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806313af40351461005c578063877333461461009f578063c41a360a1461010c575b600080fd5b34801561006857600080fd5b5061009d600480360381019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610179565b005b3480156100ab57600080fd5b506100ca60048036038101908080359060200190929190505050610274565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561011857600080fd5b50610137600480360381019080803590602001909291905050506102ae565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b73b6e447d1d576de6c7f767c32a649f0ad50ae597573ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614151515610231576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260158152602001807f41646472657373206d75737420626520213d203078000000000000000000000081525060200191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600060018214151561028557600080fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b6000600182141515610328576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600b8152602001807f57726f6e6720636865636b00000000000000000000000000000000000000000081525060200191505060405180910390fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690509190505600a165627a7a7230582070775fabe424bfe924ea8b9a9f4863306d35202b9c074f195334273994260ef20029"
 86 |     },
 87 |     testConstant: {
 88 |         contractName: "testConstantContract",
 89 |         abi: [
 90 |             {
 91 |                 "constant": true,
 92 |                 "inputs": [
 93 |                     {
 94 |                         "name": "x",
 95 |                         "type": "uint256"
 96 |                     },
 97 |                     {
 98 |                         "name": "y",
 99 |                         "type": "uint256"
100 |                     }
101 |                 ],
102 |                 "name": "testPure",
103 |                 "outputs": [
104 |                     {
105 |                         "name": "z",
106 |                         "type": "uint256"
107 |                     }
108 |                 ],
109 |                 "payable": false,
110 |                 "stateMutability": "pure",
111 |                 "type": "function"
112 |             }
113 |         ],
114 |         bytecode: "0x608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a57600080fd5b5060e5806100396000396000f300608060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806307fb8ea6146044575b600080fd5b348015604f57600080fd5b50d38015605b57600080fd5b50d28015606757600080fd5b50608e600480360381019080803590602001909291908035906020019092919050505060a4565b6040518082815260200191505060405180910390f35b600080600190508284820101915050929150505600a165627a7a72305820ba2dba126dd3285cfaee13187fa53bf7d9bc09517d6afd04cd7d71098a1f90ee0029"
115 |     },
116 |     testSetVal: {
117 |         "contractName": "SetVal",
118 |         "abi": [
119 |             {
120 |                 "constant": false,
121 |                 "inputs": [
122 |                     {
123 |                         "name": "_val",
124 |                         "type": "uint256"
125 |                     }
126 |                 ],
127 |                 "name": "set",
128 |                 "outputs": [
129 |                     {
130 |                         "name": "",
131 |                         "type": "uint256"
132 |                     }
133 |                 ],
134 |                 "payable": false,
135 |                 "stateMutability": "nonpayable",
136 |                 "type": "function"
137 |             }
138 |         ],
139 |         "bytecode": "0x60806040526000805534801561001457600080fd5b50d3801561002157600080fd5b50d2801561002e57600080fd5b5060e08061003d6000396000f3fe6080604052348015600f57600080fd5b50d38015601b57600080fd5b50d28015602757600080fd5b5060043610605d576000357c01000000000000000000000000000000000000000000000000000000009004806360fe47b1146062575b600080fd5b608b60048036036020811015607657600080fd5b810190808035906020019092919050505060a1565b6040518082815260200191505060405180910390f35b600081600081905550600054905091905056fea165627a7a72305820392f2cf7f1b37873349bf7ce496fb370bc80c6539de204bded6197106c530e700029"
140 |     },
141 |     arrayParam: {
142 |         "contractName": "ArrayParam",
143 |         "abi": [
144 |             {
145 |                 "constant": true,
146 |                 "inputs": [
147 |                     {
148 |                         "name": "",
149 |                         "type": "address"
150 |                     }
151 |                 ],
152 |                 "name": "balances",
153 |                 "outputs": [
154 |                     {
155 |                         "name": "",
156 |                         "type": "uint256"
157 |                     }
158 |                 ],
159 |                 "payable": false,
160 |                 "stateMutability": "view",
161 |                 "type": "function"
162 |             },
163 |             {
164 |                 "inputs": [
165 |                     {
166 |                         "name": "addresses",
167 |                         "type": "address[]"
168 |                     },
169 |                     {
170 |                         "name": "initialBalances",
171 |                         "type": "uint256[]"
172 |                     }
173 |                 ],
174 |                 "payable": false,
175 |                 "stateMutability": "nonpayable",
176 |                 "type": "constructor"
177 |             }
178 |         ],
179 |         "bytecode": "0x608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a57600080fd5b506040516102a83803806102a88339810180604052604081101561004d57600080fd5b81019080805164010000000081111561006557600080fd5b8281019050602081018481111561007b57600080fd5b815185602082028301116401000000008211171561009857600080fd5b505092919060200180516401000000008111156100b457600080fd5b828101905060208101848111156100ca57600080fd5b81518560208202830111640100000000821117156100e757600080fd5b5050929190505050600082511115156100ff57600080fd5b8051825114151561010f57600080fd5b60008090505b825181101561019c57818181518110151561012c57fe5b90602001906020020151600080858481518110151561014757fe5b9060200190602002015173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508080600101915050610115565b50505060fb806101ad6000396000f3fe6080604052348015600f57600080fd5b50d38015601b57600080fd5b50d28015602757600080fd5b5060043610605d576000357c01000000000000000000000000000000000000000000000000000000009004806327e235e3146062575b600080fd5b60a160048036036020811015607657600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505060b7565b6040518082815260200191505060405180910390f35b6000602052806000526040600020600091509050548156fea165627a7a723058207d447cc574baeda0c964d154c92f29b2c72be467d5118d30741788a8c03c185d0029"
180 |     }
181 | }
182 | 


--------------------------------------------------------------------------------
/test/helpers/BlockLib.js:
--------------------------------------------------------------------------------
 1 | 
 2 | const injectPromise = require('injectpromise')
 3 | 
 4 | class BlockLib {
 5 | 
 6 |     constructor(tronWeb = false) {
 7 |         if (!tronWeb)
 8 |             throw new Error('Expected instances of TronWeb and utils');
 9 |         this.tronWeb = tronWeb;
10 |         this.injectPromise = injectPromise(this);
11 |     }
12 | 
13 |     async getCurrent(callback = false) {
14 | 
15 |         if (!callback)
16 |             return this.injectPromise(this.getCurrent);
17 | 
18 |         this.tronWeb.fullNode.request('wallet/getnowblock').then(block => {
19 |             block.fromPlugin = true
20 |             callback(null, block);
21 |         }).catch(err => callback(err));
22 |     }
23 | 
24 |     pluginInterface() {
25 |         return {
26 |             requires: '^2.8.0',
27 |             fullClass: true
28 |         }
29 |     }
30 | }
31 | 
32 | module.exports = BlockLib
33 | 


--------------------------------------------------------------------------------
/test/helpers/GetNowBlock.js:
--------------------------------------------------------------------------------
 1 | 
 2 | let someParameter
 3 | 
 4 | class GetNowBlock {
 5 | 
 6 |     constructor(tronWeb = false) {
 7 |         if (!tronWeb)
 8 |             throw new Error('Expected instance of TronWeb');
 9 | 
10 |         this.tronWeb = tronWeb;
11 |     }
12 | 
13 |     async someMethod(callback = false) {
14 | 
15 |         if(!callback)
16 |             return this.injectPromise(this.getCurrentBlock);
17 | 
18 |         this.tronWeb.fullNode.request('wallet/getnowblock').then(block => {
19 |             block.fromPlugin = true
20 |             callback(null, block);
21 |         }).catch(err => callback(err));
22 |     }
23 | 
24 |     getSomeParameter() {
25 |         return someParameter;
26 |     }
27 | 
28 |     pluginInterface(options) {
29 |         if (options.someParameter) {
30 |             someParameter = options.someParameter
31 |         }
32 |         return {
33 |             requires: '^2.2.4',
34 |             components: {
35 |                 trx: {
36 |                     // will be overridden
37 |                     getCurrentBlock: this.someMethod,
38 | 
39 |                     // will be added
40 |                     getLatestBlock: this.someMethod,
41 |                     getSomeParameter: this.getSomeParameter,
42 | 
43 |                     // will be skipped
44 |                     _parseToken: function () {}
45 | 
46 | 
47 |                 }
48 |             }
49 |         }
50 |     }
51 | }
52 | 
53 | module.exports = GetNowBlock
54 | 


--------------------------------------------------------------------------------
/test/helpers/assertEqualHex.js:
--------------------------------------------------------------------------------
 1 | const assert = require('chai').assert;
 2 | const tronWebBuilder = require('./tronWebBuilder');
 3 | 
 4 | module.exports = async function (result, string) {
 5 | 
 6 |     assert.equal(
 7 |         result,
 8 |         tronWebBuilder.getInstance().toHex(string).substring(2)
 9 |     )
10 | }
11 | 


--------------------------------------------------------------------------------
/test/helpers/assertThrow.js:
--------------------------------------------------------------------------------
 1 | const assert = require('chai').assert;
 2 | 
 3 | module.exports = async function (func, expectedError, expectedErrorContains) {
 4 |     let errMsg;
 5 |     try {
 6 |         await func
 7 |     } catch (err) {
 8 |         if(typeof err === 'object') {
 9 |             if(err.message)
10 |                 errMsg = err.message
11 |             else if(err.error)
12 |                 errMsg = err.error
13 |         }
14 |         else
15 |             errMsg = err
16 |         if(expectedError)
17 |             assert.equal(errMsg, expectedError);
18 |         else if(expectedErrorContains) {
19 |             if(!Array.isArray(expectedErrorContains)) {
20 |                 expectedErrorContains = [expectedErrorContains]
21 |             }
22 |             for(let expected of expectedErrorContains) {
23 |                 assert.notEqual(errMsg.indexOf(expected), -1)
24 |             }
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/test/helpers/broadcaster.js:
--------------------------------------------------------------------------------
 1 | const tronWebBuilder = require('../helpers/tronWebBuilder');
 2 | 
 3 | module.exports = async function (func, pk, transaction) {
 4 |     const tronWeb = tronWebBuilder.createInstance();
 5 |     if( !transaction) {
 6 |         transaction = await func;
 7 |     }
 8 |     const signedTransaction = await tronWeb.trx.sign(transaction, pk);
 9 |     const result = {
10 |         transaction,
11 |         signedTransaction,
12 |         receipt: await tronWeb.trx.sendRawTransaction(signedTransaction)
13 |     };
14 |     return Promise.resolve(result);
15 | }
16 | 


--------------------------------------------------------------------------------
/test/helpers/config.js:
--------------------------------------------------------------------------------
 1 | const fullHost = "http://127.0.0.1:" + (process.env.HOST_PORT || 9090)
 2 | 
 3 | module.exports = {
 4 | 
 5 |     PRIVATE_KEY: 'da146374a75310b9666e834ee4ad0866d6f4035967bfc76217c5a495fff9f0d0',
 6 |     CONSUME_USER_RESOURCE_PERCENT: 30,
 7 |     FEE_LIMIT: 100000000,
 8 |     FULL_NODE_API: fullHost,
 9 |     SOLIDITY_NODE_API: fullHost,
10 |     EVENT_API: fullHost,
11 |     NETWORK_ID: "*",
12 |     ADDRESS_HEX: '41928c9af0651632157ef27a2cf17ca72c575a4d21',
13 |     ADDRESS_BASE58: 'TPL66VK2gCXNCD7EJg9pgJRfqcRazjhUZY',
14 |     UPDATED_TEST_TOKEN_OPTIONS: {
15 |         description: 'Very useless utility token',
16 |         url: 'https://none.example.com',
17 |         freeBandwidth: 10,
18 |         freeBandwidthLimit: 100
19 |     },
20 |     getTokenOptions: () => {
21 |         const rnd = Math.random().toString(36).substr(2);
22 |         return {
23 |             name: `Token${rnd}`,
24 |             abbreviation: `T${rnd.substring(2).toUpperCase()}`,
25 |             description: 'Useless utility token',
26 |             url: `https://example-${rnd}.com/`,
27 |             totalSupply: 100000000,
28 |             saleEnd: Date.now() + 60000, // 1 minute
29 |             frozenAmount: 5,
30 |             frozenDuration: 1,
31 |             trxRatio: 10,
32 |             tokenRatio: 2,
33 |             saleStart: Date.now() + 500,
34 |             freeBandwidth: 100,
35 |             freeBandwidthLimit: 1000
36 |         }
37 |     },
38 |     isProposalApproved: async (tronWeb, proposal) => {
39 |         let chainParameters = await tronWeb.trx.getChainParameters()
40 |         for(let param of chainParameters) {
41 |             if(param.key === proposal) {
42 |                 return param.value
43 |             }
44 |         }
45 |         return false
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/test/helpers/jlog.js:
--------------------------------------------------------------------------------
1 | const chalk = require('chalk')
2 | 
3 | module.exports = (...x) => {
4 |     for(let i = 0; i < x.length; i++) {
5 |         console.log(chalk.blue(typeof x[i] === 'object' ? JSON.stringify(x[i], null, 2) : x[i]))
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/test/helpers/log.js:
--------------------------------------------------------------------------------
 1 | module.exports = (...x) => {
 2 |     for(let i = 0; i < x.length; i++) {
 3 |         let y = x[i]
 4 |         if(Array.isArray(y)) {
 5 |             for(let j = 0; j < y.length; j++) {
 6 |                 console.log(j, y[j].valueOf())
 7 |             }
 8 |         } else if(typeof y === 'object') {
 9 |             console.log(y.valueOf())
10 |         } else {
11 |             console.log(y)
12 |         }
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/test/helpers/newAccounts.js:
--------------------------------------------------------------------------------
 1 | const tronWebBuilder = require('./tronWebBuilder');
 2 | const tronWeb = tronWebBuilder.createInstance();
 3 | 
 4 | const amount = process.argv[2] || 10;
 5 | 
 6 | (async function () {
 7 |     await tronWebBuilder.newTestAccounts(amount)
 8 | })()
 9 | 
10 | 


--------------------------------------------------------------------------------
/test/helpers/pollAccountFor.js:
--------------------------------------------------------------------------------
 1 | const _ = require('lodash');
 2 | const wait = require('./wait');
 3 | const tronWebBuilder = require('./tronWebBuilder')
 4 | 
 5 | module.exports = async function pollAccountFor(address, property, value = false, interval = 3, timeout = 10000) {
 6 |     const tronWeb = tronWebBuilder.createInstance()
 7 |     let now = Date.now()
 8 |     while (true) {
 9 |         if(Date.now() > now + timeout) {
10 |             throw new Error('Timeout...');
11 |         }
12 |         wait(interval);
13 |         let result = await tronWeb.trx.getAccount(address);
14 |         if(typeof property === 'string') {
15 |             let data = _.get(result, property)
16 |             if(data) {
17 |                 if(value) {
18 |                     if(data == value) return Promise.resolve(result);
19 |                 } else {
20 |                     return Promise.resolve(result);
21 |                 }
22 |             }
23 |         } else if(typeof property === 'function') {
24 |             if(property(result)) {
25 |                 return Promise.resolve(result);
26 |             }
27 | 
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/helpers/tronWebBuilder.js:
--------------------------------------------------------------------------------
 1 | const chalk = require('chalk')
 2 | const TronWeb = require('../setup/TronWeb');
 3 | const jlog = require('./jlog')
 4 | 
 5 | const {FULL_NODE_API, SOLIDITY_NODE_API, EVENT_API, PRIVATE_KEY} = require('./config')
 6 | 
 7 | const createInstance = (extraOptions = {}) => {
 8 |     let options = Object.assign({
 9 |         fullHost: FULL_NODE_API,
10 |         privateKey: PRIVATE_KEY
11 |     }, extraOptions)
12 |     return new TronWeb(options)
13 | }
14 | 
15 | let instance
16 | 
17 | const getInstance = () => {
18 |     if (!instance) {
19 |         instance = createInstance()
20 |     }
21 |     return instance
22 | }
23 | 
24 | const newTestAccounts = async (amount) => {
25 |     const tronWeb = createInstance();
26 | 
27 |     console.log(chalk.blue(`Generating ${amount} new accounts...`))
28 |     await tronWeb.fullNode.request('/admin/temporary-accounts-generation?accounts=' + amount);
29 |     const lastCreated = await getTestAccounts(-1)
30 |     jlog(lastCreated.b58)
31 | }
32 | 
33 | const getTestAccounts = async (block) => {
34 |     const accounts = {
35 |         b58: [],
36 |         hex: [],
37 |         pks: []
38 |     }
39 |     const tronWeb = createInstance();
40 |     const accountsJson = await tronWeb.fullNode.request('/admin/accounts-json');
41 |     const index = typeof block === 'number'
42 |         ? (block > -1 && block < accountsJson.more.length ? block : accountsJson.more.length - 1)
43 |         : undefined
44 |     accounts.pks = typeof block === 'number'
45 |         ? accountsJson.more[index].privateKeys
46 |         : accountsJson.privateKeys;
47 |     for (let i = 0; i < accounts.pks.length; i++) {
48 |         let addr = tronWeb.address.fromPrivateKey(accounts.pks[i]);
49 |         accounts.b58.push(addr);
50 |         accounts.hex.push(tronWeb.address.toHex(addr));
51 |     }
52 |     return Promise.resolve(accounts);
53 | }
54 | 
55 | module.exports = {
56 |     createInstance,
57 |     getInstance,
58 |     newTestAccounts,
59 |     getTestAccounts,
60 |     TronWeb
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/test/helpers/txPars.js:
--------------------------------------------------------------------------------
1 | module.exports = function (transaction) {
2 |     return transaction.raw_data.contract[0].parameter;
3 | }
4 | 


--------------------------------------------------------------------------------
/test/helpers/wait.js:
--------------------------------------------------------------------------------
 1 | function sleep(millis) {
 2 |     return new Promise(resolve => setTimeout(resolve, millis));
 3 | }
 4 | const chalk = require('chalk')
 5 | 
 6 | function log(x) {
 7 |     if (process.stdout !== undefined) {
 8 |         process.stdout.write(chalk.yellow(x));
 9 |     } else {
10 |         console.log(chalk.yellow(x)); // used for karma
11 |     }
12 | }
13 | 
14 | module.exports = async function (secs) {
15 |     secs = secs || 1
16 |     log(`Sleeping for ${secs} second${secs === 1 ? '' : 's'}...`)
17 |     await sleep(1000 * (secs || 1))
18 |     log(' Slept.\n')
19 | }
20 | 


--------------------------------------------------------------------------------
/test/helpers/waitChainData.js:
--------------------------------------------------------------------------------
 1 | const tronWebBuilder = require('./tronWebBuilder');
 2 | const tronWeb = tronWebBuilder.createInstance();
 3 | const wait = require('./wait');
 4 | const chalk = require('chalk');
 5 | const jlog = require('./jlog');
 6 | 
 7 | function log(x) {
 8 |     process.stdout.write(chalk.yellow(x))
 9 | }
10 | 
11 | module.exports = async function (type, ...params) {
12 |     let startTimestamp = Date.now();
13 |     let timeLimit = 5000;
14 |     do {
15 |         let data;
16 |         let isFound = false;
17 |         try {
18 |             switch (type) {
19 |                 case 'tx': {
20 |                     data = await tronWeb.trx.getTransaction(params[0]);
21 |                     isFound = !!data.txID;
22 |                     break;
23 |                 }
24 |                 case 'account': {
25 |                     data = await tronWeb.trx.getUnconfirmedAccount(params[0]);
26 |                     isFound = !!data.address;
27 |                     break;
28 |                 }
29 |                 case 'accountById': {
30 |                     data = await tronWeb.trx.getUnconfirmedAccountById(params[0]);
31 |                     isFound = !!data.address;
32 |                     break;
33 |                 }
34 |                 case 'token': {
35 |                     data = await tronWeb.trx.getTokensIssuedByAddress(params[0]);
36 |                     isFound = !!Object.keys(data).length;
37 |                     break;
38 |                 }
39 |                 case 'tokenById': {
40 |                     data = await tronWeb.trx.getTokenFromID(params[0]);
41 |                     isFound = !!data.name;
42 |                     break;
43 |                 }
44 |                 case 'sendToken': {
45 |                     data = await tronWeb.trx.getUnconfirmedAccount(params[0]);
46 |                     isFound = data && data.assetV2 && data.assetV2.length && data.assetV2[0].value !== params[1];
47 |                     break;
48 |                 }
49 |                 case 'balance': {
50 |                     data = await tronWeb.trx.getUnconfirmedBalance(params[0]);
51 |                     isFound = (data !== params[1]);
52 |                     break;
53 |                 }
54 |                 case 'freezeBp': {
55 |                     data = await tronWeb.trx.getUnconfirmedAccount(params[0]);
56 |                     isFound = data.frozen && (data.frozen[0].frozen_balance !== params[1]);
57 |                     break;
58 |                 }
59 |                 case 'freezeEnergy': {
60 |                     data = await tronWeb.trx.getUnconfirmedAccount(params[0]);
61 |                     isFound = data.account_resource &&
62 |                         data.account_resource.frozen_balance_for_energy &&
63 |                         (data.account_resource.frozen_balance_for_energy.frozen_balance !== params[1]);
64 |                     break;
65 |                 }
66 |                 case 'contract': {
67 |                     data = await tronWeb.trx.getContract(params[0]);
68 |                     isFound = !!data.contract_address;
69 |                     break;
70 |                 }
71 |                 case 'exchange': {
72 |                     data = await tronWeb.trx.getExchangeByID(params[0]);
73 |                     isFound = !!data.exchange_id;
74 |                     break;
75 |                 }
76 |                 default:
77 |                     isFound = true;
78 | 
79 |             }
80 |         } catch (e) {
81 |             log(e);
82 |             await wait(1);
83 |             continue;
84 |         }
85 |         // console.log(...params, 'wait for chain data result: ', isFound, data, type);
86 |         if (isFound)
87 |             return;
88 |         log(`waiting for unconfirmed data,${type}...`);
89 |         await wait(1);
90 | 
91 |     } while (Date.now() - startTimestamp < timeLimit);
92 | 
93 |     throw new Error('No unconfirmed data found on chain');
94 | };
95 | 


--------------------------------------------------------------------------------
/test/lib/contract/method.test.js:
--------------------------------------------------------------------------------
  1 | const chai = require('chai');
  2 | const assert = chai.assert;
  3 | const wait = require('../../helpers/wait');
  4 | const assertThrow = require('../../helpers/assertThrow');
  5 | const broadcaster = require('../../helpers/broadcaster');
  6 | const _ = require('lodash');
  7 | const tronWebBuilder = require('../../helpers/tronWebBuilder');
  8 | const TronWeb = tronWebBuilder.TronWeb;
  9 | 
 10 | const testRevertContract = require('../../fixtures/contracts').testRevert;
 11 | const testSetValContract = require('../../fixtures/contracts').testSetVal;
 12 | 
 13 | describe('#contract.method', function () {
 14 | 
 15 |     let accounts;
 16 |     let tronWeb;
 17 |     let emptyAccount;
 18 | 
 19 |     before(async function () {
 20 |         tronWeb = tronWebBuilder.createInstance();
 21 |         // ALERT this works only with Tron Quickstart:
 22 |         accounts = await tronWebBuilder.getTestAccounts(-1);
 23 |         emptyAccount = await TronWeb.createAccount();
 24 |     });
 25 | 
 26 |     describe('#send()', function () {
 27 | 
 28 |         let testRevert
 29 |         let testSetVal
 30 | 
 31 |         before(async function () {
 32 |             const tx = await broadcaster(tronWeb.transactionBuilder.createSmartContract({
 33 |                 abi: testRevertContract.abi,
 34 |                 bytecode: testRevertContract.bytecode
 35 |             }, accounts.b58[0]), accounts.pks[0])
 36 |             testRevert = await tronWeb.contract().at(tx.transaction.contract_address)
 37 | 
 38 |             const tx2 = await broadcaster(tronWeb.transactionBuilder.createSmartContract({
 39 |                 abi: testSetValContract.abi,
 40 |                 bytecode: testSetValContract.bytecode
 41 |             }, accounts.b58[0]), accounts.pks[0])
 42 |             testSetVal = await tronWeb.contract().at(tx2.transaction.contract_address)
 43 |         })
 44 | 
 45 |         it("should set accounts[2] as the owner and check it with getOwner(1)", async function () {
 46 |             await testRevert.setOwner(accounts.b58[2]).send()
 47 |             assert.equal(await testRevert.getOwner(1).call(), accounts.hex[2])
 48 |         })
 49 | 
 50 |         it("should revert if trying to set TSeFTBYCy3r2kZNYsj86G6Yz6rsmPdYdFs as the owner", async function () {
 51 |             this.timeout(30000)
 52 |             await assertThrow(testRevert.setOwner('TSeFTBYCy3r2kZNYsj86G6Yz6rsmPdYdFs').send({shouldPollResponse: true}),
 53 |                 null,
 54 |                 'REVERT'
 55 |             )
 56 |         });
 57 | 
 58 |         it("should set the val to 123", async function () {
 59 |             this.timeout(30000)
 60 |             let result = await testSetVal.set(123).send({
 61 |                 shouldPollResponse: true,
 62 |                 keepTxID: true
 63 |             })
 64 |             assert.equal(result[0].length, 64)
 65 |             assert.equal(result[1].toNumber(), 123)
 66 |         });
 67 | 
 68 |     });
 69 | 
 70 |     describe('#call()', function () {
 71 | 
 72 |         let testRevert
 73 | 
 74 |         before(async function () {
 75 |             const tx = await broadcaster(tronWeb.transactionBuilder.createSmartContract({
 76 |                 abi: testRevertContract.abi,
 77 |                 bytecode: testRevertContract.bytecode
 78 |             }, accounts.b58[0]), accounts.pks[0])
 79 |             testRevert = await tronWeb.contract().at(tx.transaction.contract_address)
 80 |             await testRevert.setOwner(accounts.b58[2]).send()
 81 |         })
 82 | 
 83 |         it("should getOwner(1) and get accounts[2]", async function () {
 84 |             assert.equal(await testRevert.getOwner(1).call(), accounts.hex[2])
 85 |         })
 86 | 
 87 |         it("should revert if call getOwner(2)", async function () {
 88 |             await assertThrow(testRevert.getOwner(2).call()
 89 |             )
 90 |         })
 91 | 
 92 |         it("should revert if call getOwner2()", async function () {
 93 |             await assertThrow(testRevert.getOwner2(2).call()
 94 |             )
 95 |         })
 96 | 
 97 |     });
 98 | 
 99 | });
100 | 


--------------------------------------------------------------------------------
/test/lib/event.test.js:
--------------------------------------------------------------------------------
  1 | const chai = require('chai');
  2 | const {FULL_NODE_API} = require('../helpers/config');
  3 | const assertThrow = require('../helpers/assertThrow');
  4 | const tronWebBuilder = require('../helpers/tronWebBuilder');
  5 | const TronWeb = tronWebBuilder.TronWeb;
  6 | const jlog = require('../helpers/jlog')
  7 | const broadcaster = require('../helpers/broadcaster');
  8 | const wait = require('../helpers/wait')
  9 | 
 10 | const assert = chai.assert;
 11 | 
 12 | describe('TronWeb.lib.event', async function () {
 13 | 
 14 |     let accounts
 15 |     let tronWeb
 16 |     let contractAddress
 17 |     let contract
 18 |     let eventLength = 0
 19 | 
 20 |     before(async function () {
 21 |         tronWeb = tronWebBuilder.createInstance();
 22 |         accounts = await tronWebBuilder.getTestAccounts(-1);
 23 | 
 24 |         const result = await broadcaster(tronWeb.transactionBuilder.createSmartContract({
 25 |             abi: [
 26 |                 {
 27 |                     "anonymous": false,
 28 |                     "inputs": [
 29 |                         {
 30 |                             "indexed": true,
 31 |                             "name": "_sender",
 32 |                             "type": "address"
 33 |                         },
 34 |                         {
 35 |                             "indexed": false,
 36 |                             "name": "_receiver",
 37 |                             "type": "address"
 38 |                         },
 39 |                         {
 40 |                             "indexed": false,
 41 |                             "name": "_amount",
 42 |                             "type": "uint256"
 43 |                         }
 44 |                     ],
 45 |                     "name": "SomeEvent",
 46 |                     "type": "event"
 47 |                 },
 48 |                 {
 49 |                     "constant": false,
 50 |                     "inputs": [
 51 |                         {
 52 |                             "name": "_receiver",
 53 |                             "type": "address"
 54 |                         },
 55 |                         {
 56 |                             "name": "_someAmount",
 57 |                             "type": "uint256"
 58 |                         }
 59 |                     ],
 60 |                     "name": "emitNow",
 61 |                     "outputs": [],
 62 |                     "payable": false,
 63 |                     "stateMutability": "nonpayable",
 64 |                     "type": "function"
 65 |                 }
 66 |             ],
 67 |             bytecode: "0x608060405234801561001057600080fd5b50610145806100206000396000f300608060405260043610610041576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063bed7111f14610046575b600080fd5b34801561005257600080fd5b50610091600480360381019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610093565b005b3373ffffffffffffffffffffffffffffffffffffffff167f9f08738e168c835bbaf7483705fb1c0a04a1a3258dd9687f14d430948e04e3298383604051808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020018281526020019250505060405180910390a250505600a165627a7a7230582033629e2b0bba53f7b5c49769e7e360f2803ae85ac80e69dd61c7bb48f9f401f30029"
 68 |         }, accounts.hex[0]), accounts.pks[0])
 69 | 
 70 |         contractAddress = result.receipt.transaction.contract_address
 71 |         contract = await tronWeb.contract().at(contractAddress)
 72 | 
 73 |     });
 74 | 
 75 |     describe('#constructor()', function () {
 76 | 
 77 |         it('should have been set a full instance in tronWeb', function () {
 78 | 
 79 |             assert.instanceOf(tronWeb.event, TronWeb.Event);
 80 |         });
 81 | 
 82 |     });
 83 | 
 84 |     describe("#getEventsByTransactionID", async function () {
 85 | 
 86 | 
 87 |         it('should emit an unconfirmed event and get it', async function () {
 88 | 
 89 |             this.timeout(60000)
 90 |             tronWeb.setPrivateKey(accounts.pks[1])
 91 |             let txId = await contract.emitNow(accounts.hex[2], 2000).send({
 92 |                 from: accounts.hex[1]
 93 |             })
 94 |             eventLength++
 95 |             let events
 96 |             while(true) {
 97 |                 events = await tronWeb.event.getEventsByTransactionID(txId)
 98 |                 if (events.length) {
 99 |                     break
100 |                 }
101 |                 await wait(0.5)
102 |             }
103 | 
104 |             assert.equal(events[0].result._receiver.substring(2), accounts.hex[2].substring(2))
105 |             assert.equal(events[0].result._sender.substring(2), accounts.hex[1].substring(2))
106 |             assert.equal(events[0].resourceNode, 'fullNode')
107 | 
108 |         })
109 | 
110 |         it('should emit an event, wait for confirmation and get it', async function () {
111 | 
112 |             this.timeout(60000)
113 |             tronWeb.setPrivateKey(accounts.pks[1])
114 |             let output = await contract.emitNow(accounts.hex[2], 2000).send({
115 |                 from: accounts.hex[1],
116 |                 shouldPollResponse: true,
117 |                 rawResponse: true
118 |             })
119 |             eventLength++
120 | 
121 |             let txId = output.id
122 |             let events
123 |             while(true) {
124 |                 events = await tronWeb.event.getEventsByTransactionID(txId)
125 |                 if (events.length) {
126 |                     break
127 |                 }
128 |                 await wait(0.5)
129 |             }
130 | 
131 |             assert.equal(events[0].result._receiver.substring(2), accounts.hex[2].substring(2))
132 |             assert.equal(events[0].result._sender.substring(2), accounts.hex[1].substring(2))
133 |             assert.equal(events[0].resourceNode, 'solidityNode')
134 | 
135 |         })
136 | 
137 |     });
138 | 
139 |     describe("#getEventsByContractAddress", async function () {
140 | 
141 |         it('should emit an event and wait for it', async function () {
142 | 
143 |             this.timeout(60000)
144 |             tronWeb.setPrivateKey(accounts.pks[3])
145 |             await contract.emitNow(accounts.hex[4], 4000).send({
146 |                 from: accounts.hex[3]
147 |             })
148 |             eventLength++
149 |             let events
150 |             while(true) {
151 |                 events = await tronWeb.event.getEventsByContractAddress(contractAddress, {
152 |                     eventName: 'SomeEvent',
153 |                     sort: 'block_timestamp'
154 |                 })
155 |                 if (events.length === eventLength) {
156 |                     break
157 |                 }
158 |                 await wait(0.5)
159 |             }
160 | 
161 |             const event = events[events.length - 1]
162 | 
163 |             assert.equal(event.result._receiver.substring(2), accounts.hex[4].substring(2))
164 |             assert.equal(event.result._sender.substring(2), accounts.hex[3].substring(2))
165 |             assert.equal(event.resourceNode, 'fullNode')
166 | 
167 |         })
168 | 
169 |     });
170 | 
171 |     describe('#contract.method.watch', async function () {
172 | 
173 |         it('should watch for an event', async function () {
174 |             
175 |             this.timeout(20000)
176 |             tronWeb.setPrivateKey(accounts.pks[3])
177 | 
178 |             let watchTest = await contract.SomeEvent().watch((err, res) => {
179 |                 if(res) {
180 |                     assert.equal(res.result._sender, accounts.hex[3])
181 |                     assert.equal(res.result._receiver, accounts.hex[4])
182 |                     assert.equal(res.result._amount, 4000)
183 |                     
184 |                     watchTest.stop() // Calls stop on itself when successful
185 |                 }
186 |             })
187 |             
188 |             contract.emitNow(accounts.hex[4], 4000).send({
189 |                 from: accounts.hex[3]
190 |             })
191 | 
192 |         })
193 | 
194 |         it('should only watch for an event with given filters',  async function () {
195 | 
196 |             this.timeout(20000)
197 |             tronWeb.setPrivateKey(accounts.pks[3])
198 |             
199 |             let watchTest = await contract.SomeEvent().watch({filters: {"_amount": "4000"}}, (err, res) => {
200 |                 if(res) { 
201 |                     assert.equal(res.result._sender, accounts.hex[3])
202 |                     assert.equal(res.result._receiver, accounts.hex[4])
203 |                     assert.equal(res.result._amount, 4000)
204 | 
205 |                     watchTest.stop() // Calls stop on itself when successful
206 |                 }
207 |             })
208 |             
209 |             contract.emitNow(accounts.hex[4], 4000).send({
210 |                 from: accounts.hex[3]
211 |             })
212 |         })
213 |     })
214 | });
215 | 


--------------------------------------------------------------------------------
/test/lib/plugin.test.js:
--------------------------------------------------------------------------------
 1 | const chai = require('chai');
 2 | const {FULL_NODE_API} = require('../helpers/config');
 3 | const assertThrow = require('../helpers/assertThrow');
 4 | const tronWebBuilder = require('../helpers/tronWebBuilder');
 5 | const TronWeb = tronWebBuilder.TronWeb;
 6 | const GetNowBlock = require('../helpers/GetNowBlock');
 7 | const BlockLib = require('../helpers/BlockLib');
 8 | const jlog = require('../helpers/jlog')
 9 | 
10 | const assert = chai.assert;
11 | 
12 | describe('TronWeb.lib.plugin', async function () {
13 | 
14 |     let tronWeb;
15 | 
16 |     before(async function () {
17 |         tronWeb = tronWebBuilder.createInstance();
18 |     });
19 | 
20 |     describe('#constructor()', function () {
21 | 
22 |         it('should have been set a full instance in tronWeb', function () {
23 | 
24 |             assert.instanceOf(tronWeb.plugin, TronWeb.Plugin);
25 |         });
26 | 
27 |     });
28 | 
29 |     describe("#plug GetNowBlock into tronWeb.trx", async function () {
30 | 
31 |         it('should register the plugin GetNowBlock', async function () {
32 | 
33 |             const someParameter = 'someValue'
34 | 
35 |             let result = tronWeb.plugin.register(GetNowBlock, {
36 |                 someParameter
37 |             })
38 |             assert.isTrue(result.skipped.includes('_parseToken'))
39 |             assert.isTrue(result.plugged.includes('getCurrentBlock'))
40 |             assert.isTrue(result.plugged.includes('getLatestBlock'))
41 | 
42 |             result = await tronWeb.trx.getCurrentBlock()
43 |             assert.isTrue(result.fromPlugin)
44 |             assert.equal(result.blockID.length, 64)
45 |             assert.isTrue(/^00000/.test(result.blockID))
46 | 
47 |             result = await tronWeb.trx.getSomeParameter()
48 |             assert.equal(result, someParameter)
49 | 
50 |         })
51 | 
52 |     });
53 | 
54 |     describe("#plug BlockLib into tronWeb at first level", async function () {
55 | 
56 |         it('should register the plugin and call a method using a promise', async function () {
57 | 
58 |             let result = tronWeb.plugin.register(BlockLib)
59 |             assert.equal(result.libs[0], 'BlockLib')
60 |             result = await tronWeb.blockLib.getCurrent()
61 |             assert.isTrue(result.fromPlugin)
62 |             assert.equal(result.blockID.length, 64)
63 |             assert.isTrue(/^00000/.test(result.blockID))
64 | 
65 |         })
66 | 
67 |         it('should register and call a method using callbacks', async function () {
68 | 
69 |             tronWeb.plugin.register(BlockLib)
70 |             return new Promise(resolve => {
71 |                 tronWeb.blockLib.getCurrent((err, result) => {
72 |                     assert.isTrue(result.fromPlugin)
73 |                     assert.equal(result.blockID.length, 64)
74 |                     assert.isTrue(/^00000/.test(result.blockID))
75 |                     resolve()
76 |                 })
77 |             })
78 |         })
79 | 
80 |         it('should not register if tronWeb is instantiated with the disablePlugins option', async function () {
81 | 
82 |             let tronWeb2 = tronWebBuilder.createInstance({disablePlugins: true});
83 |             let result = tronWeb2.plugin.register(BlockLib);
84 |             assert.isTrue(typeof result.error === 'string');
85 | 
86 |         })
87 | 
88 | 
89 |     });
90 | 
91 | });
92 | 


--------------------------------------------------------------------------------
/test/lib/providers.test.js:
--------------------------------------------------------------------------------
 1 | const chai = require('chai');
 2 | const {FULL_NODE_API} = require('../helpers/config');
 3 | const assertThrow = require('../helpers/assertThrow');
 4 | const tronWebBuilder = require('../helpers/tronWebBuilder');
 5 | const TronWeb = tronWebBuilder.TronWeb;
 6 | 
 7 | const assert = chai.assert;
 8 | 
 9 | describe('TronWeb.lib.providers', async function () {
10 | 
11 | 
12 |     describe('#constructor()', function () {
13 | 
14 |         it('should create a full instance', function () {
15 |             let provider = new TronWeb.providers.HttpProvider(FULL_NODE_API);
16 |             assert.instanceOf(provider, TronWeb.providers.HttpProvider);
17 | 
18 |             provider = new TronWeb.providers.HttpProvider
19 |             ('www.exaple.com');
20 |             assert.instanceOf(provider, TronWeb.providers.HttpProvider);
21 |         });
22 | 
23 |         it('should throw if the host is not valid', function () {
24 |             const tronWeb = tronWebBuilder.createInstance();
25 | 
26 |             assert.throws(() => new TronWeb.providers.HttpProvider(
27 |                 '$' + FULL_NODE_API
28 |             ), 'Invalid URL provided to HttpProvider');
29 | 
30 |             assert.throws(() => new TronWeb.providers.HttpProvider(
31 |                 '_localhost'
32 |             ), 'Invalid URL provided to HttpProvider');
33 | 
34 |             assert.throws(() => new TronWeb.providers.HttpProvider(
35 |                 [FULL_NODE_API]
36 |             ), 'Invalid URL provided to HttpProvider');
37 | 
38 |         });
39 | 
40 |     });
41 | 
42 |     describe('#setStatusPage()', function () {
43 | 
44 |         it('should set a status page', function () {
45 |             const provider = new TronWeb.providers.HttpProvider(FULL_NODE_API);
46 |             const statusPage = '/status';
47 |             provider.setStatusPage(statusPage);
48 |             assert.equal(provider.statusPage, statusPage);
49 |         });
50 |     });
51 | 
52 |     describe('#isConnected()', function () {
53 | 
54 |         it('should verify if the provider is connected', async function () {
55 |             const provider = new TronWeb.providers.HttpProvider(FULL_NODE_API);
56 |             assert.isTrue(await provider.isConnected('/wallet/getnowblock'));
57 | 
58 |         });
59 | 
60 | 
61 |         it('should return false if the url is not one of the expected provider', async function () {
62 |             const provider = new TronWeb.providers.HttpProvider('https://google.com');
63 |             assert.isFalse(await provider.isConnected('/wallet/getnowblock'));
64 |         });
65 |     });
66 | 
67 |     describe('#request()', function () {
68 | 
69 |         it('should request a route', async function () {
70 |             const provider = new TronWeb.providers.HttpProvider(FULL_NODE_API);
71 |             const result = await provider.request('/wallet/getnowblock');
72 |             assert.equal(result.blockID.length, 64);
73 |         });
74 | 
75 |         it('should throw if the route is missed or returns an error', async function () {
76 |             const provider = new TronWeb.providers.HttpProvider(FULL_NODE_API);
77 | 
78 |             await assertThrow(provider.request('/wallet/some-fun'),
79 |                 'Request failed with status code 404');
80 | 
81 |         });
82 | 
83 | 
84 |     });
85 | 
86 | 
87 | });
88 | 


--------------------------------------------------------------------------------
/test/setup/browser.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../src').default;
2 | 


--------------------------------------------------------------------------------
/test/setup/node.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../dist/TronWeb.node');
2 | 


--------------------------------------------------------------------------------
/test/utils/abi.test.js:
--------------------------------------------------------------------------------
  1 | const chai = require('chai');
  2 | const {ADDRESS_HEX, ADDRESS_BASE58} = require('../helpers/config');
  3 | const tronWebBuilder = require('../helpers/tronWebBuilder');
  4 | 
  5 | const assert = chai.assert;
  6 | 
  7 | describe('TronWeb.utils.abi', function () {
  8 | 
  9 |     describe('#decodeParams()', function () {
 10 |         it('should decode abi coded params passing types and output', function () {
 11 | 
 12 |             const tronWeb = tronWebBuilder.createInstance();
 13 |             const types = ['string', 'string', 'uint8', 'bytes32', 'uint256'];
 14 |             const output = '0x00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000012dc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011506920446179204e30306220546f6b656e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035049450000000000000000000000000000000000000000000000000000000000';
 15 | 
 16 |             const expected = [
 17 |                 'Pi Day N00b Token',
 18 |                 'PIE',
 19 |                 18,
 20 |                 '0xdc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece7',
 21 |                 0
 22 |             ];
 23 | 
 24 | 
 25 |             const result = tronWeb.utils.abi.decodeParams(types, output);
 26 | 
 27 |             for(let i = 0; i < expected.length; i++) {
 28 |                 assert.equal(result[i], expected[i]);
 29 |             }
 30 |         });
 31 | 
 32 |         it('should decode abi coded params passing names, types and output', function () {
 33 | 
 34 |             const tronWeb = tronWebBuilder.createInstance();
 35 |             const names = ['Token', 'Graph', 'Qty', 'Bytes', 'Total'];
 36 |             const types = ['string', 'string', 'uint8', 'bytes32', 'uint256'];
 37 |             const output = '0x00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000012dc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011506920446179204e30306220546f6b656e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035049450000000000000000000000000000000000000000000000000000000000';
 38 | 
 39 |             const expected = {
 40 |                 Token: 'Pi Day N00b Token',
 41 |                 Graph: 'PIE',
 42 |                 Qty: 18,
 43 |                 Bytes: '0xdc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece7',
 44 |                 Total: 0
 45 |             };
 46 | 
 47 |             const result = tronWeb.utils.abi.decodeParams(names, types, output);
 48 |             for(let i in expected) {
 49 |                 assert.equal(result[i], expected[i]);
 50 |             }
 51 |         });
 52 | 
 53 |         it('should throw if the string does not start with 0x', function () {
 54 | 
 55 |             const tronWeb = tronWebBuilder.createInstance();
 56 |             const types = ['string', 'string', 'uint8', 'bytes32', 'uint256'];
 57 |             const output =
 58 |                 '00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000012dc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011506920446179204e30306220546f6b656e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035049450000000000000000000000000000000000000000000000000000000000';
 59 | 
 60 |             assert.throws(() => {
 61 |                 tronWeb.utils.abi.decodeParams(types, output)
 62 |             }, 'hex string must have 0x prefix');
 63 |         });
 64 | 
 65 |         it('should throw if the output format is wrong', function () {
 66 | 
 67 |             const tronWeb = tronWebBuilder.createInstance();
 68 |             const types = ['string', 'string', 'uint8', 'bytes32', 'uint256'];
 69 |             const output = '0x00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000012dc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011506920446179204e30306220546f6b656e0000000000000000000000000000005049450000000000000000000000000000000000000000000000000000000000';
 70 | 
 71 |             assert.throws(() => {
 72 |                 tronWeb.utils.abi.decodeParams(types, output)
 73 |             }, 'dynamic bytes count too large');
 74 |         });
 75 | 
 76 |         it('should throw if the output is invalid', function () {
 77 | 
 78 |             const tronWeb = tronWebBuilder.createInstance();
 79 |             const types = ['string'];
 80 |             const output = '0x6630f88f000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000046173646600000000000000000000000000000000000000000000000000000000';
 81 | 
 82 |             assert.throws(() => {
 83 |                 tronWeb.utils.abi.decodeParams(types, output)
 84 |             }, 'The encoded string is not valid. Its length must be a multiple of 64.');
 85 |         });
 86 | 
 87 |         it('should decode if the output is prefixed with the method hash', function () {
 88 | 
 89 |             const tronWeb = tronWebBuilder.createInstance();
 90 |             const types = ['string'];
 91 |             const output = '0x6630f88f000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000046173646600000000000000000000000000000000000000000000000000000000';
 92 | 
 93 |             const result = tronWeb.utils.abi.decodeParams(types, output, true)
 94 |             assert.equal(result, 'asdf')
 95 |         });
 96 |     });
 97 | 
 98 | 
 99 |     describe('#encodeParams()', function () {
100 |         it('should encode abi coded params passing types and values', function () {
101 | 
102 |             const tronWeb = tronWebBuilder.createInstance();
103 |             const types = ['string', 'string', 'uint8', 'bytes32', 'uint256'];
104 |             const values = [
105 |                 'Pi Day N00b Token',
106 |                 'PIE',
107 |                 18,
108 |                 '0xdc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece7',
109 |                 0
110 |             ];
111 | 
112 |             const expected = '0x00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000012dc03b7993bad736ad595eb9e3ba51877ac17ecc31d2355f8f270125b9427ece700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011506920446179204e30306220546f6b656e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035049450000000000000000000000000000000000000000000000000000000000';
113 | 
114 | 
115 |             const result = tronWeb.utils.abi.encodeParams(types, values);
116 | 
117 |             for(let i = 0; i < expected.length; i++) {
118 |                 assert.equal(result[i], expected[i]);
119 |             }
120 |         });
121 | 
122 |         it('should encode abi coded params passing addresses in hex and base58 mode', function () {
123 | 
124 |             const tronWeb = tronWebBuilder.createInstance();
125 |             const types = ['string', 'address', 'address'];
126 |             const values = [
127 |                 'Onwer',
128 |                 ADDRESS_HEX,
129 |                 ADDRESS_BASE58
130 |             ];
131 | 
132 |             const expected = '0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000928c9af0651632157ef27a2cf17ca72c575a4d21000000000000000000000000928c9af0651632157ef27a2cf17ca72c575a4d2100000000000000000000000000000000000000000000000000000000000000054f6e776572000000000000000000000000000000000000000000000000000000';
133 |             const result = tronWeb.utils.abi.encodeParams(types, values);
134 | 
135 |             for(let i = 0; i < expected.length; i++) {
136 |                 assert.equal(result[i], expected[i]);
137 |             }
138 |         });
139 |     });
140 | });
141 | 


--------------------------------------------------------------------------------
/test/utils/accounts.test.js:
--------------------------------------------------------------------------------
 1 | const chai = require('chai');
 2 | const {ADDRESS_HEX, ADDRESS_BASE58} = require('../helpers/config');
 3 | const tronWebBuilder = require('../helpers/tronWebBuilder');
 4 | 
 5 | const assert = chai.assert;
 6 | 
 7 | describe('TronWeb.utils.accounts', function () {
 8 | 
 9 |     describe('#generateAccount()', function () {
10 | 
11 |         it("should generate a new account", async function () {
12 |             const tronWeb = tronWebBuilder.createInstance();
13 | 
14 |             const newAccount = await tronWeb.utils.accounts.generateAccount();
15 |             assert.equal(newAccount.privateKey.length, 64);
16 |             assert.equal(newAccount.publicKey.length, 130);
17 |             let address = tronWeb.address.fromPrivateKey(newAccount.privateKey);
18 |             assert.equal(address, newAccount.address.base58);
19 | 
20 |             assert.equal(tronWeb.address.toHex(address), newAccount.address.hex.toLowerCase());
21 |         });
22 |     });
23 | });
24 | 


--------------------------------------------------------------------------------
/test/utils/base58.test.js:
--------------------------------------------------------------------------------
 1 | const chai = require('chai');
 2 | const tronWebBuilder = require('../helpers/tronWebBuilder');
 3 | 
 4 | const assert = chai.assert;
 5 | 
 6 | describe('TronWeb.utils.base58', function () {
 7 | 
 8 |     describe('#encode58()', function () {
 9 | 
10 |         it("should encode a buffer in base58 string", async function () {
11 |             const tronWeb = tronWebBuilder.createInstance();
12 | 
13 |             let input = Buffer.from('0xbf7e698', 'utf-8');
14 |             let expected = 'cnTsZgYWJRAw';
15 | 
16 |             assert.equal(tronWeb.utils.base58.encode58(input), expected);
17 | 
18 |             input = [30, 78, 62, 66, 37, 65, 36, 39, 38];
19 |             expected = 'PNfgHhpd9fqF';
20 | 
21 |             assert.equal(tronWeb.utils.base58.encode58(input), expected);
22 | 
23 |             input = '0xbf7e698';
24 |             expected = 'BLw3T83';
25 | 
26 |             assert.equal(tronWeb.utils.base58.encode58(input), expected);
27 | 
28 |             input = '12354345';
29 |             expected = '3toVqjxtiu2q';
30 | 
31 |             assert.equal(tronWeb.utils.base58.encode58(input), expected);
32 |         });
33 | 
34 | 
35 |         it("should return '' or '1' if passing something different from a buffer", async function () {
36 |             // TODO. Is this what we want?
37 |             const tronWeb = tronWebBuilder.createInstance();
38 | 
39 |             assert.equal(tronWeb.utils.base58.encode58([]), '');
40 |             assert.equal(tronWeb.utils.base58.encode58('some string'), '');
41 |             assert.equal(tronWeb.utils.base58.encode58({key: 1}), '1');
42 |         });
43 |     });
44 | 
45 |     describe('#decode58()', function () {
46 | 
47 |         it("should decode a base58 string in a buffer", async function () {
48 |             const tronWeb = tronWebBuilder.createInstance();
49 | 
50 |             const input = 'cnTsZgYWJRAw';
51 |             const expected = Buffer.from('0xbf7e698', 'utf-8');
52 | 
53 |             const decoded = tronWeb.utils.base58.decode58(input)
54 | 
55 |             assert.equal(Buffer.compare(expected, Buffer.from(decoded, 'utf-8')), 0);
56 | 
57 |         });
58 | 
59 | 
60 |         it("should return [] or [0] if passing something '' or '1'", async function () {
61 |             // TODO. As above. Is this what we want?
62 |             const tronWeb = tronWebBuilder.createInstance();
63 | 
64 |             assert.equal(JSON.stringify(tronWeb.utils.base58.decode58('')), "[]");
65 |             assert.equal(JSON.stringify(tronWeb.utils.base58.decode58('1')), "[0]");
66 |         });
67 |     });
68 | 
69 | });
70 | 


--------------------------------------------------------------------------------
/test/utils/bytes.test.js:
--------------------------------------------------------------------------------
  1 | const chai = require('chai');
  2 | const tronWebBuilder = require('../helpers/tronWebBuilder');
  3 | 
  4 | const assert = chai.assert;
  5 | 
  6 | describe('TronWeb.utils.bytes', function () {
  7 | 
  8 |     describe('#byte2hexStr()', function () {
  9 | 
 10 |         it("should convert a byte to a hex string", async function () {
 11 |             const tronWeb = tronWebBuilder.createInstance();
 12 | 
 13 |             assert.equal(tronWeb.utils.bytes.byte2hexStr(21), '15');
 14 |             assert.equal(tronWeb.utils.bytes.byte2hexStr(33), '21');
 15 |             assert.equal(tronWeb.utils.bytes.byte2hexStr(78), '4E');
 16 |             assert.equal(tronWeb.utils.bytes.byte2hexStr(156), '9C');
 17 |             assert.equal(tronWeb.utils.bytes.byte2hexStr(200), 'C8');
 18 | 
 19 |         });
 20 | 
 21 |         it("should throw if something else than a byte is passed as input", async function () {
 22 |             const tronWeb = tronWebBuilder.createInstance();
 23 | 
 24 |             assert.throws(() => {
 25 |                 tronWeb.utils.bytes.byte2hexStr('15')
 26 |             }, 'Input must be a number');
 27 | 
 28 |             assert.throws(() => {
 29 |                 tronWeb.utils.bytes.byte2hexStr(-15)
 30 |             }, 'Input must be a byte');
 31 | 
 32 |             assert.throws(() => {
 33 |                 tronWeb.utils.bytes.byte2hexStr(1455)
 34 |             }, 'Input must be a byte');
 35 | 
 36 |         });
 37 |     });
 38 | 
 39 |     describe('#bytesToString()', function () {
 40 | 
 41 |         it("should convert an array of bytes to a hex string", async function () {
 42 |             const tronWeb = tronWebBuilder.createInstance();
 43 | 
 44 |             assert.equal(tronWeb.utils.bytes.bytesToString([78, 112, 87, 69, 99, 65]), 'NpWEcA');
 45 | 
 46 |             assert.equal(tronWeb.utils.bytes.bytesToString([1178, 2112, 1087, 969]), 'Қࡀпω');
 47 | 
 48 |         });
 49 | 
 50 |         it("should return the input if the input is a string", async function () {
 51 |             const tronWeb = tronWebBuilder.createInstance();
 52 | 
 53 |             assert.equal(tronWeb.utils.bytes.bytesToString('NpWEcA'), 'NpWEcA');
 54 | 
 55 |             assert.equal(tronWeb.utils.bytes.bytesToString('Қࡀпω'), 'Қࡀпω');
 56 |         });
 57 |     });
 58 | 
 59 | 
 60 |     describe('#hextoString()', function () {
 61 | 
 62 |         it("should convert an hex string to a utf-8 string", async function () {
 63 |             const tronWeb = tronWebBuilder.createInstance();
 64 | 
 65 |             assert.equal(tronWeb.utils.bytes.hextoString('af43ed56aa77'), '¯CíVªw');
 66 |             assert.equal(tronWeb.utils.bytes.hextoString('0xaf43'), '¯C');
 67 |             assert.equal(tronWeb.utils.bytes.hextoString('49206C6F7665206461726B20636F6D6564696573'), 'I love dark comedies');
 68 | 
 69 |         });
 70 |     });
 71 | 
 72 |     describe('#byteArray2hexStr()', function () {
 73 | 
 74 |         it("should convert an array of bytes to a hex string", async function () {
 75 |             const tronWeb = tronWebBuilder.createInstance();
 76 | 
 77 |             assert.equal(tronWeb.utils.bytes.byteArray2hexStr([73, 32, 108, 111, 118, 101, 32, 100, 97, 114, 107, 32, 99, 111, 109, 101, 100, 105, 101, 115]), '49206C6F7665206461726B20636F6D6564696573');
 78 | 
 79 |         });
 80 | 
 81 |         it("should throw if the array of bytes is not valid", async function () {
 82 |             const tronWeb = tronWebBuilder.createInstance();
 83 | 
 84 |             assert.throws(() => {
 85 |                 tronWeb.utils.bytes.byteArray2hexStr([73, -32, 108])
 86 |             }, 'Input must be a byte');
 87 |         });
 88 |     });
 89 | 
 90 | 
 91 |     describe('#base64EncodeToString()', function () {
 92 |         it("should encode a bytes array to a base64 string", async function () {
 93 |             const tronWeb = tronWebBuilder.createInstance();
 94 | 
 95 |             let result = tronWeb.utils.bytes.base64EncodeToString([73, 32, 108, 111, 118, 101, 32, 100, 97, 114, 107, 32, 99, 111, 109, 101, 100, 105, 101, 115]
 96 |             );
 97 | 
 98 |             assert.equal(result, 'SSBsb3ZlIGRhcmsgY29tZWRpZXM=');
 99 |         });
100 |     });
101 | 
102 |     describe('#base64DecodeFromString()', function () {
103 |         it("should decode a base64 string", async function () {
104 |             const tronWeb = tronWebBuilder.createInstance();
105 | 
106 |             let result = tronWeb.utils.bytes.base64DecodeFromString('SSBsb3ZlIGRhcmsgY29tZWRpZXM=');
107 | 
108 |             let string = tronWeb.utils.bytes.bytesToString(result);
109 |             assert.equal(string, 'I love dark comedies');
110 | 
111 |         });
112 | 
113 |     });
114 | 
115 | });
116 | 


--------------------------------------------------------------------------------
/test/utils/code.test.js:
--------------------------------------------------------------------------------
  1 | const chai = require('chai');
  2 | const tronWebBuilder = require('../helpers/tronWebBuilder');
  3 | 
  4 | const assert = chai.assert;
  5 | 
  6 | describe('TronWeb.utils.code', function () {
  7 | 
  8 |     describe('#bin2String()', function () {
  9 | 
 10 |         it("should convert a byte to a hex string", async function () {
 11 |             const tronWeb = tronWebBuilder.createInstance();
 12 | 
 13 |             assert.equal(tronWeb.utils.code.bin2String([78, 112, 87, 69, 99, 65]), 'NpWEcA');
 14 |         });
 15 |     });
 16 | 
 17 |     describe('#arrayEquals()', function () {
 18 | 
 19 |         it("should compare two arrays to see if they are equal", async function () {
 20 |             const tronWeb = tronWebBuilder.createInstance();
 21 | 
 22 |             const a = [78, 112, 87, 69, 99, 65];
 23 |             const b = [78, 112, 69, 99, 65];
 24 |             const c = [78, 112, 69, 99, 65];
 25 |             const d = [78, 'casa', {a: 1}, 99, [65, 2]];
 26 |             const e = [78, 'casa', {a: 1}, 99, [65, 2]];
 27 | 
 28 |             assert.isTrue(tronWeb.utils.code.arrayEquals(a, a));
 29 |             assert.isTrue(tronWeb.utils.code.arrayEquals(b, c));
 30 |             assert.isTrue(tronWeb.utils.code.arrayEquals(d, e));
 31 | 
 32 |             assert.isFalse(tronWeb.utils.code.arrayEquals(a, b));
 33 |             assert.isFalse(tronWeb.utils.code.arrayEquals(d, e, true));
 34 | 
 35 |         });
 36 |     });
 37 | 
 38 |     describe('#stringToBytes()', function () {
 39 | 
 40 |         it("should convert a string to an array of bytes", async function () {
 41 |             const tronWeb = tronWebBuilder.createInstance();
 42 | 
 43 |             const a = 'Қࡀпω';
 44 | 
 45 |             assert.isTrue(tronWeb.utils.code.arrayEquals(tronWeb.utils.code.stringToBytes('Қࡀпω'), [210, 154, 224, 161, 128, 208, 191, 207, 137], true));
 46 | 
 47 |             // TODO We have something wrong, in fact this should be the reverse of the command above:
 48 |             assert.equal(tronWeb.utils.bytes.bytesToString([1178, 2112, 1087, 969]), 'Қࡀпω');
 49 | 
 50 |         });
 51 | 
 52 |         it("should throw if something else than a string is passed as input", async function () {
 53 |             const tronWeb = tronWebBuilder.createInstance();
 54 | 
 55 |             assert.throws(() => {
 56 |                 tronWeb.utils.code.stringToBytes([210, 154, 224, 161, 128, 208, 191, 207, 137])
 57 |             }, 'The passed string is not a string');
 58 | 
 59 |             assert.throws(() => {
 60 |                 tronWeb.utils.code.stringToBytes(356253)
 61 |             }, 'The passed string is not a string');
 62 | 
 63 |         });
 64 |     });
 65 | 
 66 |     describe('#hexChar2byte()', function () {
 67 | 
 68 |         it("should convert an hex char to a byte", async function () {
 69 |             const tronWeb = tronWebBuilder.createInstance();
 70 | 
 71 |             assert.equal(tronWeb.utils.code.hexChar2byte('0'), 0);
 72 |             assert.equal(tronWeb.utils.code.hexChar2byte('D'), 13);
 73 |             assert.equal(tronWeb.utils.code.hexChar2byte('d'), 13);
 74 |             assert.equal(tronWeb.utils.code.hexChar2byte('7'), 7);
 75 | 
 76 |         });
 77 | 
 78 |         it("should throw if something else than a string is passed as input", async function () {
 79 |             const tronWeb = tronWebBuilder.createInstance();
 80 | 
 81 |             assert.throws(() => {
 82 |                 tronWeb.utils.code.hexChar2byte(12)
 83 |             }, 'The passed hex char is not a valid hex char');
 84 | 
 85 |             assert.throws(() => {
 86 |                 tronWeb.utils.code.hexChar2byte('Z')
 87 |             }, 'The passed hex char is not a valid hex char');
 88 | 
 89 |         });
 90 |     });
 91 | 
 92 |     describe('#isHexChar()', function () {
 93 | 
 94 |         it("should verify that an hex char is a valid hex char", async function () {
 95 |             const tronWeb = tronWebBuilder.createInstance();
 96 | 
 97 |             assert.equal(tronWeb.utils.code.isHexChar('0'), 1);
 98 |             assert.equal(tronWeb.utils.code.isHexChar('e'), 1);
 99 |             assert.equal(tronWeb.utils.code.isHexChar('D'), 1);
100 | 
101 |             assert.equal(tronWeb.utils.code.isHexChar('Z'), 0);
102 |             assert.equal(tronWeb.utils.code.isHexChar(66), 0);
103 |         });
104 |     });
105 | 
106 |     describe('#hexStr2byteArray()', function () {
107 | 
108 |         it("should verify that an hex char is a valid hex char", async function () {
109 |             const tronWeb = tronWebBuilder.createInstance();
110 | 
111 |             assert.isTrue(tronWeb.utils.code.arrayEquals(tronWeb.utils.code.hexStr2byteArray('49206C6F7665206461726B20636F6D6564696573'), [73, 32, 108, 111, 118, 101, 32, 100, 97, 114, 107, 32, 99, 111, 109, 101, 100, 105, 101, 115]));
112 | 
113 |         });
114 | 
115 |         it("should throw if we pass an invalid hex string", async function () {
116 |             const tronWeb = tronWebBuilder.createInstance();
117 | 
118 |             assert.throws(() => {
119 |                 tronWeb.utils.code.hexStr2byteArray('ZASSyue')
120 |             }, 'The passed hex char is not a valid hex string');
121 | 
122 |             assert.throws(() => {
123 |                 tronWeb.utils.code.hexStr2byteArray(123)
124 |             }, 'The passed string is not a string');
125 | 
126 |         });
127 |     });
128 | 
129 |     describe('#strToDate()', function () {
130 | 
131 |         it("should verify that an hex char is a valid hex char", async function () {
132 |             const tronWeb = tronWebBuilder.createInstance();
133 | 
134 |             let input = '2018-09-23 13-45-03';
135 |             let regex = RegExp('Sep 23 2018 13:45:03')
136 |             assert.isTrue(regex.test(tronWeb.utils.code.strToDate(input).toString()));
137 | 
138 |             input = '2018-09-23';
139 |             regex = RegExp('Sep 23 2018 00:00:00')
140 |             assert.isTrue(regex.test(tronWeb.utils.code.strToDate(input).toString()));
141 | 
142 |         });
143 | 
144 |         it("should throw if we pass an invalid hex string", async function () {
145 |             const tronWeb = tronWebBuilder.createInstance();
146 | 
147 |             assert.throws(() => {
148 |                 tronWeb.utils.code.strToDate('2018-02-')
149 |             }, 'The passed date string is not valid');
150 | 
151 |             assert.throws(() => {
152 |                 tronWeb.utils.code.strToDate(123)
153 |             }, 'The passed date string is not valid');
154 | 
155 |             assert.throws(() => {
156 |                 tronWeb.utils.code.strToDate('2018-0212')
157 |             }, 'The passed date string is not valid');
158 | 
159 |             assert.throws(() => {
160 |                 tronWeb.utils.code.strToDate('90-22-21')
161 |             }, 'The passed date string is not valid');
162 |         });
163 |     });
164 | 
165 |     describe('#isNumber()', function () {
166 | 
167 |         it("should verify that an numeric char is a number", async function () {
168 |             const tronWeb = tronWebBuilder.createInstance();
169 | 
170 |             assert.equal(tronWeb.utils.code.isNumber('0'), 1);
171 |             assert.equal(tronWeb.utils.code.isHexChar('Z'), 0);
172 |         });
173 |     });
174 | 
175 |     describe('#getStringType()', function () {
176 | 
177 |         it("should return the type of a string", async function () {
178 |             const tronWeb = tronWebBuilder.createInstance();
179 | 
180 |             assert.equal(tronWeb.utils.code.getStringType('bf7e69851988c80e5484e52f4f6aca99479458b6'), 1);
181 | 
182 |             // TODO Should the next test return 1?
183 |             assert.equal(tronWeb.utils.code.getStringType('4136b9c3690c3be15a4ad697965b1e5e088ae131f2'), 3);
184 | 
185 |             assert.equal(tronWeb.utils.code.getStringType('3534'), 2);
186 |             assert.equal(tronWeb.utils.code.getStringType('ERC20Token'), 3);
187 | 
188 |             assert.equal(tronWeb.utils.code.getStringType(3.45), -1);
189 |         });
190 |     });
191 | });
192 | 


--------------------------------------------------------------------------------
/test/utils/index.test.js:
--------------------------------------------------------------------------------
  1 | const chai = require('chai');
  2 | const tronWebBuilder = require('../helpers/tronWebBuilder');
  3 | const TronWeb = tronWebBuilder.TronWeb;
  4 | const BigNumber = require('bignumber.js');
  5 | 
  6 | const assert = chai.assert;
  7 | 
  8 | describe('TronWeb.utils', function () {
  9 | 
 10 |     describe("#isValidURL()", function () {
 11 | 
 12 |         it('should verify good urls', function () {
 13 | 
 14 |             const tronWeb = tronWebBuilder.createInstance();
 15 | 
 16 |             assert.isTrue(tronWeb.utils.isValidURL('https://some.example.com:9090/casa?qe=3'))
 17 |             assert.isTrue(tronWeb.utils.isValidURL('www.example.com/welcome'))
 18 | 
 19 |             assert.isFalse(tronWeb.utils.isValidURL('http:/some.example.com'))
 20 | 
 21 |             assert.isFalse(tronWeb.utils.isValidURL(['http://example.com']))
 22 | 
 23 |         })
 24 | 
 25 |     });
 26 | 
 27 |     describe("#isArray()", function () {
 28 | 
 29 |         it('should verify that a value is an array', function () {
 30 |             const tronWeb = tronWebBuilder.createInstance();
 31 | 
 32 |             assert.isTrue(tronWeb.utils.isArray([]));
 33 |             assert.isTrue(tronWeb.utils.isArray([[2], {a: 3}]));
 34 | 
 35 |             assert.isFalse(tronWeb.utils.isArray({}));
 36 |             assert.isFalse(tronWeb.utils.isArray("Array"));
 37 | 
 38 |         })
 39 | 
 40 |     });
 41 | 
 42 | 
 43 |     describe("#isJson()", function () {
 44 | 
 45 |         it('should verify that a value is a JSON string', function () {
 46 |             const tronWeb = tronWebBuilder.createInstance();
 47 | 
 48 |             assert.isTrue(tronWeb.utils.isJson('[]'));
 49 |             assert.isTrue(tronWeb.utils.isJson('{"key":"value"}'));
 50 |             assert.isTrue(tronWeb.utils.isJson('"json"'));
 51 | 
 52 |             assert.isFalse(tronWeb.utils.isJson({}));
 53 |             assert.isFalse(tronWeb.utils.isJson("json"));
 54 | 
 55 |         })
 56 | 
 57 |     });
 58 | 
 59 |     describe("#isBoolean()", function () {
 60 | 
 61 |         it('should verify that a value is a JSON string', function () {
 62 |             const tronWeb = tronWebBuilder.createInstance();
 63 | 
 64 |             assert.isTrue(tronWeb.utils.isBoolean(true));
 65 |             assert.isTrue(tronWeb.utils.isBoolean('a' == []));
 66 | 
 67 |             assert.isFalse(tronWeb.utils.isBoolean({}));
 68 |             assert.isFalse(tronWeb.utils.isBoolean("json"));
 69 | 
 70 |         })
 71 | 
 72 |     });
 73 | 
 74 |     describe("#isBigNumber()", function () {
 75 | 
 76 |         it('should verify that a value is a JSON string', function () {
 77 |             const tronWeb = tronWebBuilder.createInstance();
 78 | 
 79 |             const bigNumber = BigNumber('1234565432123456778765434456777')
 80 | 
 81 |             assert.isTrue(tronWeb.utils.isBigNumber(bigNumber));
 82 | 
 83 |             assert.isFalse(tronWeb.utils.isBigNumber('0x09e80f665949b63b39f3850127eb29b55267306b69e2104c41c882e076524a1c'));
 84 |             assert.isFalse(tronWeb.utils.isBigNumber({}));
 85 |             assert.isFalse(tronWeb.utils.isBigNumber("json"));
 86 | 
 87 |         })
 88 | 
 89 |     });
 90 | 
 91 | 
 92 |     describe("#isString()", function () {
 93 | 
 94 |         it('should verify that a valyue is a string', function () {
 95 |             const tronWeb = tronWebBuilder.createInstance();
 96 | 
 97 |             assert.isTrue(tronWeb.utils.isString('str'));
 98 |             assert.isTrue(tronWeb.utils.isString(13..toString()));
 99 | 
100 |             assert.isFalse(tronWeb.utils.isString(2));
101 | 
102 |         })
103 | 
104 |     });
105 | 
106 |     describe("#isFunction()", function () {
107 | 
108 |         it('should verify that a value is a function', function () {
109 |             const tronWeb = tronWebBuilder.createInstance();
110 | 
111 |             assert.isTrue(tronWeb.utils.isFunction(new Function()));
112 |             assert.isTrue(tronWeb.utils.isFunction(() => {
113 |             }));
114 |             assert.isTrue(tronWeb.utils.isFunction(tronWeb.utils.isFunction));
115 | 
116 |             assert.isFalse(tronWeb.utils.isFunction({function: new Function}));
117 | 
118 |         })
119 | 
120 |     });
121 | 
122 |     describe('#isHex()', function () {
123 |         it('should verify that a string is an hex string', function () {
124 | 
125 |             const tronWeb = tronWebBuilder.createInstance();
126 | 
127 |             let input = '0x1';
128 |             let expected = true;
129 |             assert.equal(tronWeb.utils.isHex(input), expected);
130 | 
131 |             input = '0x0';
132 |             expected = true;
133 |             assert.equal(tronWeb.utils.isHex(input), expected);
134 | 
135 |             input = '0x73616c616d6f6e';
136 |             expected = true;
137 |             assert.equal(tronWeb.utils.isHex(input), expected);
138 | 
139 |             input = '73616c616d6f';
140 |             expected = true;
141 |             assert.equal(tronWeb.utils.isHex(input), expected);
142 | 
143 |             input = '0x73616c616d6fsz';
144 |             expected = false;
145 |             assert.equal(tronWeb.utils.isHex(input), expected);
146 | 
147 |             input = 'x898989';
148 |             expected = false;
149 |             assert.equal(tronWeb.utils.isHex(input), expected);
150 | 
151 |         });
152 | 
153 |     });
154 | 
155 |     describe("#isInteger()", function () {
156 | 
157 |         it('should verify that a value is an integer', function () {
158 |             const tronWeb = tronWebBuilder.createInstance();
159 | 
160 |             assert.isTrue(tronWeb.utils.isInteger(2345434));
161 |             assert.isTrue(tronWeb.utils.isInteger(-234e4));
162 | 
163 |             assert.isFalse(tronWeb.utils.isInteger(3.4));
164 |             assert.isFalse(tronWeb.utils.isInteger('integer'));
165 | 
166 |         })
167 | 
168 |     });
169 | 
170 |     describe("#hasProperty()", function () {
171 | 
172 |         it('should verify that an object has a specific property', function () {
173 |             const tronWeb = tronWebBuilder.createInstance();
174 | 
175 |             assert.isTrue(tronWeb.utils.hasProperty({p: 2}, 'p'));
176 |             assert.isFalse(tronWeb.utils.hasProperty([{p: 2}], 'p'));
177 | 
178 |             assert.isFalse(tronWeb.utils.hasProperty({a: 2}, 'p'));
179 | 
180 |         })
181 | 
182 |     });
183 | 
184 |     describe("#hasProperties()", function () {
185 | 
186 |         it('should verify that an object has some specific properties', function () {
187 |             const tronWeb = tronWebBuilder.createInstance();
188 | 
189 |             assert.isTrue(tronWeb.utils.hasProperties({p: 2, s: 2}, 'p', 's'));
190 | 
191 |             assert.isFalse(tronWeb.utils.hasProperties({p: 2, s: 2}, 'p', 'q'));
192 | 
193 |         })
194 | 
195 |     });
196 | 
197 | 
198 |     describe("#mapEvent()", function () {
199 | 
200 |         it('should map an event result', function () {
201 |             const tronWeb = tronWebBuilder.createInstance();
202 | 
203 |             const event = {
204 |                 block_number: 'blockNumber',
205 |                 block_timestamp: 'blockTimestamp',
206 |                 contract_address: 'contractAddress',
207 |                 event_name: 'eventName',
208 |                 transaction_id: 'transactionId',
209 |                 result: 'result',
210 |                 resource_Node: 'resourceNode'
211 |             }
212 | 
213 |             const expected = {
214 |                 block: 'blockNumber',
215 |                 timestamp: 'blockTimestamp',
216 |                 contract: 'contractAddress',
217 |                 name: 'eventName',
218 |                 transaction: 'transactionId',
219 |                 result: 'result',
220 |                 resourceNode: 'resourceNode'
221 |             }
222 | 
223 |             const mapped = tronWeb.utils.mapEvent(event)
224 |             for(let key in mapped) {
225 |                 assert.equal(mapped[key], expected[key])
226 |             }
227 | 
228 |         })
229 | 
230 |     });
231 | 
232 |     describe('#parseEvent', function () {
233 |         // TODO
234 |     });
235 | 
236 |     describe("#padLeft()", function () {
237 | 
238 |         it('should return the pad left of a string', function () {
239 |             const tronWeb = tronWebBuilder.createInstance();
240 | 
241 |             assert.equal(tronWeb.utils.padLeft('09e80f', '0', 12), '00000009e80f');
242 |             // assert.equal(tronWeb.utils.padLeft(new Function, '0', 32), '0000000function anonymous() {\n\n}');
243 |             assert.equal(tronWeb.utils.padLeft(3.4e3, '0', 12), '000000003400');
244 | 
245 |         })
246 | 
247 |     });
248 | 
249 |     describe("#ethersUtils()", function () {
250 | 
251 |         it('should import sha256 from ethers and has a string', function () {
252 |             const tronWeb = tronWebBuilder.createInstance();
253 | 
254 |             const string = '0x' + Buffer.from('some string').toString('hex');
255 |             const hash = tronWeb.utils.ethersUtils.sha256(string);
256 | 
257 |             assert.equal(hash, '0x61d034473102d7dac305902770471fd50f4c5b26f6831a56dd90b5184b3c30fc');
258 | 
259 |         })
260 | 
261 |     });
262 | 
263 | });
264 | 


--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
  1 | const path = require('path');
  2 | const externals = require('webpack-node-externals');
  3 | 
  4 | const basePlugins = [
  5 |     '@babel/plugin-proposal-numeric-separator',
  6 |     '@babel/plugin-proposal-class-properties',
  7 |     '@babel/plugin-transform-runtime',
  8 |     '@babel/plugin-proposal-object-rest-spread'
  9 | ];
 10 | 
 11 | const mode = process.env.NODE_ENV || 'production'
 12 | 
 13 | const baseConfig = {
 14 |     entry: path.resolve(__dirname, 'src', 'index.js'),
 15 |     module: {
 16 |         rules: [
 17 |             {
 18 |                 test: /\.js$/,
 19 |                 exclude: /(node_modules|bower_components)/,
 20 |                 use: {
 21 |                     loader: 'babel-loader',
 22 |                     options: {
 23 |                         presets: [
 24 |                             ['@babel/env', {
 25 |                                 targets: {
 26 |                                     browsers: [
 27 |                                         '>0.25%',
 28 |                                         'not dead'
 29 |                                     ]
 30 |                                 }
 31 |                             }]
 32 |                         ],
 33 |                         plugins: basePlugins
 34 |                     }
 35 |                 }
 36 |             }
 37 |         ]
 38 |     },
 39 |     resolve: {
 40 |         modules: [
 41 |             'node_modules',
 42 |             path.resolve(__dirname, 'src')
 43 |         ],
 44 |     },
 45 |     devtool: 'source-map',
 46 |     mode
 47 | };
 48 | 
 49 | nodePlugins = [
 50 |     ...basePlugins
 51 | ]
 52 | 
 53 | if (mode === 'development') {
 54 |     nodePlugins.push('source-map-support')
 55 | }
 56 | 
 57 | module.exports = [
 58 |     {
 59 |         ...baseConfig,
 60 |         output: {
 61 |             path: path.resolve(__dirname, 'dist'),
 62 |             filename: 'TronWeb.node.js',
 63 |             libraryTarget: 'commonjs2',
 64 |             libraryExport: 'default'
 65 |         },
 66 |         module: {
 67 |             rules: [
 68 |                 {
 69 |                     test: /\.js$/,
 70 |                     exclude: /(node_modules|bower_components)/,
 71 |                     use: {
 72 |                         loader: 'babel-loader',
 73 |                         options: {
 74 |                             presets: [
 75 |                                 ['@babel/env', {
 76 |                                     targets: {
 77 |                                         node: 6
 78 |                                     },
 79 |                                     forceAllTransforms: true
 80 |                                 }]
 81 |                             ],
 82 |                             plugins: nodePlugins
 83 |                         }
 84 |                     }
 85 |                 }
 86 |             ]
 87 |         },
 88 |         externals: [ externals() ],
 89 |         target: 'node'
 90 |     },
 91 |     {
 92 |         ...baseConfig,
 93 |         output: {
 94 |             path: path.resolve(__dirname, 'dist'),
 95 |             filename: 'TronWeb.js',
 96 |             library: 'TronWeb',
 97 |             libraryTarget: 'umd',
 98 |             libraryExport: 'default',
 99 |             umdNamedDefine: true
100 |         },
101 |     }
102 | ];
103 | 


--------------------------------------------------------------------------------