TronBox

https://tronbox.io/docs
Admin
TronBox is a development framework for compiling, testing, and deploying smart contracts on the TRON...
Tokens:49,904
Snippets:409
Trust Score:7.1
Update:2 days ago
Show doc for...
Tokens:
Raw
### Install Node.js v20 with nvm

Source: https://tronbox.io/docs/guides/installation

Use nvm to install a compatible version of Node.js. The example installs Node.js v20.

```shell
nvm install 20
```

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

### Install and Initialize TronBox (Hardhat Developers)

Source: https://tronbox.io/docs/migration/overview

Commands to install TronBox globally (unlike Hardhat's local installation) and initialize a project.

```shell
# Install TronBox globally (unlike Hardhat's local installation)
npm install -g tronbox

# Initialize a project
tronbox init
```

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

### Install and Initialize TronBox (Truffle Developers)

Source: https://tronbox.io/docs/migration/overview

Commands to install TronBox globally and initialize a project, similar to Truffle workflow.

```shell
# Install TronBox (similar to Truffle)
npm install -g tronbox

# Initialize a project
tronbox init
```

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

### Install TronBox globally with bun

Source: https://tronbox.io/docs/

Use this command to install TronBox globally via bun. Requires bun to be installed.

```sh
bun install -g tronbox
```

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

### Install nvm using wget

Source: https://tronbox.io/docs/guides/installation

Alternative to curl for downloading and running the nvm installation script. Works on Linux and macOS.

```shell
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash
```

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

### Hardhat test example using describe and expect

Source: https://tronbox.io/docs/migration/tronbox-vs-hardhat

Shows a Hardhat test using `describe`, `it`, `beforeEach`, and `expect`. Deploys the contract with `ethers.getContractFactory` and `deploy()`. Uses `ethers.getSigners()` to get accounts.

```javascript
// Hardhat
const { expect } = require('chai');

describe('MyContract', function () {
  let contract;
  let owner;

  beforeEach(async function () {
    [owner] = await ethers.getSigners();
    const MyContract = await ethers.getContractFactory('MyContract');
    contract = await MyContract.deploy();
  });

  it('should work', async function () {
    expect(await contract.getValue()).to.equal(0);
  });
});
```

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

### Install npm package with npm install

Source: https://tronbox.io/docs/guides/work-with-npm

Installs the example-tronbox-library package into the current project's node_modules directory, making it available for import in contracts and JavaScript code.

```shell
cd my_project && npm install example-tronbox-library
```

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

### Install nvm using curl

Source: https://tronbox.io/docs/guides/installation

Use curl to download and run the nvm installation script. This is the recommended method for Linux and macOS to avoid permission errors when installing Node.js globally.

```shell
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash
```

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

### Install TronBox globally with pnpm

Source: https://tronbox.io/docs/

Use this command to install TronBox globally via pnpm. Requires pnpm to be installed.

```sh
pnpm add -g tronbox
```

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

### Install TronBox globally with npm

Source: https://tronbox.io/docs/

Use this command to install TronBox globally via npm. Requires Node.js and npm to be installed.

```sh
npm install -g tronbox
```

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

### deployer.link examples

Source: https://tronbox.io/docs/guides/deploy-contracts

Shows how to link an already-deployed library to one or multiple contracts. The destinations argument can be a single contract or an array. Contracts that don't rely on the library are ignored.

```javascript
// Deploy library LibA, then link LibA to contract B, then deploy B.
deployer.deploy(LibA);
deployer.link(LibA, B);
deployer.deploy(B);

// Link LibA to many contracts
deployer.link(LibA, [B, C, D]);
```

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

### Install TronBox globally with yarn

Source: https://tronbox.io/docs/

Use this command to install TronBox globally via yarn. Requires yarn to be installed.

```sh
yarn global add tronbox
```

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

### deployer.then example

Source: https://tronbox.io/docs/guides/deploy-contracts

Shows how to use deployer.then to run arbitrary deployment steps, such as creating a new contract instance and setting its address on another contract via a function call.

```javascript
const A = artifacts.require('A');
const B = artifacts.require('B');

module.exports = async function (deployer) {
  let a, b;
  deployer
    .then(function () {
      // Create a new version of A
      return A.new();
    })
    .then(function (instance) {
      a = instance;
      // Get the deployed instance of B
      return B.deployed();
    })
    .then(function (instance) {
      b = instance;
      // Set the new instance of A's address on B via B's setA() function.
      return b.setA(a.address);
    });
};
```

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

### TRE startup output

Source: https://tronbox.io/docs/guides/test-contracts

Expected output when starting the TRE container. Shows proxy creation, account generation, and available accounts with private keys.

```shell
----------------------------------

TronBox Runtime Environment v1.0.5

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

Start the http proxy for dApps...
[HPM] Proxy created: /  ->  http://127.0.0.1:18190
[HPM] Proxy created: /  ->  http://127.0.0.1:18191
[HPM] Proxy created: /  ->  http://127.0.0.1:8545
[HPM] Proxy created: /  ->  http://127.0.0.1:8545
[HPM] Proxy created: /  ->  http://127.0.0.1:8060

 TRE now listening on http://127.0.0.1:9090


ADMIN /admin/accounts-generation
(1) FullNode is not already.
Sleeping for 3 seconds... Slept.
(2) FullNode is not already.
Sleeping for 3 seconds... Slept.

FullNode is already.

...
Loading the accounts and waiting for the node to mine the transactions...
(1) Waiting for receipts...
Sending 10000 TRX to TEXqRygDHvE7Xe5XcnBpJeJsRCu2pB3e4U
Sending 10000 TRX to TBXGwsmz7n6QemBABmooTBvWgn86H8n7QT
Sending 10000 TRX to THaLQRHEfmYwRbVfHkL3VrpzJzUvgStJbX
Sending 10000 TRX to TTuWX3EiRSgSEX35z39dKnkGwux27E7tYe
Sending 10000 TRX to TKnbNtvgW2jnkXZApWNMGVunuirts4UaL8
Sending 10000 TRX to TSZ4ABf1nKTsTFqqBfcGDDkfcsGcdC7784
Sending 10000 TRX to TXHDhBZ9ZYHLbH1ZEKjXBmaR3eJfdgeTWE
Sending 10000 TRX to TJUiUEAbkQ7vfupB5GoJRVr6QwQBR97n45
Sending 10000 TRX to TCzMS8UDrWJ9Yf5Pk49Y7cD9C2i7Ui4Ve1
Sending 10000 TRX to TT31CTebLhcSynLxm5Ak7W9Pjnq4Mupdbb
Sleeping for 3 seconds... Slept.
(2) Waiting for receipts...
Sleeping for 3 seconds... Slept.
(3) Waiting for receipts...
Done.

Available Accounts
==================

(0) TEXqRygDHvE7Xe5XcnBpJeJsRCu2pB3e4U (10000 TRX)
(1) TBXGwsmz7n6QemBABmooTBvWgn86H8n7QT (10000 TRX)
(2) THaLQRHEfmYwRbVfHkL3VrpzJzUvgStJbX (10000 TRX)
(3) TTuWX3EiRSgSEX35z39dKnkGwux27E7tYe (10000 TRX)
(4) TKnbNtvgW2jnkXZApWNMGVunuirts4UaL8 (10000 TRX)
(5) TSZ4ABf1nKTsTFqqBfcGDDkfcsGcdC7784 (10000 TRX)
(6) TXHDhBZ9ZYHLbH1ZEKjXBmaR3eJfdgeTWE (10000 TRX)
(7) TJUiUEAbkQ7vfupB5GoJRVr6QwQBR97n45 (10000 TRX)
(8) TCzMS8UDrWJ9Yf5Pk49Y7cD9C2i7Ui4Ve1 (10000 TRX)
(9) TT31CTebLhcSynLxm5Ak7W9Pjnq4Mupdbb (10000 TRX)

Private Keys
==================

(0) ...PRIVATE_KEY_HERE...
(1) ...PRIVATE_KEY_HERE...
(2) ...PRIVATE_KEY_HERE...
(3) ...PRIVATE_KEY_HERE...
(4) ...PRIVATE_KEY_HERE...
(5) ...PRIVATE_KEY_HERE...
(6) ...PRIVATE_KEY_HERE...
(7) ...PRIVATE_KEY_HERE...
(8) ...PRIVATE_KEY_HERE...
(9) ...PRIVATE_KEY_HERE...

HD Wallet
==================
Mnemonic:      ... MNEMONIC_HERE ...
Base HD Path:  m/44'/195'/0'/0/{account_index}

GET 200  - 10752.337 ms
```

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

### Start local development node with Docker

Source: https://tronbox.io/docs/migration/migrating-from-hardhat

Starts the TronBox development environment (TRE) as a Docker container, mapping port 9090 for local testing.

```shell
docker run -it -p 9090:9090 --rm --name tron tronbox/tre

```

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

### Deployment log output with console.log

Source: https://tronbox.io/docs/guides/debugging-with-TRE

Example output from tronbox migrate, showing compilation, deployment, and the console.log message with token transfer details.

```solidity
Compiling your contracts ...
============================
Compiling ./contracts/Token.sol...
Compiling tronbox/console.sol...
Writing artifacts to ./build/contracts

> Compiled successfully using:
  - solc: 0.8.6
Using network 'development'.

Running migration: 1_initial_migration.js
  Deploying Token...
  Token:
    (base58) TJWQUFE9aZzuugnYsXXKVtJQcUWQNHBY9V
    (hex) 415da779869e8eac338beaf7cbeda1cdfe412be84f
Saving artifacts...
Transferring from TJHD16Qq3aWtygQqU4R5UcAGh3hFKxnEwQ to TGjX4QszjhRbyP8k39cGert9pSvkN2sRTA 100 tokens  
```

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

### Install @openzeppelin/truffle-upgrades

Source: https://tronbox.io/docs/guides/using-upgrades-plugins

Install the package as a dev dependency. Requires TronBox v3.2.0 or later.

```shell
npm install --save-dev @openzeppelin/truffle-upgrades
```

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

### Start tronbox console

Source: https://tronbox.io/docs/quickstart

Launches the TronBox interactive console for interacting with contracts.

```shell
tronbox console
```

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

### Deploy a New Contract with MetaCoin.new()

Source: https://tronbox.io/docs/guides/interact-with-contracts

Deploy a new instance of the MetaCoin contract to the network using the .new() function. The example passes an initial balance of 50 and logs the new contract address.

```shell
tronbox(development)> MetaCoin.new(50).then(res => console.log(res.address))

// outputs:
// 418912f128b414779e0a21251883b026671706ea6d
```

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

### Truffle Configuration (truffle-config.js)

Source: https://tronbox.io/docs/migration/tronbox-vs-truffle

Example Truffle configuration file showing network definitions for development and mainnet, using HDWalletProvider for mainnet, and specifying solc compiler version 0.8.6.

```javascript
module.exports = {
  networks: {
    development: {
      host: '127.0.0.1',
      port: 8545,
      network_id: '*',
      gas: 6721975,
      gasPrice: 20000000000
    },
    mainnet: {
      provider: () =>
        new HDWalletProvider(process.env.MNEMONIC, `https://mainnet.infura.io/v3/${process.env.INFURA_KEY}`),
      network_id: 1,
      gas: 5500000,
      gasPrice: 20000000000
    }
  },
  compilers: {
    solc: {
      version: '0.8.6'
    }
  }
};
```

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

### tronbox.json commands configuration

Source: https://tronbox.io/docs/guides/create-a-box

Example tronbox.json showing the commands object, which maps descriptors to console commands. These are displayed to users after unboxing as quick instructions.

```json
{
  "commands": {
    "Compile": "tronbox compile",
    "Migrate": "tronbox migrate",
    "Test contracts": "tronbox test",
    "Test dapp": "npm test",
    "Run dev server": "npm run start",
    "Build for production": "npm run build"
  }
}
```

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

### Migration script (Truffle and TronBox)

Source: https://tronbox.io/docs/migration/migrating-from-truffle

Migration files follow the same pattern as Truffle. The example shows identical code for both Truffle and TronBox, using artifacts.require and deployer.deploy.

```javascript
// migrations/2_deploy_contracts.js (Truffle)
const MyContract = artifacts.require('MyContract');

module.exports = function (deployer) {
  deployer.deploy(MyContract /* constructor arguments */);
};
```

```javascript
// migrations/2_deploy_contracts.js (TronBox)
const MyContract = artifacts.require('MyContract');

module.exports = function (deployer) {
  deployer.deploy(MyContract /* constructor arguments */);
};
```

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

### TronBox test example using contract and assert

Source: https://tronbox.io/docs/migration/tronbox-vs-hardhat

Shows a TronBox test using `contract`, `it`, `beforeEach`, and `assert`. Deploys the contract with `MyContract.new()`. Uses the `accounts` parameter for accounts.

```javascript
// TronBox
const MyContract = artifacts.require('MyContract');

contract('MyContract', accounts => {
  let instance;

  beforeEach(async () => {
    instance = await MyContract.new();
  });

  it('should pass test', async () => {
    // Test code here
    const result = await instance.getValue();
    assert.equal(result, expectedValue);
  });
});
```

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

### Hardhat Configuration (hardhat.config.js)

Source: https://tronbox.io/docs/migration/tronbox-vs-hardhat

Example Hardhat configuration file showing network definitions and Solidity compiler settings. Uses `@nomicfoundation/hardhat-toolbox` and environment variables for private keys and Infura endpoint.

```javascript
require('@nomicfoundation/hardhat-toolbox');

module.exports = {
  networks: {
    localhost: {
      url: 'http://127.0.0.1:8545',
      accounts: [process.env.PRIVATE_KEY]
    },
    mainnet: {
      url: `https://mainnet.infura.io/v3/${process.env.INFURA_KEY}`,
      accounts: [process.env.PRIVATE_KEY],
      chainId: 1
    }
  },
  solidity: {
    version: '0.8.6'
  }
};

```

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

### Web3.js pattern for account setup, contract deployment, and transactions

Source: https://tronbox.io/docs/migration/tronbox-vs-truffle

Shows the familiar Web3.js approach: creating a Web3 instance, adding an account from a private key, deploying a contract with gas, calling a function, and sending a transaction. Use this as the baseline for migrating to TronWeb.

```javascript
const { Web3 } = require('web3');
const web3 = new Web3('http://localhost:8545');

// Add account
const account = web3.eth.accounts.privateKeyToAccount(process.env.PRIVATE_KEY);
web3.eth.accounts.wallet.add(account);
web3.defaultAccount = account.address;

// Deploy contract
const contract = new web3.eth.Contract(abi);
const instance = await contract
  .deploy({
    data: bytecode,
    arguments: [arg1, arg2]
  })
  .send({ gas: 1500000 });

// Call function
const result = await instance.methods.getValue().call();

// Send transaction
await instance.methods.setValue(42).send({ gas: 1500000 });
```

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

### Tronbox configuration file example (tronbox.js)

Source: https://tronbox.io/docs/reference/configuration

Exports a configuration object with a development network and Solidity compiler settings. The network uses a private key from the environment variable PRIVATE_KEY_DEV, sets userFeePercentage to 0, feeLimit to 1000 * 1e6 (in SUN), and fullHost to http://127.0.0.1:9090. The compiler is set to solc version 0.8.6 with optimizer enabled, runs 200, evmVersion 'istanbul', and viaIR true.

```javascript
module.exports = {
  networks: {
    development: {
      // For tronbox/tre docker image
      // See https://hub.docker.com/r/tronbox/tre
      privateKey: process.env.PRIVATE_KEY_DEV,
      userFeePercentage: 0, // The percentage of resource consumption ratio.
      feeLimit: 1000 * 1e6, // The TRX consumption limit for the deployment and trigger, unit is SUN
      fullHost: 'http://127.0.0.1:9090',
      network_id: '*'
    }
  },
  compilers: {
    solc: {
      version: '0.8.6',
      // An object with the same schema as the settings entry in the Input JSON.
      // See https://docs.soliditylang.org/en/latest/using-the-compiler.html#input-description
      settings: {
        optimizer: {
          enabled: true,
          runs: 200
        },
        evmVersion: 'istanbul',
        viaIR: true
      }
    }
  }
};
```

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

### deployer.deploy examples

Source: https://tronbox.io/docs/guides/deploy-contracts

Shows various ways to use deployer.deploy: deploying a single contract with or without constructor arguments, preventing redeployment with overwrite: false, setting fee_limit and userFeePercentage, deploying multiple contracts with arrays, and using overwrite for external dependencies.

```javascript
// Deploy a single contract without constructor arguments
deployer.deploy(A);

// Deploy a single contract with constructor arguments
deployer.deploy(A, arg1, arg2);

// Don't deploy this contract if it has already been deployed
deployer.deploy(A, { overwrite: false });

// Set a maximum amount of fee_limit and `userFeePercentage`  for the deployment
deployer.deploy(A, { fee_limit: 1.1e8, userFeePercentage: 30 });

// Deploy multiple contracts in one call by passing an array. Use a nested
// array to pass constructor arguments. The contracts are deployed in sequence.
deployer.deploy([[A, arg1, arg2], B, [C, arg1]]);

// External dependency example:
//
// For this example, our dependency provides an address when we're deploying to the
// live network, but not for any other networks like testing and development.
// When we're deploying to the live network we want it to use that address, but in
// testing and development we need to deploy a version of our own. Instead of writing
// a bunch of conditionals, we can simply use the `overwrite` key.
deployer.deploy(SomeDependency, { overwrite: false });
```

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

### Simple migration file: ./migrations/4_example_migration.js

Source: https://tronbox.io/docs/guides/deploy-contracts

A basic migration file that deploys a single contract. The numbered prefix is required to record migration success and run files in order; the suffix is for readability.

```javascript
const MyContract = artifacts.require('MyContract');

module.exports = function (deployer) {
  deployer.deploy(MyContract);
};
```

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

### Migrations with async/await

Source: https://tronbox.io/docs/guides/deploy-contracts

Shows how to use async/await in migrations to deploy a contract and access its deployed instance.

```javascript
const MyContract = artifacts.require('MyContract');

module.exports = async function (deployer) {
  // deploy a contract
  await deployer.deploy(MyContract);
  //access information about your deployed contract instance
  const instance = await MyContract.deployed();
};
```

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

### Console prompt after starting tronbox console

Source: https://tronbox.io/docs/quickstart

Shows the prompt displayed after starting `tronbox console`. The network name in parentheses indicates the currently connected network.

```shell
tronbox(development)>
```

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

### MetaCoin Solidity Contract

Source: https://tronbox.io/docs/guides/interact-with-contracts

The MetaCoin contract used as an example for contract abstractions. It includes a constructor, sendCoin, getConvertedBalance, getBalance, and getOwner methods. It is not standards compatible and is just a simple example of a coin-like contract.

```solidity
pragma solidity ^0.5.4;

import "./ConvertLib.sol";

// This is just a simple example of a coin-like contract.
// It is not standards compatible and cannot be expected to talk to other
// coin/token contracts.

contract MetaCoin {
  mapping(address => uint) balances;

  event Transfer(address _from, address _to, uint256 _value);

  address owner;

  constructor(uint initialBalance) public {
    owner = msg.sender;
    balances[msg.sender] = initialBalance;
  }

  function sendCoin(address receiver, uint amount) public returns (bool sufficient) {
    if (balances[msg.sender] < amount) return false;
    balances[msg.sender] -= amount;
    balances[receiver] += amount;
    emit Transfer(msg.sender, receiver, amount);
    return true;
  }

  function getConvertedBalance(address addr) public view returns (uint){
    return ConvertLib.convert(getBalance(addr), 2);
  }

  function getBalance(address addr) public view returns (uint) {
    return balances[addr];
  }

  function getOwner() public view returns (address) {
    return owner;
  }
}
```

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

### Initialize TronBox project

Source: https://tronbox.io/docs/migration/migrating-from-hardhat

Creates a new TronBox workspace with standard folders (contracts, migrations, test) and a baseline project structure.

```shell
mkdir my-tron-project
cd my-tron-project
tronbox init
```

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

### Check TronBox version

Source: https://tronbox.io/docs/guides/installation

Verify that TronBox has been properly installed by checking its version.

```shell
tronbox version
```

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

### MyContract.new(...[arg1, arg2, ...], { tx params })

Source: https://tronbox.io/docs/reference/contract-abstractions

Deploys a new instance of the contract to the network. Takes constructor parameters and optional transaction parameters like feeLimit, userFeePercentage, and callValue. Returns a Promise that resolves to a new contract abstraction instance.

```APIDOC
## MyContract.new(...[arg1, arg2, ...], { tx params })

### Description
Deploys a new instance of the contract to the network. Takes constructor parameters and optional transaction parameters like feeLimit, userFeePercentage, and callValue. Returns a Promise that resolves to a new contract abstraction instance.

### Method
new

### Parameters
#### Constructor Parameters
- **arg1, arg2, ...** (any) - Required - Constructor parameters required by the contract.

#### Transaction Parameters (optional last argument)
- **feeLimit** (number) - Optional - Transaction fee limit.
- **userFeePercentage** (number) - Optional - User fee percentage.
- **callValue** (number) - Optional - Call value.

### Returns
- **Promise** - A new instance of the newly deployed contract abstraction.
```

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

### debug_storageRangeAt Example

Source: https://tronbox.io/docs/guides/test-contracts

Returns the contract storage for a specified range using 'debug_storageRangeAt'.

```javascript
const result = await tronWrap.send('debug_storageRangeAt', [0, 0, contractAddress, '0x01', 1]);
console.log(result);
```

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

### debug_traceTransaction Example

Source: https://tronbox.io/docs/guides/test-contracts

Returns all traces of a given transaction using the 'debug_traceTransaction' method.

```javascript
const txid = 'f6b72dda65682b858c1c1980710aad7955fbf6db91c66840da0f852fc3cc694b';
const result = await tronWrap.send('debug_traceTransaction', [txid]);
console.log(result);
```

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

### Create and enter MetaCoin directory

Source: https://tronbox.io/docs/guides/create-a-project

Run these commands in a terminal to create a directory named MetaCoin and change into it. This is the first step before unboxing the MetaCoin project.

```shell
mkdir MetaCoin
cd MetaCoin
```

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

### tre_setAccountStorageAt Example

Source: https://tronbox.io/docs/guides/test-contracts

Sets the storage value at a specific slot for an account using 'tre_setAccountStorageAt'.

```javascript
const address = 'TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL';
const slot = '0x0000000000000000000000000000000000000000000000000000000000000005';
const data = '0xbaddad42';
const result = await tronWrap.send('tre_setAccountStorageAt', [address, slot, data]);
console.log(result);
```

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

### MetaCoin test using artifacts.require() and async/await

Source: https://tronbox.io/docs/guides/write-javascript-tests

Example test file (./test/metacoin.js) demonstrating how to use artifacts.require() to interact with the MetaCoin contract, the contract() function, and the accounts array. It includes three tests: checking initial balance, testing linked library function, and testing sendCoin.

```javascript
const MetaCoin = artifacts.require('MetaCoin');

contract('MetaCoin', async accounts => {
  it('should put 10000 MetaCoin in the first account', async () => {
    let instance = await MetaCoin.deployed();
    let balance = await instance.getBalance(accounts[0]);
    assert.equal(balance.valueOf(), 10000);
  });

  it('should call a function that depends on a linked library', async () => {
    let meta = await MetaCoin.deployed();
    let outCoinBalance = await meta.getBalance(accounts[0]);
    let metaCoinBalance = Number(outCoinBalance);
    let outCoinConvertedBalance = await meta.getConvertedBalance(accounts[0]);
    let metaCoinConvertedBalance = Number(outCoinConvertedBalance);
    assert.equal(metaCoinConvertedBalance, 2 * metaCoinBalance);
  });

  it('should send coin correctly', async () => {
    // Get initial balances of first and second account.
    let account_one = accounts[0];
    let account_two = accounts[1];

    let amount = 10;

    let instance = await MetaCoin.deployed();
    let meta = instance;

    let balance = await meta.getBalance(account_one);
    let account_one_starting_balance = Number(balance);

    balance = await meta.getBalance(account_two);
    let account_two_starting_balance = Number(balance);
    await meta.sendCoin(account_two, amount, { from: account_one });

    balance = await meta.getBalance(account_one);
    let account_one_ending_balance = Number(balance);

    balance = await meta.getBalance(account_two);
    let account_two_ending_balance = Number(balance);

    assert.equal(
      account_one_ending_balance,
      account_one_starting_balance - amount,
      "Amount wasn't correctly taken from the sender"
    );
    assert.equal(
      account_two_ending_balance,
      account_two_starting_balance + amount,
      "Amount wasn't correctly sent to the receiver"
    );
  });
});
```

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

### Configure networks with private keys

Source: https://tronbox.io/docs/reference/configuration

Example networks configuration using private keys for shasta and nile networks. Includes transaction parameters like userFeePercentage, feeLimit, fullHost, and network_id. Private keys are read from environment variables.

```javascript
module.exports = {
  networks: {
    shasta: {
      // Obtain test coin at https://shasta.tronex.io/
      privateKey: process.env.PRIVATE_KEY_SHASTA,
      userFeePercentage: 50,
      feeLimit: 1000 * 1e6,
      fullHost: 'https://api.shasta.trongrid.io',
      network_id: '2'
    },
    nile: {
      // Obtain test coin at https://nileex.io/join/getJoinPage
      privateKey: process.env.PRIVATE_KEY_NILE,
      userFeePercentage: 100,
      feeLimit: 1000 * 1e6,
      fullHost: 'https://nile.trongrid.io',
      network_id: '3'
    }
  }
};
```

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

### tre_blockTime Example

Source: https://tronbox.io/docs/guides/test-contracts

Sets the auto-mining time. If the parameter is 0, auto-mining is stopped and a block will mine after receiving a transaction.

```javascript
const result = await tronWrap.send('tre_blockTime', [3]);
console.log(result);
```

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

### TronBox Configuration (tronbox-config.js)

Source: https://tronbox.io/docs/migration/tronbox-vs-hardhat

Example TronBox configuration file showing network definitions and TVM Solidity compiler settings. Uses a single `privateKey`, `feeLimit` for resource limits, and `fullHost` for network endpoints.

```javascript
module.exports = {
  networks: {
    development: {
      privateKey: process.env.PRIVATE_KEY, // ⚠️ Single key, not array
      feeLimit: 1e8, // ⚠️ Resource limit
      fullHost: 'http://127.0.0.1:9090', // ⚠️ Use `fullHost`, not `url`
      network_id: '9'
    },
    mainnet: {
      privateKey: process.env.PRIVATE_KEY,
      feeLimit: 1e8,
      fullHost: 'https://api.trongrid.io', // ⚠️ TRON mainnet
      network_id: '1'
    }
  },
  compilers: {
    solc: {
      version: '0.8.6' // ⚠️ TVM Solidity version
    }
  }
};

```

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

### tre_unlockedAccounts Example

Source: https://tronbox.io/docs/guides/test-contracts

Unlocks specified accounts. Transactions sent from unlocked accounts do not require private key signatures.

```javascript
const result = await tronWrap.send('tre_unlockedAccounts', [['TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL']]);
console.log(result);
```

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

### Check nvm version

Source: https://tronbox.io/docs/guides/installation

Verify that nvm is properly installed. You may need to reload the terminal for the command to take effect.

```shell
nvm --version
```

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

### TronWeb equivalent for contract deployment and transactions

Source: https://tronbox.io/docs/migration/tronbox-vs-truffle

Shows the TronWeb equivalent: creating a TronWeb instance with privateKey, deploying a contract with feeLimit, calling a function, and sending a transaction. Note that the private key is set on the instance and no defaultAccount is needed.

```javascript
const { TronWeb } = require('tronweb');
const tronWeb = new TronWeb({
  fullHost: 'http://127.0.0.1:9090',
  privateKey: process.env.PRIVATE_KEY
});

// Deploy contract
const contract = await tronWeb.contract().new({
  abi: abi,
  bytecode: bytecode,
  feeLimit: 1e8,
  parameters: [arg1, arg2]
});

// Call function
const result = await contract.getValue().call();

// Send transaction
await contract.setValue(42).send({
  feeLimit: 1e8
});
```

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

### tre_setAccountBalance Example

Source: https://tronbox.io/docs/guides/test-contracts

Sets the balance of a given account using the TRE method 'tre_setAccountBalance'. The balance is provided as a hex string.

```javascript
const address = 'TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL';
const balance = '0x3e8';
const result = await tronWrap.send('tre_setAccountBalance', [address, balance]);
console.log(result);
```

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

### JavaScript: Make a call via getValue

Source: https://tronbox.io/docs/reference/contract-abstractions

Calling `getValue()` performs a call, which is free and does not require TRX. This example retrieves the value from the contract.

```javascript
const value = await instance.getValue();
// value represents the `value` storage object in the solidity contract
// since the contract returns that value.
```

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

### Test file (Truffle and TronBox)

Source: https://tronbox.io/docs/migration/migrating-from-truffle

Tests keep the same structure; replace web3 with tronWeb. The Truffle version uses web3.eth.getBalance and logs ETH balance in wei; the TronBox version uses tronWeb.trx.getBalance and logs TRX balance in sun.

```javascript
// test/my_contract.test.js (Truffle)
const MyContract = artifacts.require('MyContract');

contract('MyContract', accounts => {
  it('should work', async () => {
    const instance = await MyContract.deployed();

    // Log account balance (wei)
    const balance = await web3.eth.getBalance(accounts[0]);
    console.log('ETH balance (wei):', balance);

    // Set value via transaction
    await instance.setValue(42);

    // Verify state via call
    const value = await instance.getValue();
    assert.equal(value.toString(), '42', 'getValue should return 42 after setValue');
  });
});
```

```javascript
// test/my_contract.test.js (TronBox)
const MyContract = artifacts.require('MyContract');

contract('MyContract', accounts => {
  it('should work', async () => {
    const instance = await MyContract.deployed();

    // Log account balance (sun)
    const balance = await tronWeb.trx.getBalance(accounts[0]);
    console.log('TRX balance (sun):', balance);

    // Set value via transaction
    await instance.setValue(42);

    // Verify state via call
    const value = await instance.getValue();
    assert.equal(value.toString(), '42', 'getValue should return 42 after setValue');
  });
});
```

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

### Validate TRON address with tronWeb.isAddress

Source: https://tronbox.io/docs/migration/overview

Checks if a string is a valid TRON address. TRON addresses use Base58 and typically start with 'T', not '0x'.

```javascript
// Validate an address format
const isValid = tronWeb.isAddress('TRX9aKv8GQ9KvWxJ...');
```

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

### Migrations with async/await

Source: https://tronbox.io/docs/guides/deploy-contracts

Shows how to use async/await with the deployer to migrate contracts.

```APIDOC
## Migrations with async/await

### Description
You can also migrate your contracts using async/await.

### Method
JavaScript async function

### Request Example
```javascript
const MyContract = artifacts.require('MyContract');

module.exports = async function (deployer) {
  // deploy a contract
  await deployer.deploy(MyContract);
  //access information about your deployed contract instance
  const instance = await MyContract.deployed();
};
```

### Response
No explicit response documented.
```

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

### Use contract abstraction in developer console

Source: https://tronbox.io/docs/reference/contract-abstractions

In the developer console, compiled contracts are exposed as global variables. This example calls deployed() and logs the instance.

```shell
tronbox(development)> MyContract.deployed().then(myContract => console.log(myContract));
```

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

### TRE Migration Output

Source: https://tronbox.io/docs/guides/test-contracts

Example output from running a migration in TRE, showing network, deployed contract addresses (base58 and hex), and transaction statuses.

```text
Using network 'development'.

Running migration: 1_initial_migration.js
  Deploying Migrations...
  Migrations:
    (base58) TVbadXqMTap8D2rNjyf353Rc2jD82kWKac
    (hex) 41d74b6b5c04a4a8ec9dd60127d354540d40270889
Saving successful migration to network...
Saving artifacts...
Running migration: 2_deploy_contracts.js
  Deploying ConvertLib...
  ConvertLib:
    (base58) TGcA7gVte4sw45FVXg7tkA7Y4MVYKWvgT5
    (hex) 4148cdbc805388241d397bc9e3da63cc1371e21b30
  Linking ConvertLib to MetaCoin
  Deploying MetaCoin...
  MetaCoin:
    (base58) TLQnf4xrHjn2t983AutNZKzJwisJEyM18k
    (hex) 417287c03e5db15b58b8d3c111302815b6d10c0235
Saving successful migration to network...
Saving artifacts...
```
Tokens:
Raw