Chapter 2
Passing arguments to constructor:pragma solidity >=0.4.22 <0.7.0;
contract DappToken {
uint256 public totalSupply;
constructor (uint256 _initialSupply) public {
totalSupply = _initialSupply;
}
}
contract DappToken {
uint256 public totalSupply;
constructor (uint256 _initialSupply) public {
totalSupply = _initialSupply;
}
}
2_deploy_contracts.js
const DappToken = artifacts.require("DappToken");
module.exports = function(deployer) {
deployer.deploy(DappToken, 1000000);
};
module.exports = function(deployer) {
deployer.deploy(DappToken, 1000000);
};
Then truffle test
to check everything is working
How to allocate the initial supply?
In DappToken.js
Take the first account from ganache, and check the balance of of the account
New code
return tokenInstance.balanceOf(accounts[0]);
}).then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account" )
});
}).then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account" )
});
See the var tokenInstance;
Total code:
const DappToken = artifacts.require("DappToken");
contract("DappToken", function(accounts) {
var tokenInstance;
it("sets the total supply upon deployment", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.totalSupply();
})
.then(function(totalSupply) {
assert.equal(totalSupply.toNumber(), 1000000, "sets the total supply to 1,000,000");
return tokenInstance.balanceOf(accounts[0]);
}).then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account" )
});
});
});
contract("DappToken", function(accounts) {
var tokenInstance;
it("sets the total supply upon deployment", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.totalSupply();
})
.then(function(totalSupply) {
assert.equal(totalSupply.toNumber(), 1000000, "sets the total supply to 1,000,000");
return tokenInstance.balanceOf(accounts[0]);
}).then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account" )
});
});
});
DappToken.sol
pragma solidity >=0.4.22 <0.7.0;
contract DappToken {
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
constructor (uint256 _initialSupply) public {
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
}
}
contract DappToken {
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
constructor (uint256 _initialSupply) public {
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
}
}
Get the accounts:
web3.eth.getAccounts(function(err,res) { accounts = res; });
Add name, symbol and standard:
string public name = "DApp Token";
string public symbol = "DAPP";
string public standard = "DApp Token v1.0";
string public symbol = "DAPP";
string public standard = "DApp Token v1.0";
pragma solidity >=0.4.22 <0.7.0;
contract DappToken {
string public name = "DApp Token";
string public symbol = "DAPP";
string public standard = "DApp Token v1.0";
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
constructor (uint256 _initialSupply) public {
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
}
}
contract DappToken {
string public name = "DApp Token";
string public symbol = "DAPP";
string public standard = "DApp Token v1.0";
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
constructor (uint256 _initialSupply) public {
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
}
}
DappToken.js (Test)
const DappToken = artifacts.require("DappToken");
contract("DappToken", function(accounts) {
var tokenInstance;
it("initialize the contract with correct values", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.name();
})
.then(function(name) {
assert.equal(name, "DApp Token", "has the correct name");
return tokenInstance.symbol();
})
.then(function(symbol) {
assert.equal(symbol, "DAPP", "has the correct symbol");
return tokenInstance.standard();
})
.then(function(standard) {
assert.equal(standard, "DApp Token v1.0", "has the correct standard");
});
});
it("allocates the initial supply supply upon deployment", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.totalSupply();
})
.then(function(totalSupply) {
assert.equal(totalSupply.toNumber(), 1000000, "sets the total supply to 1,000,000");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account");
});
});
});
contract("DappToken", function(accounts) {
var tokenInstance;
it("initialize the contract with correct values", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.name();
})
.then(function(name) {
assert.equal(name, "DApp Token", "has the correct name");
return tokenInstance.symbol();
})
.then(function(symbol) {
assert.equal(symbol, "DAPP", "has the correct symbol");
return tokenInstance.standard();
})
.then(function(standard) {
assert.equal(standard, "DApp Token v1.0", "has the correct standard");
});
});
it("allocates the initial supply supply upon deployment", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.totalSupply();
})
.then(function(totalSupply) {
assert.equal(totalSupply.toNumber(), 1000000, "sets the total supply to 1,000,000");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account");
});
});
});
Transfer tokens
DappToken.sol
pragma solidity >=0.4.22 <0.7.0;
contract DappToken {
string public name = "DApp Token";
string public symbol = "DAPP";
string public standard = "DApp Token v1.0";
uint256 public totalSupply;
//4. Its there in documentation, please see it.
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value
);
mapping(address => uint256) public balanceOf;
constructor (uint256 _initialSupply) public {
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
}
// 1. Transfer, please also look at the documentation
function transfer(address _to, uint256 _value) public returns (bool success) {
// 2. Exception if account doesn't have enough
require(balanceOf[msg.sender] >= _value, "Don't have enough money");
//3. Transfer the balance
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
//5. Transfer Event
emit Transfer(msg.sender, _to, _value);
//6. Return a boolean
return true;
}
}
contract DappToken {
string public name = "DApp Token";
string public symbol = "DAPP";
string public standard = "DApp Token v1.0";
uint256 public totalSupply;
//4. Its there in documentation, please see it.
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value
);
mapping(address => uint256) public balanceOf;
constructor (uint256 _initialSupply) public {
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
}
// 1. Transfer, please also look at the documentation
function transfer(address _to, uint256 _value) public returns (bool success) {
// 2. Exception if account doesn't have enough
require(balanceOf[msg.sender] >= _value, "Don't have enough money");
//3. Transfer the balance
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
//5. Transfer Event
emit Transfer(msg.sender, _to, _value);
//6. Return a boolean
return true;
}
}
tokenInstance.transfer.call
You don't get a transaction receipt.
tokenInstance.transfer
You do get a transaction receipt.
it("transfer token ownership", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
// console.log(accounts[1])
return tokenInstance.transfer.call(accounts[1], 999999999999);
})
.then(assert.fail)
.catch(function(error) {
// console.log(error.message)
assert(error.message.indexOf("revert") >= 0, "error message must contain revert");
return tokenInstance.transfer.call(accounts[1], 250000, { from: accounts[0] });
})
.then(function(success) {
assert.equal(success, true, "it return true");
return tokenInstance.transfer(accounts[1], 250000, { from: accounts[0] });
})
.then(function(receipt) {
assert.equal(receipt.logs.length, 1, "triggers one event");
assert.equal(receipt.logs[0].event, "Transfer", 'should be "Transfer event');
assert.equal(receipt.logs[0].args._from, accounts[0], "logs the account the tokens are transferred from");
assert.equal(receipt.logs[0].args._to, accounts[1], "logs the account the tokens are transferred to");
assert.equal(receipt.logs[0].args._value, 250000, "logs the transfer amount");
return tokenInstance.balanceOf(accounts[1]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 250000, "adds the amount to the receiving account");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 750000, "deducts the amount from the sending account");
});
});
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
// console.log(accounts[1])
return tokenInstance.transfer.call(accounts[1], 999999999999);
})
.then(assert.fail)
.catch(function(error) {
// console.log(error.message)
assert(error.message.indexOf("revert") >= 0, "error message must contain revert");
return tokenInstance.transfer.call(accounts[1], 250000, { from: accounts[0] });
})
.then(function(success) {
assert.equal(success, true, "it return true");
return tokenInstance.transfer(accounts[1], 250000, { from: accounts[0] });
})
.then(function(receipt) {
assert.equal(receipt.logs.length, 1, "triggers one event");
assert.equal(receipt.logs[0].event, "Transfer", 'should be "Transfer event');
assert.equal(receipt.logs[0].args._from, accounts[0], "logs the account the tokens are transferred from");
assert.equal(receipt.logs[0].args._to, accounts[1], "logs the account the tokens are transferred to");
assert.equal(receipt.logs[0].args._value, 250000, "logs the transfer amount");
return tokenInstance.balanceOf(accounts[1]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 250000, "adds the amount to the receiving account");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 750000, "deducts the amount from the sending account");
});
});
Total Code:
DappToken.js
const DappToken = artifacts.require("DappToken");
contract("DappToken", function(accounts) {
var tokenInstance;
it("initialize the contract with correct values", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.name();
})
.then(function(name) {
assert.equal(name, "DApp Token", "has the correct name");
return tokenInstance.symbol();
})
.then(function(symbol) {
assert.equal(symbol, "DAPP", "has the correct symbol");
return tokenInstance.standard();
})
.then(function(standard) {
assert.equal(standard, "DApp Token v1.0", "has the correct standard");
});
});
it("allocates the initial supply supply upon deployment", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.totalSupply();
})
.then(function(totalSupply) {
assert.equal(totalSupply.toNumber(), 1000000, "sets the total supply to 1,000,000");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account");
});
});
it("transfer token ownership", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
// console.log(accounts[1])
return tokenInstance.transfer.call(accounts[1], 999999999999);
})
.then(assert.fail)
.catch(function(error) {
// console.log(error.message)
assert(error.message.indexOf("revert") >= 0, "error message must contain revert");
return tokenInstance.transfer.call(accounts[1], 250000, { from: accounts[0] });
})
.then(function(success) {
assert.equal(success, true, "it return true");
return tokenInstance.transfer(accounts[1], 250000, { from: accounts[0] });
})
.then(function(receipt) {
assert.equal(receipt.logs.length, 1, "triggers one event");
assert.equal(receipt.logs[0].event, "Transfer", 'should be "Transfer event');
assert.equal(receipt.logs[0].args._from, accounts[0], "logs the account the tokens are transferred from");
assert.equal(receipt.logs[0].args._to, accounts[1], "logs the account the tokens are transferred to");
assert.equal(receipt.logs[0].args._value, 250000, "logs the transfer amount");
return tokenInstance.balanceOf(accounts[1]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 250000, "adds the amount to the receiving account");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 750000, "deducts the amount from the sending account");
});
});
});
contract("DappToken", function(accounts) {
var tokenInstance;
it("initialize the contract with correct values", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.name();
})
.then(function(name) {
assert.equal(name, "DApp Token", "has the correct name");
return tokenInstance.symbol();
})
.then(function(symbol) {
assert.equal(symbol, "DAPP", "has the correct symbol");
return tokenInstance.standard();
})
.then(function(standard) {
assert.equal(standard, "DApp Token v1.0", "has the correct standard");
});
});
it("allocates the initial supply supply upon deployment", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
return tokenInstance.totalSupply();
})
.then(function(totalSupply) {
assert.equal(totalSupply.toNumber(), 1000000, "sets the total supply to 1,000,000");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(adminBalance) {
assert.equal(adminBalance.toNumber(), 1000000, "it allocates the intial supply to the admin account");
});
});
it("transfer token ownership", function() {
return DappToken.deployed()
.then(function(instance) {
tokenInstance = instance;
// console.log(accounts[1])
return tokenInstance.transfer.call(accounts[1], 999999999999);
})
.then(assert.fail)
.catch(function(error) {
// console.log(error.message)
assert(error.message.indexOf("revert") >= 0, "error message must contain revert");
return tokenInstance.transfer.call(accounts[1], 250000, { from: accounts[0] });
})
.then(function(success) {
assert.equal(success, true, "it return true");
return tokenInstance.transfer(accounts[1], 250000, { from: accounts[0] });
})
.then(function(receipt) {
assert.equal(receipt.logs.length, 1, "triggers one event");
assert.equal(receipt.logs[0].event, "Transfer", 'should be "Transfer event');
assert.equal(receipt.logs[0].args._from, accounts[0], "logs the account the tokens are transferred from");
assert.equal(receipt.logs[0].args._to, accounts[1], "logs the account the tokens are transferred to");
assert.equal(receipt.logs[0].args._value, 250000, "logs the transfer amount");
return tokenInstance.balanceOf(accounts[1]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 250000, "adds the amount to the receiving account");
return tokenInstance.balanceOf(accounts[0]);
})
.then(function(balance) {
assert.equal(balance.toNumber(), 750000, "deducts the amount from the sending account");
});
});
});