feat: add erc20 paymaster

contracts/contracts/NODL.sol

@@ -7,10 +7,13 @@ import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC2
 import {ERC20Capped} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
 import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
 
-contract NODL is ERC20, ERC20Burnable, ERC20Capped, AccessControl {
+contract NODL is ERC20Burnable, ERC20Capped, AccessControl {
     bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
+    uint256 public constant MAX_SUPPLY = 21_000_000_000;
+    uint8 public constant DECIMALS = 11;
 
-    constructor(address defaultAdmin, address minter) ERC20("Nodle Token", "NODL") ERC20Capped(21000000000 * (10 ** 18)) {
+
+    constructor(address defaultAdmin, address minter) ERC20("Nodle Token", "NODL") ERC20Capped(MAX_SUPPLY * (10 ** DECIMALS)) {
         _grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);
         _grantRole(MINTER_ROLE, minter);
     }
@@ -19,12 +22,7 @@ contract NODL is ERC20, ERC20Burnable, ERC20Capped, AccessControl {
         _mint(to, amount);
     }
 
-    // The following functions are overrides required by Solidity.
-
-    function _update(address from, address to, uint256 value)
-        internal
-        override(ERC20, ERC20Capped)
-    {
-        super._update(from, to, value);
+    function _update(address from, address to, uint256 value) internal override(ERC20, ERC20Capped) {
+        ERC20Capped._update(from, to, value);
     }
 }

contracts/test/NODL.test.ts

@@ -7,12 +7,14 @@ describe("NODL", function () {
   let tokenContract: Contract;
   let ownerWallet: Wallet;
   let userWallet: Wallet;
+  const mintAmount = 1000n;
 
   before(async function () {
     ownerWallet = getWallet(LOCAL_RICH_WALLETS[0].privateKey);
     userWallet = getWallet(LOCAL_RICH_WALLETS[1].privateKey);
 
     tokenContract = await deployContract("NODL", [ownerWallet.address, ownerWallet.address], { wallet: ownerWallet, silent: true, skipChecks: true });
+    await tokenContract.waitForDeployment();
   });
 
   it("Should be deployed with no supply", async function () {
@@ -22,10 +24,10 @@ describe("NODL", function () {
 
   it("Should be mintable", async () => {
     const balanceBefore = await tokenContract.balanceOf(userWallet.address);
-    const mintAmount = ethers.parseEther("1000");
     const initialSupply = await tokenContract.totalSupply();
 
-    await tokenContract.mint(userWallet.address, mintAmount);
+    const minTx = await tokenContract.connect(ownerWallet).mint(userWallet.address, mintAmount);
+    await minTx.wait();
 
     const balanceAfter = await tokenContract.balanceOf(userWallet.address);
     expect(balanceAfter).to.equal(balanceBefore + mintAmount);
@@ -36,20 +38,32 @@ describe("NODL", function () {
 
   it("Should be burnable", async () => {
     const balanceBefore = await tokenContract.balanceOf(userWallet.address);
-    const burnAmount = ethers.parseEther("1000");
     const initialSupply = await tokenContract.totalSupply();
+    const burnAmount = mintAmount/2n;
 
-    await tokenContract.connect(userWallet).burn(burnAmount);
+    const userBurnTx = await tokenContract.connect(userWallet).burn(burnAmount);
+    await userBurnTx.wait();
 
-    const balanceAfter = await tokenContract.balanceOf(userWallet.address);
-    expect(balanceAfter).to.equal(balanceBefore - burnAmount);
+    const balanceAfterUserBurn = await tokenContract.balanceOf(userWallet.address);
+    expect(balanceAfterUserBurn).to.equal(balanceBefore - burnAmount);
+    const supplyAfterUserBurn = await tokenContract.totalSupply();
+    expect(supplyAfterUserBurn).to.equal(initialSupply - burnAmount);
 
-    const finalSupply = await tokenContract.totalSupply();
-    expect(finalSupply).to.equal(initialSupply - burnAmount);
+    const userApproveTx = await tokenContract.connect(userWallet).approve(ownerWallet.address, burnAmount);
+    await userApproveTx.wait();
+
+    const approvedBurnTx = await tokenContract.connect(ownerWallet).burnFrom(userWallet.address, burnAmount);
+    await approvedBurnTx.wait();
+
+    const balanceAfterApprovedBurn = await tokenContract.balanceOf(userWallet.address);
+    expect(balanceAfterApprovedBurn).to.equal(balanceBefore - mintAmount);
+
+    const supplyAfterApprovedBurn = await tokenContract.totalSupply();
+    expect(supplyAfterApprovedBurn).to.equal(initialSupply - mintAmount);
   });
 
   it("Has a max supply of 21 billion", async () => {
-    const maxSupply = ethers.parseEther("21000000000");
+    const maxSupply = ethers.parseUnits("21000000000", 11);
     const cap = await tokenContract.cap();
     expect(cap).to.equal(maxSupply);
   });
@@ -59,12 +73,13 @@ describe("NODL", function () {
     const currentSupply = await tokenContract.totalSupply();
 
     const maxMint = cap - currentSupply;
-    await tokenContract.mint(userWallet.address, maxMint);
+    const mintAllTx = await tokenContract.connect(ownerWallet).mint(userWallet.address, maxMint);
+    await mintAllTx.wait();
+
+    expect(await tokenContract.balanceOf(userWallet.address)).to.equal(maxMint);
+    expect(await tokenContract.totalSupply()).to.equal(cap);
 
-    await expect(
-      tokenContract.mint(userWallet.address, 1)
-    ).to.be
-      .revertedWithCustomError(tokenContract, "ERC20ExceededCap")
-      .withArgs(cap + 1n, cap);
+    const mintAboveCapTx = tokenContract.connect(ownerWallet).mint(userWallet.address, 1);
+    await expect(mintAboveCapTx).to.be.revertedWithCustomError(tokenContract, "ERC20ExceededCap").withArgs(cap + 1n, cap);
   });
 });