@dnextco/tokenboost-solidity-erc223token/test/ERC223Token.js

Solidity contracts for TokenBoost (ERC223Token)

const ERC223Token = artifacts.require("ERC223Token");
const ERROR_MSG = 'VM Exception while processing transaction: revert';


contract('ERC223Token Test', async (accounts) => {

    it('should supply', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            false,
            false
        );

        assert.equal(await token.activated(), false);

        await token.activate();

        assert.equal(await token.totalSupply(), 21000000);
        assert.equal(await token.balanceOf(accounts[0]), 21000000);
    });

    it('should transfer to EOA', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            false,
            false
        );

        try {
            await token.contract.transfer["address,uint256"](accounts[1], 10, {from: accounts[0]});
        } catch (e) {
            await console.log(ERROR_MSG);
        }

        await token.activate();

        await token.contract.transfer["address,uint256"](accounts[1], 10, {from: accounts[0]});
        assert.equal(await token.balanceOf(accounts[0]), 21000000 - 10);
        assert.equal(await token.balanceOf(accounts[1]), 10);
    });

    it('should transfer to CA', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            false,
            false
        );

        try {
            await token.contract.transfer["address,uint256"](token.address, 10, {from: accounts[0]});
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.activate();

        try {
            await token.contract.transfer["address,uint256"](token.address, 10, {from: accounts[0]});

        } catch (e) {
            console.log(ERROR_MSG);
        }

        assert.equal(await token.balanceOf(accounts[0]), 21000000);
        assert.equal(await token.balanceOf(token.address), 0);
    });

    it('should pause and unpause', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            false,
            true
        );

        assert.equal(await token.paused(), false);

        try {
            await token.contract.transfer["address,uint256"](accounts[1], 10, {from: accounts[0]});
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.activate();

        await token.pause();
        assert.equal(await token.paused(), true);

        try {
            await token.contract.transfer["address,uint256"](accounts[1], 10, {from: accounts[0]});
        } catch (e) {
            console.log(ERROR_MSG);
        }

        try {
            await token.approve(accounts[2], 10);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        try {
            await token.increaseApproval(accounts[2], 10);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        try {
            await token.decreaseApproval(accounts[2], 10);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        try {
            await token.transferFrom(accounts[0], accounts[1], 10, {from: accounts[2]});
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.unpause();
        assert.equal(await token.paused(), false);

        await token.contract.transfer["address,uint256"](accounts[1], 10, {from: accounts[0]});
        assert.equal(await token.balanceOf(accounts[0]), 21000000 - 10);
        assert.equal(await token.balanceOf(accounts[1]), 10);

        await token.approve(accounts[2], 10);
        assert.equal(await token.allowance(accounts[0], accounts[2]), 10);

        await token.increaseApproval(accounts[2], 10);
        assert.equal(await token.allowance(accounts[0], accounts[2]), 20);

        await token.decreaseApproval(accounts[2], 10);
        assert.equal(await token.allowance(accounts[0], accounts[2]), 10);

        await token.transferFrom(accounts[0], accounts[1], 10, {from: accounts[2]});
        assert.equal(await token.balanceOf(accounts[1]), 20);
        assert.equal(await token.allowance(accounts[0], accounts[2]), 0);

    });

    it('should not be able to pause', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            false,
            false
        );

        try {
            await token.pause();
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.activate();

        try {
            await token.pause();
        } catch (e) {
            console.log(ERROR_MSG);
        }

    });

    it('should burn', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            true,
            false
        );

        try {
            await token.burn(10);
        } catch (e) {
            console.log(ERROR_MSG)
        }

        await token.activate();

        assert.equal(await token.balanceOf(accounts[0]), 21000000);
        assert.equal(await token.totalSupply(), 21000000);

        await token.burn(1000000);

        assert.equal(await token.balanceOf(accounts[0]), 20000000);
        assert.equal(await token.totalSupply(), 20000000);

        await token.contract.transfer["address,uint256"](accounts[1], 10000000, {from: accounts[0]});
        assert.equal(await token.balanceOf(accounts[0]), 10000000);
        assert.equal(await token.balanceOf(accounts[1]), 10000000);

        await token.burn(10000000, {from: accounts[1]});
        assert.equal(await token.balanceOf(accounts[1]), 0);
        assert.equal(await token.totalSupply(), 10000000);

    });

    it('should not be able to burn', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            false,
            false
        );

        try {
            await token.burn(1000000);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.activate();

        try {
            await token.burn(1000000);
        } catch (e) {
            console.log(ERROR_MSG);
        }

    });

    it('should mint', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            true,
            false,
            false
        );

        await token.setMaxMintable(22000000);

        try {
            await token.mint(accounts[1], 1000000);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.activate();

        try {
            await token.setMaxMintable(23000000);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        assert.equal(await token.balanceOf(accounts[1]), 0);
        assert.equal(await token.totalSupply(), 21000000);

        try {
            await token.mint(accounts[1], 1000000);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.addMinter(accounts[0]);

        await token.mint(accounts[1], 1000000);
        assert.equal(await token.balanceOf(accounts[1]), 1000000);
        assert.equal(await token.totalSupply(), 22000000);

        try {
            await token.mint(accounts[1], 1);
        } catch (e) {
            console.log(ERROR_MSG);
        }

    });

    it('should not be able to mint', async () => {

        let token = await ERC223Token.new(accounts[0], "Bitcoin", "BTC");
        await token.update(
            "Bitcoin",
            "BTC",
            8,
            21000000,
            false,
            false,
            false
        );

        await token.setMaxMintable(22000000);
        await token.addMinter(accounts[0]);

        try {
            await token.mint(accounts[1], 1);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        await token.activate();

        try {
            await token.mint(accounts[0], 1);
        } catch (e) {
            console.log(ERROR_MSG);
        }

        try {
            await token.mint(accounts[1], 1);
        } catch (e) {
            console.log(ERROR_MSG);
        }

    });
});