feat: improved test coverage part two

contracts/interchain-token-service/InterchainTokenService.sol

@@ -841,7 +841,7 @@ contract InterchainTokenService is IInterchainTokenService, Upgradable, Operatab
     function _decodeMetadata(bytes memory metadata) internal pure returns (uint32 version, bytes memory data) {
         data = new bytes(metadata.length - 4);
         assembly {
-            version := shr(224, mload(data))
+            version := shr(224, mload(add(metadata, 32)))
         }
         if (data.length == 0) return (version, data);
         uint256 n = (data.length - 1) / 32;

contracts/test/InvalidStandardizedToken.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import { IERC20MintableBurnable } from '../interfaces/IERC20MintableBurnable.sol';
+import { ITokenManager } from '../interfaces/ITokenManager.sol';
+
+import { InterchainToken } from '../interchain-token/InterchainToken.sol';
+import { ERC20Permit } from '../token-implementations/ERC20Permit.sol';
+import { AddressBytesUtils } from '../libraries/AddressBytesUtils.sol';
+import { Implementation } from '../utils/Implementation.sol';
+import { Distributable } from '../utils/Distributable.sol';
+
+contract InvalidStandardizedToken is IERC20MintableBurnable, InterchainToken, ERC20Permit, Implementation, Distributable {
+    using AddressBytesUtils for bytes;
+
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+    address internal tokenManager_;
+
+    bytes32 private constant CONTRACT_ID = keccak256('invalid-standardized-token');
+
+    modifier onlyDistributorOrTokenManager() {
+        if (msg.sender != tokenManager_) {
+            if (msg.sender != distributor()) revert NotDistributor();
+        }
+
+        _;
+    }
+
+    /**
+     * @notice Getter for the contract id.
+     */
+    function contractId() external pure returns (bytes32) {
+        return CONTRACT_ID;
+    }
+
+    /**
+     * @notice Returns the token manager for this token
+     * @return ITokenManager The token manager contract
+     */
+    function tokenManager() public view override returns (ITokenManager) {
+        return ITokenManager(tokenManager_);
+    }
+
+    /**
+     * @notice Setup function to initialize contract parameters
+     * @param params The setup parameters in bytes
+     * The setup params include tokenManager, distributor, tokenName, symbol, decimals, mintAmount and mintTo
+     */
+    function setup(bytes calldata params) external override onlyProxy {
+        {
+            address distributor_;
+            address tokenManagerAddress;
+            string memory tokenName;
+            (tokenManagerAddress, distributor_, tokenName, symbol, decimals) = abi.decode(
+                params,
+                (address, address, string, string, uint8)
+            );
+
+            tokenManager_ = tokenManagerAddress;
+            name = tokenName;
+
+            _setDistributor(distributor_);
+            _setNameHash(tokenName);
+        }
+        {
+            uint256 mintAmount;
+            address mintTo;
+            (, , , , , mintAmount, mintTo) = abi.decode(params, (address, address, string, string, uint8, uint256, address));
+
+            if (mintAmount > 0 && mintTo != address(0)) {
+                _mint(mintTo, mintAmount);
+            }
+        }
+    }
+
+    /**
+     * @notice Function to mint new tokens
+     * Can only be called by the distributor address.
+     * @param account The address that will receive the minted tokens
+     * @param amount The amount of tokens to mint
+     */
+    function mint(address account, uint256 amount) external onlyDistributorOrTokenManager {
+        _mint(account, amount);
+    }
+
+    /**
+     * @notice Function to burn tokens
+     * Can only be called by the distributor address.
+     * @param account The address that will have its tokens burnt
+     * @param amount The amount of tokens to burn
+     */
+    function burn(address account, uint256 amount) external onlyDistributorOrTokenManager {
+        _burn(account, amount);
+    }
+}

contracts/test/MockAxelarGateway.sol

@@ -77,6 +77,10 @@ contract MockAxelarGateway is IMockAxelarGateway {
         _addressStorage[_getTokenAddressKey(symbol)] = tokenAddress;
     }
 
+    function setCommandExecuted(bytes32 commandId, bool executed) external {
+        _setCommandExecuted(commandId, executed);
+    }
+
     /********************\
     |* Pure Key Getters *|
     \********************/

contracts/test/utils/MulticallTest.sol

@@ -22,6 +22,11 @@ contract MulticallTest is Multicall {
         return nonce_;
     }
 
+    function function3() external pure {
+        // solhint-disable-next-line reason-string
+        revert();
+    }
+
     function multicallTest(bytes[] calldata data) external {
         lastMulticallReturns = multicall(data);
     }

scripts/deploy.js

@@ -6,7 +6,7 @@ const { deployCreate3Contract, getCreate3Address } = require('@axelar-network/ax
 
 async function deployContract(wallet, contractName, args = []) {
     const factory = await ethers.getContractFactory(contractName, wallet);
-    const contract = await factory.deploy(...args);
+    const contract = await factory.deploy(...args).then((d) => d.deployed());
 
     return contract;
 }
@@ -103,6 +103,7 @@ module.exports = {
     deployContract,
     deployRemoteAddressValidator,
     deployMockGateway,
+    deployTokenManagerImplementations,
     deployGasService,
     deployInterchainTokenService,
     deployAll,

test/ERC20.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const chai = require('chai');
+const { ethers } = require('hardhat');
+const {
+    Contract,
+    constants: { MaxUint256, AddressZero },
+} = ethers;
+const { expect } = chai;
+const { getRandomBytes32, expectRevert } = require('./utils');
+const { deployContract } = require('../scripts/deploy');
+
+const StandardizedToken = require('../artifacts/contracts/token-implementations/StandardizedToken.sol/StandardizedToken.json');
+
+describe('ERC20', () => {
+    let standardizedToken, standardizedTokenDeployer;
+
+    const name = 'tokenName';
+    const symbol = 'tokenSymbol';
+    const decimals = 18;
+    const mintAmount = 123;
+
+    let token;
+
+    let owner, user;
+
+    before(async () => {
+        const wallets = await ethers.getSigners();
+        owner = wallets[0];
+        user = wallets[1];
+
+        standardizedToken = await deployContract(owner, 'StandardizedToken');
+        standardizedTokenDeployer = await deployContract(owner, 'StandardizedTokenDeployer', [standardizedToken.address]);
+
+        const salt = getRandomBytes32();
+
+        const tokenAddress = await standardizedTokenDeployer.deployedAddress(salt);
+
+        token = new Contract(tokenAddress, StandardizedToken.abi, owner);
+
+        await standardizedTokenDeployer
+            .deployStandardizedToken(salt, owner.address, owner.address, name, symbol, decimals, mintAmount, owner.address)
+            .then((tx) => tx.wait());
+    });
+
+    it('should increase and decrease allowance', async () => {
+        const initialAllowance = await token.allowance(user.address, owner.address);
+        expect(initialAllowance).to.eq(0);
+
+        await expect(token.connect(user).increaseAllowance(owner.address, MaxUint256))
+            .to.emit(token, 'Approval')
+            .withArgs(user.address, owner.address, MaxUint256);
+
+        const increasedAllowance = await token.allowance(user.address, owner.address);
+        expect(increasedAllowance).to.eq(MaxUint256);
+
+        await expect(token.connect(user).decreaseAllowance(owner.address, MaxUint256))
+            .to.emit(token, 'Approval')
+            .withArgs(user.address, owner.address, 0);
+
+        const finalAllowance = await token.allowance(user.address, owner.address);
+        expect(finalAllowance).to.eq(0);
+    });
+
+    it('should revert on approve with invalid owner or sender', async () => {
+        await expectRevert(
+            (gasOptions) => token.connect(owner).transferFrom(AddressZero, owner.address, 0, gasOptions),
+            token,
+            'InvalidAccount',
+        );
+
+        await expectRevert(
+            (gasOptions) => token.connect(user).increaseAllowance(AddressZero, MaxUint256, gasOptions),
+            token,
+            'InvalidAccount',
+        );
+    });
+
+    it('should revert on transfer to invalid address', async () => {
+        const initialAllowance = await token.allowance(user.address, owner.address);
+        expect(initialAllowance).to.eq(0);
+
+        await expect(token.connect(user).increaseAllowance(owner.address, MaxUint256))
+            .to.emit(token, 'Approval')
+            .withArgs(user.address, owner.address, MaxUint256);
+
+        const increasedAllowance = await token.allowance(user.address, owner.address);
+        expect(increasedAllowance).to.eq(MaxUint256);
+
+        const amount = 100;
+
+        await expectRevert(
+            (gasOptions) => token.connect(owner).transferFrom(user.address, AddressZero, amount, gasOptions),
+            token,
+            'InvalidAccount',
+        );
+    });
+
+    it('should revert mint or burn to invalid address', async () => {
+        const amount = 100;
+        await expectRevert((gasOptions) => token.mint(AddressZero, amount, gasOptions), token, 'InvalidAccount');
+        await expectRevert((gasOptions) => token.burn(AddressZero, amount, gasOptions), token, 'InvalidAccount');
+    });
+});