From c82fd030ba7a81abcd300ea859df609dc3f59b0b Mon Sep 17 00:00:00 2001 From: 0xdavinchee <0xdavinchee@gmail.com> Date: Thu, 28 Sep 2023 15:56:38 +0300 Subject: [PATCH] fix pure supertoken issue --- .../contracts/superfluid/SuperToken.sol | 24 ++-- .../superfluid/SuperToken.NonStandard.test.ts | 2 +- .../test/foundry/superfluid/SuperToken.t.sol | 111 ++++++++++++++++++ 3 files changed, 127 insertions(+), 10 deletions(-) diff --git a/packages/ethereum-contracts/contracts/superfluid/SuperToken.sol b/packages/ethereum-contracts/contracts/superfluid/SuperToken.sol index a67183252d..793dfa0bcf 100644 --- a/packages/ethereum-contracts/contracts/superfluid/SuperToken.sol +++ b/packages/ethereum-contracts/contracts/superfluid/SuperToken.sol @@ -733,20 +733,26 @@ contract SuperToken is bytes memory userData, bytes memory operatorData ) internal { - if (address(_underlyingToken) == address(0)) revert SUPER_TOKEN_NO_UNDERLYING_TOKEN(); + bool hasNoUnderlying = address(_underlyingToken) == address(0); (uint256 underlyingAmount, uint256 adjustedAmount) = _toUnderlyingAmount(amount); - // _burn will check the (actual) amount availability again - _burn(operator, account, adjustedAmount, userData.length != 0, userData, operatorData); + adjustedAmount = hasNoUnderlying ? amount : adjustedAmount; - uint256 amountBefore = _underlyingToken.balanceOf(address(this)); - _underlyingToken.safeTransfer(to, underlyingAmount); - uint256 amountAfter = _underlyingToken.balanceOf(address(this)); - uint256 actualDowngradedAmount = amountBefore - amountAfter; - if (underlyingAmount != actualDowngradedAmount) revert SUPER_TOKEN_INFLATIONARY_DEFLATIONARY_NOT_SUPPORTED(); + // _burn will check the (actual) amount availability again + _burn(operator, account, adjustedAmount, userData.length != 0, userData, operatorData); - emit TokenDowngraded(account, adjustedAmount); + if (!hasNoUnderlying) { + uint256 amountBefore = _underlyingToken.balanceOf(address(this)); + _underlyingToken.safeTransfer(to, underlyingAmount); + uint256 amountAfter = _underlyingToken.balanceOf(address(this)); + uint256 actualDowngradedAmount = amountBefore - amountAfter; + if (underlyingAmount != actualDowngradedAmount) { + revert SUPER_TOKEN_INFLATIONARY_DEFLATIONARY_NOT_SUPPORTED(); + } + + emit TokenDowngraded(account, adjustedAmount); + } } /** diff --git a/packages/ethereum-contracts/test/contracts/superfluid/SuperToken.NonStandard.test.ts b/packages/ethereum-contracts/test/contracts/superfluid/SuperToken.NonStandard.test.ts index 7f03b825aa..29b0c585b6 100644 --- a/packages/ethereum-contracts/test/contracts/superfluid/SuperToken.NonStandard.test.ts +++ b/packages/ethereum-contracts/test/contracts/superfluid/SuperToken.NonStandard.test.ts @@ -744,7 +744,7 @@ describe("SuperToken's Non Standard Functions", function () { await expectCustomError( customToken.downgrade(100), customToken, - reason + "SF_TOKEN_BURN_INSUFFICIENT_BALANCE" ); await web3tx(customToken.initialize, "customToken.initialize")( ZERO_ADDRESS, diff --git a/packages/ethereum-contracts/test/foundry/superfluid/SuperToken.t.sol b/packages/ethereum-contracts/test/foundry/superfluid/SuperToken.t.sol index 3f80f3d779..69ec68e159 100644 --- a/packages/ethereum-contracts/test/foundry/superfluid/SuperToken.t.sol +++ b/packages/ethereum-contracts/test/foundry/superfluid/SuperToken.t.sol @@ -7,6 +7,7 @@ import { UUPSProxiable } from "../../../contracts/upgradability/UUPSProxiable.so import { IERC20, ISuperToken, SuperToken } from "../../../contracts/superfluid/SuperToken.sol"; import { ConstantOutflowNFT, IConstantOutflowNFT } from "../../../contracts/superfluid/ConstantOutflowNFT.sol"; import { ConstantInflowNFT, IConstantInflowNFT } from "../../../contracts/superfluid/ConstantInflowNFT.sol"; +import { IPureSuperToken } from "../../../contracts/interfaces/tokens/IPureSuperToken.sol"; import { FoundrySuperfluidTester } from "../FoundrySuperfluidTester.sol"; import { TestToken } from "../../../contracts/utils/TestToken.sol"; import { TokenDeployerLibrary } from "../../../contracts/utils/SuperfluidFrameworkDeploymentSteps.sol"; @@ -234,4 +235,114 @@ contract SuperTokenIntegrationTest is FoundrySuperfluidTester { UUPSProxiable(address(localSuperToken)).updateCode(address(newSuperTokenLogic)); vm.stopPrank(); } + + function testPureSuperTokenDowngrade(address holder, int256 initialSupply, int256 downgradeAmount) public { + _assumeValidPureSuperTokenBurnConditions(holder, initialSupply, downgradeAmount); + + vm.startPrank(holder); + (IPureSuperToken pureSuperToken) = sfDeployer.deployPureSuperToken("Mr. Token", "MR", uint256(initialSupply)); + uint256 initialTotalSupply = pureSuperToken.totalSupply(); + pureSuperToken.downgrade(uint256(downgradeAmount)); + vm.stopPrank(); + + assertEq( + pureSuperToken.totalSupply(), + initialTotalSupply - uint256(downgradeAmount), + "testPureSuperTokenDowngrade: total supply not updated correctly" + ); + } + + function testPureSuperTokenDowngradeTo(address holder, address to, int256 initialSupply, int256 downgradeAmount) + public + { + _assumeValidPureSuperTokenBurnConditions(holder, initialSupply, downgradeAmount); + + vm.startPrank(holder); + (IPureSuperToken pureSuperToken) = sfDeployer.deployPureSuperToken("Mr. Token", "MR", uint256(initialSupply)); + uint256 initialTotalSupply = pureSuperToken.totalSupply(); + // @note this function doesn't do anything except for burning the tokens + // that is, `to` receives nothing + pureSuperToken.downgradeTo(to, uint256(downgradeAmount)); + vm.stopPrank(); + + assertEq( + pureSuperToken.totalSupply(), + initialTotalSupply - uint256(downgradeAmount), + "testPureSuperTokenDowngradeTo: total supply not updated correctly" + ); + } + + function testPureSuperTokenBurn(address holder, int256 initialSupply, int256 downgradeAmount) public { + _assumeValidPureSuperTokenBurnConditions(holder, initialSupply, downgradeAmount); + + vm.startPrank(holder); + (IPureSuperToken pureSuperToken) = sfDeployer.deployPureSuperToken("Mr. Token", "MR", uint256(initialSupply)); + uint256 initialTotalSupply = pureSuperToken.totalSupply(); + pureSuperToken.burn(uint256(downgradeAmount), ""); + vm.stopPrank(); + + assertEq( + pureSuperToken.totalSupply(), + initialTotalSupply - uint256(downgradeAmount), + "testPureSuperTokenBurn: total supply not updated correctly" + ); + } + + function testPureSuperTokenOperatorBurn( + address operator, + address holder, + int256 initialSupply, + int256 downgradeAmount + ) public { + _assumeValidPureSuperTokenBurnConditions(holder, initialSupply, downgradeAmount); + + vm.startPrank(holder); + (IPureSuperToken pureSuperToken) = sfDeployer.deployPureSuperToken("Mr. Token", "MR", uint256(initialSupply)); + pureSuperToken.authorizeOperator(operator); + vm.stopPrank(); + + assertTrue( + pureSuperToken.isOperatorFor(operator, holder), "testPureSuperTokenOperatorBurn: operator not authorized" + ); + uint256 initialTotalSupply = pureSuperToken.totalSupply(); + + vm.startPrank(operator); + pureSuperToken.operatorBurn(holder, uint256(downgradeAmount), "", ""); + vm.stopPrank(); + + assertEq( + pureSuperToken.totalSupply(), + initialTotalSupply - uint256(downgradeAmount), + "testPureSuperTokenOperatorBurn: total supply not updated correctly" + ); + } + + function testPureSuperTokenOperationDowngrade(address holder, int256 initialSupply, int256 downgradeAmount) + public + { + _assumeValidPureSuperTokenBurnConditions(holder, initialSupply, downgradeAmount); + + vm.startPrank(holder); + (IPureSuperToken pureSuperToken) = sfDeployer.deployPureSuperToken("Mr. Token", "MR", uint256(initialSupply)); + uint256 initialTotalSupply = pureSuperToken.totalSupply(); + vm.stopPrank(); + vm.startPrank(address(sf.host)); + pureSuperToken.operationDowngrade(holder, uint256(downgradeAmount)); + vm.stopPrank(); + + assertEq( + pureSuperToken.totalSupply(), + initialTotalSupply - uint256(downgradeAmount), + "testPureSuperTokenOperatorBurn: total supply not updated correctly" + ); + } + + function _assumeValidPureSuperTokenBurnConditions(address holder, int256 initialSupply, int256 downgradeAmount) + internal + { + vm.assume(initialSupply > downgradeAmount); + vm.assume(initialSupply > 0); + vm.assume(downgradeAmount > 0); + vm.assume(holder != address(0)); + } }