From cabe17251425582ec2df78fa133c108d50440b0b Mon Sep 17 00:00:00 2001 From: prateek105 Date: Fri, 8 Sep 2023 19:57:05 +0530 Subject: [PATCH] Add missing external functions tests for burn wrapped ajna --- test/unit/BurnWrappedToken.t.sol | 158 +++++++++++++++++++++++++++++++ 1 file changed, 158 insertions(+) diff --git a/test/unit/BurnWrappedToken.t.sol b/test/unit/BurnWrappedToken.t.sol index 37214162..0297ed23 100644 --- a/test/unit/BurnWrappedToken.t.sol +++ b/test/unit/BurnWrappedToken.t.sol @@ -8,6 +8,8 @@ import { Test } from "@std/Test.sol"; import { AjnaToken } from "../../src/token/AjnaToken.sol"; import { BurnWrappedAjna } from "../../src/token/BurnWrapper.sol"; +import { SigUtils } from "../utils/SigUtils.sol"; + contract BurnWrappedTokenTest is Test { /*************/ @@ -16,6 +18,7 @@ contract BurnWrappedTokenTest is Test { AjnaToken internal _token; BurnWrappedAjna internal _wrappedToken; + SigUtils internal _sigUtils; address internal _ajnaAddress = 0x9a96ec9B57Fb64FbC60B423d1f4da7691Bd35079; // mainnet ajna token address address internal _tokenDeployer = 0x666cf594fB18622e1ddB91468309a7E194ccb799; // mainnet token deployer @@ -35,6 +38,8 @@ contract BurnWrappedTokenTest is Test { // reference mainnet deployment _token = AjnaToken(_ajnaAddress); _wrappedToken = new BurnWrappedAjna(IERC20(address(_token))); + + _sigUtils = new SigUtils(_wrappedToken.DOMAIN_SEPARATOR()); } function approveAndWrapTokens(address account_, uint256 amount_) internal { @@ -127,4 +132,157 @@ contract BurnWrappedTokenTest is Test { _wrappedToken.withdrawTo(_tokenHolder, 25 * 1e18); } + function testApproveAndTransfer() external { + uint256 tokensToTransfer = 500 * 1e18; + address tokenReceiver = makeAddr("tokenReceiver"); + + // transfer some tokens to the test address + vm.startPrank(_tokenDeployer); + _token.approve(address(_tokenDeployer), tokensToTransfer); + _token.transferFrom(_tokenDeployer, _tokenHolder, tokensToTransfer); + + // wrap tokens + approveAndWrapTokens(_tokenHolder, tokensToTransfer); + + // approve some tokens to the receiver address + vm.startPrank(_tokenHolder); + _wrappedToken.approve(tokenReceiver, tokensToTransfer); + + // check token allowance + assertEq(_wrappedToken.allowance(_tokenHolder, tokenReceiver), tokensToTransfer); + + // transfer tokens + changePrank(tokenReceiver); + _wrappedToken.transferFrom(_tokenHolder, tokenReceiver, tokensToTransfer); + + // ensure tokens are transferred + assertEq(_wrappedToken.balanceOf(tokenReceiver), tokensToTransfer); + } + + function testIncreaseAndDecreaseAllowance() external { + uint256 tokensToTransfer = 500 * 1e18; + address tokenReceiver = makeAddr("tokenReceiver"); + + // transfer some tokens to the test address + vm.startPrank(_tokenDeployer); + _token.approve(address(_tokenDeployer), tokensToTransfer); + _token.transferFrom(_tokenDeployer, _tokenHolder, tokensToTransfer); + + // wrap tokens + approveAndWrapTokens(_tokenHolder, tokensToTransfer); + + // approve some tokens to the test address + vm.startPrank(_tokenHolder); + _wrappedToken.approve(tokenReceiver, tokensToTransfer); + + // increase token allowance to 1000 tokens + _wrappedToken.increaseAllowance(tokenReceiver, 500 * 1e18); + + // check allowance is increased + assertEq(_wrappedToken.allowance(_tokenHolder, tokenReceiver), 1000 * 1e18); + + // decrease token allowance to 200 tokens + _wrappedToken.decreaseAllowance(tokenReceiver, 800 * 1e18); + + // check allowance is decreased + assertEq(_wrappedToken.allowance(_tokenHolder, tokenReceiver), 200 * 1e18); + } + + function testDomainSeparatorAndUnderlyingToken() external { + bytes32 expectedDomainSeparator = keccak256( + abi.encode( + keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), + keccak256(bytes("Burn Wrapped AJNA")), + keccak256(bytes("1")), + block.chainid, + address(_wrappedToken) + ) + ); + + assertEq(_wrappedToken.DOMAIN_SEPARATOR(), expectedDomainSeparator); + + assertEq(address(_wrappedToken.underlying()), address(_token)); + } + + function testTransferWithPermit() external { + uint256 tokensToTransfer = 500 * 1e18; + + // define owner and spender addresses + (address owner, uint256 ownerPrivateKey) = makeAddrAndKey("owner"); + address spender = makeAddr("spender"); + address newOwner = makeAddr("newOwner"); + + // set owner balance + deal(address(_wrappedToken), owner, tokensToTransfer); + + // check owner and spender balances + assertEq(_wrappedToken.balanceOf(owner), tokensToTransfer); + assertEq(_wrappedToken.balanceOf(spender), 0); + assertEq(_wrappedToken.balanceOf(newOwner), 0); + + // TEST transfer with ERC20 permit + vm.startPrank(owner); + SigUtils.Permit memory permit = SigUtils.Permit({ + owner: owner, + spender: spender, + value: tokensToTransfer, + nonce: 0, + deadline: block.timestamp + 1 days + }); + + bytes32 digest = _sigUtils.getTypedDataHash(permit); + (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest); + _wrappedToken.permit(owner, spender, tokensToTransfer, permit.deadline, v, r, s); + + // check nonces is increased + assertEq(_wrappedToken.nonces(owner), 1); + + changePrank(spender); + _wrappedToken.transferFrom(owner, newOwner, tokensToTransfer); + + // check owner and spender balances after transfer + assertEq(_wrappedToken.balanceOf(owner), 0); + assertEq(_wrappedToken.balanceOf(spender), 0); + assertEq(_wrappedToken.balanceOf(newOwner), tokensToTransfer); + assertEq(_wrappedToken.allowance(owner, spender), 0); + } + + function testBurn() external { + uint256 tokensToBurn = 500 * 1e18; + + // transfer some tokens to the test address + vm.startPrank(_tokenDeployer); + _token.approve(address(_tokenDeployer), tokensToBurn); + _token.transferFrom(_tokenDeployer, _tokenHolder, tokensToBurn); + + // wrap tokens + approveAndWrapTokens(_tokenHolder, tokensToBurn); + + uint256 totalTokenSupply = _wrappedToken.totalSupply(); + + uint256 snapshot = vm.snapshot(); + + // burn tokens + _wrappedToken.burn(tokensToBurn); + + // ensure tokens are burned + assertEq(_wrappedToken.balanceOf(_tokenHolder), 0); + assertEq(_wrappedToken.totalSupply(), totalTokenSupply - tokensToBurn); + + vm.revertTo(snapshot); + + address tokenBurner = makeAddr("tokenBurner"); + + // approve tokens to token burner address + _wrappedToken.approve(tokenBurner, tokensToBurn); + + // burn tokens + changePrank(tokenBurner); + _wrappedToken.burnFrom(_tokenHolder, tokensToBurn); + + // ensure tokens are burned + assertEq(_wrappedToken.balanceOf(_tokenHolder), 0); + assertEq(_wrappedToken.totalSupply(), totalTokenSupply - tokensToBurn); + } + }