Meterify DApp Tutorials

DApps are decentralized applications that utilize blockchains to store a history of operations (e.g. transactions). They can also consist of functional code, called smart contracts, that are published to the blockchain. DApps interfaces can be graphical, console-based, or APIs.
Popular categories for DApps include finance, exchanges, and gambling, but social applications and games also exist.
One of the primary use cases for a DApp is sending cryptocurrency between two accounts. For example, when Alice wishes to send some MTR and MTRG to Bob's account. Application developers can create methods for this on the Meter blockchain using meterify, an extended version of Web3 (AKA the Ethereum JavaScript API library).
The final project files can be found here:
​index.js​
​sample_token.sol​
​docker-compose.yml​
Prerequisites
Meterify requires that Node.js version 10.15.1 or above is installed, as well as npm.
1
$ node --version
2
​
3
v10.16.3
4
​
5
$ npm --version
6
​
7
6.9.0
Copied!
Example DApp
Step 1 - Project Setup
Create a directory (e.g. meter-dapp) and initialize a new project using npm. Then install the app prerequisites meterify and web3, plus the JavaScript bindings for the Solidity compiler (solc).
1
$ mkdir meter-dapp
2
​
3
$ cd meter-dapp
4
​
5
$ npm init
6
​
7
$ npm install meterify --save
8
​
9
$ npm install [email protected] --save
10
​
11
$ npm install [email protected] --save
Copied!
Step 2 - Test the Connection
Create a file called index.js, and include the meterify and web3 requirements, then call the file with node to test the connection to the testnet.
index.js:
1
const mtr = require("meterify").meterify;
2
const Web3 = require("web3");
3
const meterify = mtr(new Web3(), "https://testnet.meter.io");
Copied!
1
$ node index.js
Copied!
If the code runs without any errors the connection was successful.
Step 3 - Creating an Account-Generating Function
1
meterify.eth.accounts.create()
Copied!
The meterify.eth.accounts package contains functions for generating accounts and signing transactions and data. Create an object, using Alice's and Bob's names as keys. Perform a loop on the object, calling the create function. This will generate new local accounts that contain both a private key and a public key. Add each account to the object as is created.
1
var accounts = createAccounts({"alice":{},"bob":{}});
2
​
3
function createAccounts(accounts){
4
​
5
  for(key in accounts){
6
    accounts[key] = meterify.eth.accounts.create();
7
  }
8
​
9
  return accounts;
10
}
Copied!
Step 4 - Add Accounts to a Wallet.
1
meterify.eth.accounts.wallet;
Copied!
meterify.eth.accounts also contains an in memory wallet to store multiple accounts. Loop through the object returned by the createAccounts function, and add Alice's and Bob's accounts to the wallet, using each account's private key.
1
function addAccountsToWallet(accounts){
2
​
3
  for(var key in accounts){
4
    meterify.eth.accounts.wallet.add(accounts[key].privateKey);
5
  }
6
​
7
}
Copied!
Step 5 - Send MTR to an Account
Use the eth package's sendTransaction method to create a function for sending some MTR and MTRG from Alice to Bob.
Units in meterify are Wei, where 1 MTR = 10e18 Wei. Note that the identifier code for MTR is 0000000000, while MTRG is 0000000001. sendTransaction returns a promiEvent that is considered resolved once the receipt becomes available.
1
​
2
/* Note: Alice's account should already contain some MTR and MTRG
3
 * for this example code to work.
4
 */
5
​
6
sendCrypto(accounts.alice.address, accounts.bob.address, '0000000000', '1000000000000000000');
7
​
8
sendCrypto(accounts.alice.address, accounts.bob.address, '0000000001', '1000000000000000000');
9
​
10
function sendCrypto(fromAddress, toAddress, code, amount){
11
​
12
  meterify.eth.sendTransaction(
13
    {
14
      from: fromAddress,
15
      to: toAddress,
16
      value: amount,
17
      data: code
18
    }
19
  ).then(
20
    receipt => {}
21
  ).then(
22
    data => {
23
      console.log("MTR sent: "+JSON.stringify(data));
24
      next();
25
    }
26
  ).catch(function(error){
27
    console.log("Error: "+error);
28
  });
29
}
Copied!
Step 6 - Run the application.
1
$ node index.js
Copied!
Load, Deploy, and Test a Smart Contract
The following modifications to the example demonstrate the use of a sample smart contract on the Meter blockchain. Again, follow the steps to add code snippets to the existing index.js file.
Step 1 - Load a Smart Contract.
The file can be found here: sample_token.sol​
1
function loadContract(file){
2
  console.log("Loading contract: "+file);
3
  const contractFile = fs.readFileSync(file).toString();
4
  const solc = require('solc');
5
  const compiledCode = solc.compile(contractFile);
6
​
7
  var data = {};
8
​
9
  data.token_abiDefinition = JSON.parse(compiledCode.contracts[':SAMPLEToken'].interface)
10
  let token_byteCode = compiledCode.contracts[':SAMPLEToken'].bytecode
11
  data.token_byteCode = "0x" + token_byteCode;
12
​
13
  console.log("Contract Loaded.");
14
  return data;
15
}
Copied!
Step 2 - Deploy a Smart Contract
1
function deployContract(data,address){
2
  console.log("Deploying contract.");
3
​
4
  contractInstance = new meterify.eth.Contract(data.token_abiDefinition)
5
  contractInstance.options.data = data.token_byteCode
6
  contractInstance.deploy(
7
    {
8
      arguments: [
9
        address,
10
        '1000000000',
11
        'Sample Token',
12
        '3',
13
        'STOKEN'
14
      ]
15
    }
16
  ).send(
17
    {
18
      from: address,
19
      gas: 4700000
20
    }
21
  ).then(
22
    (
23
      newContractInstance
24
    ) => {
25
      console.log("Contract deployed.");
26
      contractInstance.options.address = newContractInstance.options.address;
27
      registerEvents(contractInstance);
28
    }
29
  );
30
}
Copied!
Step 3 - Register Contract Events
Additionally, call some example functions within contractReady when the contract is ready.
1
function registerEvents(contractInstance){
2
  contractInstance.events.allEvents(
3
    {}, (error, result) => {
4
      if (error) {
5
          console.log(error)
6
      } else {
7
        console.log("Contract Ready.");
8
          contractReady(result,contractInstance);
9
      }
10
  })
11
}
12
​
13
function contractReady(result,contractInstance){
14
  transferFrom(contractInstance, accounts.alice.address, accounts.bob.address);
15
}
16
​
Copied!
Step 4 - Transfer Between Accounts.
1
function transferFrom(contractInstance, fromAddress, toAddress){
2
  contractInstance.methods._transferFrom(
3
    fromAddress,
4
    toAddress,
5
    '9999'
6
  ).send(
7
    {
8
      from:fromAddress,
9
      gas: 4700000
10
    }
11
  ).then(
12
    data => {
13
      console.log(data)}
14
    ).catch(
15
      err => {console.log(err)}
16
  )
17
}
Copied!
Step 5 - Get a Balance.
1
function getAccountBalanceOf(contractInstance,address){
2
  contractInstance.methods.getAccountBalanceOf(
3
    address
4
  ).send(
5
    {
6
      from: address,
7
      gas: 4700000
8
    }).then(
9
      data => {
10
        console.log(data)
11
      }
12
    ).catch(err => {
13
      console.log(err)
14
    }
15
  )
16
}
Copied!
Step 6 - Mint Some Coins.
1
function mintToken(contractInstance,address){
2
  contractInstance.methods.mintToken(
3
    address,
4
    '99999999999999999999999'
5
  ).send(
6
    {
7
      from: address,
8
      gas: 4700000
9
    }
10
  ).then(
11
    data => {
12
      console.log(data)
13
    }
14
  ).catch(
15
    err => {
16
      console.log(err)
17
    }
18
  )
19
}
20
​
Copied!
Using Docker
Step 1 - Ensure docker-compose is Installed.
1
$ sudo curl -L https://github.com/docker/compose/releases/download/1.24.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
2
​
3
$ sudo chmod +x /usr/local/bin/docker-compose
4
​
5
$ docker-compose --version
6
​
7
docker-compose version 1.24.1, build 4667896b
Copied!
Step 2 - Create docker-compose.yml
A copy of this file can be found here: docker-compose.yml​
1
version: '3.5'
2
services:
3
  node:
4
    image: "node:10"
5
    user: "node"
6
    working_dir: /home/node/meter-daap
7
    volumes:
8
      - ./:/home/node/meter-daap
9
    command: >
10
      sh -c "rm -rf node_modules
11
            npm init -y &&
12
            npm install meterify --save &&
13
            rm -rf node_modules/*/.git/
14
            npm install [email protected] --save &&
15
            npm install [email protected] --save &&
16
            node index.js"
Copied!
Step 3 - Run docker-compose
Initiate the test application with docker-compose.
1
$ docker-compose up
Copied!
If there are no errors the connection was successful.
Stop Docker using Ctrl+C.
1
Ctrl+C
Copied!
Step 4 - Comment out dependency installation.
After the first run in docker-compose.yml, stop repeated initialization and dependency installation by commenting out the following lines.
1
version: '3.5'
2
services:
3
  node:
4
    image: "node:10"
5
    user: "node"
6
    working_dir: /home/node/meter-daap
7
    volumes:
8
      - ./:/home/node/meter-daap
9
    command: node index.js
10
#    command: >
11
#      sh -c "rm -rf node_modules
12
#            npm init -y &&
13
#            npm install meterify --save &&
14
#            rm -rf node_modules/*/.git/
15
#            npm install [email protected] --save &&
16
#            npm install [email protected] --save &&
17
#            node index.js"
Copied!

json interface

Next - Developer Documentation

Meterify Code Examples

Last modified 21d ago

Prerequisites

Example DApp

Step 1 - Project Setup

Step 2 - Test the Connection

Step 3 - Creating an Account-Generating Function

Step 4 - Add Accounts to a Wallet.

Step 5 - Send MTR to an Account

Step 6 - Run the application.

Load, Deploy, and Test a Smart Contract

Step 1 - Load a Smart Contract.

Step 2 - Deploy a Smart Contract

Step 3 - Register Contract Events

Step 4 - Transfer Between Accounts.

Step 5 - Get a Balance.

Step 6 - Mint Some Coins.

Using Docker

Step 1 - Ensure `docker-compose` is Installed.

Step 2 - Create `docker-compose.yml`

Step 3 - Run `docker-compose`

Step 4 - Comment out dependency installation.