Otoken: Burn and Mint

contracts/Otoken.sol

@@ -70,6 +70,26 @@ contract Otoken is ERC20Initializable {
         __ERC20_init_unchained(name, symbol);
     }
 
+    /**
+     * @notice Mint oToken for an account.
+     * @dev this is a Controller only method. Access control is taken care of by _beforeTokenTransfer hook.
+     * @param account the account to mint token to
+     * @param amount the amount to mint
+     */
+    function mintOtoken(address account, uint256 amount) external {
+        _mint(account, amount);
+    }
+
+    /**
+     * @notice Burn oToken from an account.
+     * @dev this is a Controller only method. Access control is taken care of by _beforeTokenTransfer hook.
+     * @param account the account to burn token from
+     * @param amount the amount to burn
+     */
+    function burnOtoken(address account, uint256 amount) external {
+        _burn(account, amount);
+    }
+
     /**
      * @notice generate name and symbol for an option
      * @return name ETHUSDC 05-September-2020 200 Put USDC Collateral
@@ -149,7 +169,7 @@ contract Otoken is ERC20Initializable {
     }
 
     /**
-     * @dev return string of optino type
+     * @dev return string of option type
      * @return symbol P or C
      * @return full Put or Call
      */
@@ -193,4 +213,30 @@ contract Otoken is ERC20Initializable {
             return ("DEC", "December");
         }
     }
+
+    /**
+     * @dev this function overrides the _beforeTokenTransfer hook in ERC20Initializable.sol.
+     * If the operation is mint or burn, requires msg.sender to be the controller.
+     * The function signature is the same as _beforeTokenTransfer defined in ERC20Initializable.sol.
+     * @param from from address
+     * @param to to address
+     * @param amount amount to transfer
+     */
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override {
+        if (from == address(0)) {
+            require(
+                msg.sender == AddressBookInterface(addressBook).getController(),
+                "Otoken: Only Controller can mint Otokens."
+            );
+        } else if (to == address(0)) {
+            require(
+                msg.sender == AddressBookInterface(addressBook).getController(),
+                "Otoken: Only Controller can burn Otokens."
+            );
+        }
+    }
 }

contracts/mocks/MockAddressBook.sol

@@ -5,6 +5,7 @@ contract MockAddressBook {
     address private _otokenImpl;
     address private _whitelist;
     address private _otokenFactoryImpl;
+    address private _controllerImpl;
 
     function setOtokenImpl(address _newImpl) external {
         _otokenImpl = _newImpl;
@@ -26,7 +27,15 @@ contract MockAddressBook {
         return _otokenFactoryImpl;
     }
 
+    function getController() external view returns (address) {
+        return _controllerImpl;
+    }
+
     function setOtokenFactory(address _otokenFactory) external {
         _otokenFactoryImpl = _otokenFactory;
     }
+
+    function setController(address _controller) external {
+        _controllerImpl = _controller;
+    }
 }

test/Otoken.test.ts

@@ -5,12 +5,14 @@ const {expectRevert} = require('@openzeppelin/test-helpers')
 
 const Otoken = artifacts.require('Otoken.sol')
 const MockERC20 = artifacts.require('MockERC20.sol')
+const MockAddressBook = artifacts.require('MockAddressBook')
 const ZERO_ADDR = '0x0000000000000000000000000000000000000000'
 const ETH_ADDR = ZERO_ADDR
 
-contract('Otoken', ([deployer, mockAddressBook, random]) => {
+contract('Otoken', ([deployer, controller, user1, user2, random]) => {
   let otoken: OtokenInstance
   let usdc: MockERC20Instance
+  let mockAddressBookAddr: string
 
   // let expiry: number;
   const strikePrice = new BigNumber(200).times(new BigNumber(10).exponentiatedBy(18))
@@ -19,7 +21,13 @@ contract('Otoken', ([deployer, mockAddressBook, random]) => {
 
   before('Deployment', async () => {
     // Need another mock contract for addressbook when we add ERC20 operations.
-    otoken = await Otoken.new(mockAddressBook)
+    const addressBook = await MockAddressBook.new()
+    mockAddressBookAddr = addressBook.address
+    await addressBook.setController(controller)
+
+    // deploy oToken with addressbook
+    otoken = await Otoken.new(addressBook.address)
+
     usdc = await MockERC20.new('USDC', 'USDC')
   })
 
@@ -55,23 +63,23 @@ contract('Otoken', ([deployer, mockAddressBook, random]) => {
     })
 
     it('should set the right name for calls', async () => {
-      const call = await Otoken.new(mockAddressBook)
+      const call = await Otoken.new(mockAddressBookAddr)
       await call.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, expiry, false, {from: deployer})
       assert.equal(await call.name(), `ETHUSDC 25-September-2020 200Call USDC Collateral`)
       assert.equal(await call.symbol(), `oETHUSDC-25SEP20-200C`)
     })
 
     it('should set the right name for non-eth options', async () => {
       const weth = await MockERC20.new('WETH', 'WETH')
-      const put = await Otoken.new(mockAddressBook)
+      const put = await Otoken.new(mockAddressBookAddr)
       await put.init(weth.address, usdc.address, usdc.address, strikePrice, expiry, isPut, {from: deployer})
       assert.equal(await put.name(), `WETHUSDC 25-September-2020 200Put USDC Collateral`)
       assert.equal(await put.symbol(), `oWETHUSDC-25SEP20-200P`)
     })
 
     it('should revert when init asset with non-erc20 address', async () => {
       /* This behavior should've been banned by factory) */
-      const put = await Otoken.new(mockAddressBook)
+      const put = await Otoken.new(mockAddressBookAddr)
       await expectRevert(
         put.init(random, usdc.address, usdc.address, strikePrice, expiry, isPut, {from: deployer}),
         'revert',
@@ -80,15 +88,15 @@ contract('Otoken', ([deployer, mockAddressBook, random]) => {
 
     it('should set the right name for options with 0 expiry (should be banned by factory)', async () => {
       /* This behavior should've been banned by factory) */
-      const otoken = await Otoken.new(mockAddressBook)
+      const otoken = await Otoken.new(mockAddressBookAddr)
       await otoken.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 0, isPut, {from: deployer})
       assert.equal(await otoken.name(), `ETHUSDC 01-January-1970 200Put USDC Collateral`)
       assert.equal(await otoken.symbol(), `oETHUSDC-01JAN70-200P`)
     })
 
     it('should set the right name for options expiry on 2345/12/31', async () => {
       /** This is the largest timestamp that the factoy will allow (the largest bokkypoobah covers) **/
-      const otoken = await Otoken.new(mockAddressBook)
+      const otoken = await Otoken.new(mockAddressBookAddr)
       const _expiry = '11865394800' // Mon, 31 Dec 2345
       await otoken.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, _expiry, isPut, {from: deployer})
       assert.equal(await otoken.name(), `ETHUSDC 31-December-2345 200Put USDC Collateral`)
@@ -97,72 +105,148 @@ contract('Otoken', ([deployer, mockAddressBook, random]) => {
 
     it('should set the right name and symbol for expiry on each month', async () => {
       // We need to go through all decision branches in _getMonth() to make a 100% test coverage.
-      const January = await Otoken.new(mockAddressBook)
+      const January = await Otoken.new(mockAddressBookAddr)
       await January.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1893456000, isPut, {from: deployer})
       assert.equal(await January.name(), 'ETHUSDC 01-January-2030 200Put USDC Collateral')
       assert.equal(await January.symbol(), 'oETHUSDC-01JAN30-200P')
 
-      const February = await Otoken.new(mockAddressBook)
+      const February = await Otoken.new(mockAddressBookAddr)
       await February.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1896134400, isPut, {from: deployer})
       assert.equal(await February.name(), 'ETHUSDC 01-February-2030 200Put USDC Collateral')
       assert.equal(await February.symbol(), 'oETHUSDC-01FEB30-200P')
 
-      const March = await Otoken.new(mockAddressBook)
+      const March = await Otoken.new(mockAddressBookAddr)
       await March.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1898553600, isPut, {from: deployer})
       assert.equal(await March.name(), 'ETHUSDC 01-March-2030 200Put USDC Collateral')
       assert.equal(await March.symbol(), 'oETHUSDC-01MAR30-200P')
 
-      const April = await Otoken.new(mockAddressBook)
+      const April = await Otoken.new(mockAddressBookAddr)
       await April.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1901232000, isPut, {from: deployer})
       assert.equal(await April.name(), 'ETHUSDC 01-April-2030 200Put USDC Collateral')
       assert.equal(await April.symbol(), 'oETHUSDC-01APR30-200P')
 
-      const May = await Otoken.new(mockAddressBook)
+      const May = await Otoken.new(mockAddressBookAddr)
       await May.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1903824000, isPut, {from: deployer})
       assert.equal(await May.name(), 'ETHUSDC 01-May-2030 200Put USDC Collateral')
       assert.equal(await May.symbol(), 'oETHUSDC-01MAY30-200P')
 
-      const June = await Otoken.new(mockAddressBook)
+      const June = await Otoken.new(mockAddressBookAddr)
       await June.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1906502400, isPut, {from: deployer})
       assert.equal(await June.name(), 'ETHUSDC 01-June-2030 200Put USDC Collateral')
       assert.equal(await June.symbol(), 'oETHUSDC-01JUN30-200P')
 
-      const July = await Otoken.new(mockAddressBook)
+      const July = await Otoken.new(mockAddressBookAddr)
       await July.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1909094400, isPut, {from: deployer})
       assert.equal(await July.name(), 'ETHUSDC 01-July-2030 200Put USDC Collateral')
       assert.equal(await July.symbol(), 'oETHUSDC-01JUL30-200P')
 
-      const August = await Otoken.new(mockAddressBook)
+      const August = await Otoken.new(mockAddressBookAddr)
       await August.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1911772800, isPut, {from: deployer})
       assert.equal(await August.name(), 'ETHUSDC 01-August-2030 200Put USDC Collateral')
       assert.equal(await August.symbol(), 'oETHUSDC-01AUG30-200P')
 
-      const September = await Otoken.new(mockAddressBook)
+      const September = await Otoken.new(mockAddressBookAddr)
       await September.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1914451200, isPut, {from: deployer})
       assert.equal(await September.name(), 'ETHUSDC 01-September-2030 200Put USDC Collateral')
       assert.equal(await September.symbol(), 'oETHUSDC-01SEP30-200P')
 
-      const October = await Otoken.new(mockAddressBook)
+      const October = await Otoken.new(mockAddressBookAddr)
       await October.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1917043200, isPut, {from: deployer})
       assert.equal(await October.name(), 'ETHUSDC 01-October-2030 200Put USDC Collateral')
       assert.equal(await October.symbol(), 'oETHUSDC-01OCT30-200P')
 
-      const November = await Otoken.new(mockAddressBook)
+      const November = await Otoken.new(mockAddressBookAddr)
       await November.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1919721600, isPut, {from: deployer})
       assert.equal(await November.name(), 'ETHUSDC 01-November-2030 200Put USDC Collateral')
       assert.equal(await November.symbol(), 'oETHUSDC-01NOV30-200P')
 
-      const December = await Otoken.new(mockAddressBook)
+      const December = await Otoken.new(mockAddressBookAddr)
       await December.init(ETH_ADDR, usdc.address, usdc.address, strikePrice, 1922313600, isPut, {from: deployer})
       assert.equal(await December.name(), 'ETHUSDC 01-December-2030 200Put USDC Collateral')
       assert.equal(await December.symbol(), 'oETHUSDC-01DEC30-200P')
     })
 
     it('should display strikePrice as $0 in name and symbol when strikePrice < 10^18', async () => {
-      const testOtoken = await Otoken.new(mockAddressBook)
+      const testOtoken = await Otoken.new(mockAddressBookAddr)
       await testOtoken.init(ETH_ADDR, usdc.address, usdc.address, 0, expiry, isPut, {from: deployer})
       assert.equal(await testOtoken.name(), `ETHUSDC 25-September-2020 0Put USDC Collateral`)
       assert.equal(await testOtoken.symbol(), `oETHUSDC-25SEP20-0P`)
     })
   })
+
+  describe('Token operations: Mint', () => {
+    const amountToMint = new BigNumber(10).times(new BigNumber(10).exponentiatedBy(18))
+    it('should be able to mint tokens from controller address', async () => {
+      await otoken.mintOtoken(user1, amountToMint, {from: controller})
+      const balance = await otoken.balanceOf(user1)
+      assert.equal(balance.toString(), amountToMint.toString())
+    })
+
+    it('should revert when minting from random address', async () => {
+      await expectRevert(
+        otoken.mintOtoken(user1, amountToMint, {from: random}),
+        'Otoken: Only Controller can mint Otokens.',
+      )
+    })
+
+    it('should revert when someone try to mint for himself.', async () => {
+      await expectRevert(
+        otoken.mintOtoken(user1, amountToMint, {from: user1}),
+        'Otoken: Only Controller can mint Otokens.',
+      )
+    })
+  })
+
+  describe('Token operations: Transfer', () => {
+    const amountToMint = new BigNumber(10).times(new BigNumber(10).exponentiatedBy(18))
+    it('should be able to transfer tokens from user 1 to user 2', async () => {
+      await otoken.transfer(user2, amountToMint, {from: user1})
+      const balance = await otoken.balanceOf(user2)
+      assert.equal(balance.toString(), amountToMint.toString())
+    })
+
+    it('should revert when calling transferFrom with no allownace', async () => {
+      await expectRevert(
+        otoken.transferFrom(user2, user1, amountToMint, {from: random}),
+        'ERC20: transfer amount exceeds allowance',
+      )
+    })
+
+    it('should revert when controller call transferFrom with no allownace', async () => {
+      await expectRevert(
+        otoken.transferFrom(user2, user1, amountToMint, {from: controller}),
+        'ERC20: transfer amount exceeds allowance',
+      )
+    })
+
+    it('should be able to use transferFrom to transfer token from user2 to user1.', async () => {
+      await otoken.approve(random, amountToMint, {from: user2})
+      await otoken.transferFrom(user2, user1, amountToMint, {from: random})
+      const user2Remaining = await otoken.balanceOf(user2)
+      assert.equal(user2Remaining.toString(), '0')
+    })
+  })
+
+  describe('Token operations: Burn', () => {
+    const amountToMint = new BigNumber(10).times(new BigNumber(10).exponentiatedBy(18))
+    it('should revert when burning from random address', async () => {
+      await expectRevert(
+        otoken.burnOtoken(user1, amountToMint, {from: random}),
+        'Otoken: Only Controller can burn Otokens.',
+      )
+    })
+
+    it('should revert when someone trys to burn for himeself', async () => {
+      await expectRevert(
+        otoken.burnOtoken(user1, amountToMint, {from: user1}),
+        'Otoken: Only Controller can burn Otokens.',
+      )
+    })
+
+    it('should be able to burn tokens from controller address', async () => {
+      await otoken.burnOtoken(user1, amountToMint, {from: controller})
+      const balance = await otoken.balanceOf(user1)
+      assert.equal(balance.toString(), '0')
+    })
+  })
 })