@bananapus/core-v6 0.0.1

package/test/units/static/JBTokens/TestBurnFrom.sol

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+
+contract TestBurnFrom_Local is JBTokensSetup {
+    uint256 _projectId = 1;
+    uint256 _defaultAmount = 1e18;
+
+    // Mocks
+    IJBToken _token = IJBToken(makeAddr("token"));
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    modifier whenCallerIsController() {
+        // mock call to JBDirectory controllerOf
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        _;
+    }
+
+    function test_GivenTheCallingAmountGTTokenbalancePlusCreditbalanceOfHolder() external whenCallerIsController {
+        // it will revert INSUFFICIENT_FUNDS
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_InsufficientTokensToBurn.selector, _defaultAmount, 0));
+        _tokens.burnFrom(address(this), _projectId, _defaultAmount);
+    }
+
+    function test_GivenThereIsACreditBalance() external whenCallerIsController {
+        // it will subtract credits from creditBalanceOf and totalCreditSupplyOf
+
+        // Find the storage slot to set credit balance
+        bytes32 creditBalanceOfSlot = keccak256(abi.encode(address(this), uint256(0)));
+        bytes32 slot = keccak256(abi.encode(_projectId, uint256(creditBalanceOfSlot)));
+
+        // Set storage
+        vm.store(address(_tokens), slot, bytes32(_defaultAmount));
+
+        // Ensure it is correctly set
+        uint256 _creditBalance = _tokens.creditBalanceOf(address(this), _projectId);
+        assertEq(_defaultAmount, _creditBalance);
+
+        // Find the storage slot to set totalCreditSupplyOf
+        bytes32 totalCreditSlot = keccak256(abi.encode(_projectId, uint256(3)));
+        // Set storage
+        vm.store(address(_tokens), totalCreditSlot, bytes32(_defaultAmount));
+
+        // Ensure it is correctly set
+        uint256 _totalCreditSupply = _tokens.totalCreditSupplyOf(_projectId);
+        assertEq(_defaultAmount, _totalCreditSupply);
+
+        _tokens.burnFrom(address(this), _projectId, _defaultAmount);
+
+        // Ensure amount is zeroed now
+        uint256 _totalCreditSupplyAfter = _tokens.totalCreditSupplyOf(_projectId);
+        assertEq(0, _totalCreditSupplyAfter);
+
+        // Ensure it is correctly set
+        uint256 _creditBalanceAfter = _tokens.creditBalanceOf(address(this), _projectId);
+        assertEq(0, _creditBalanceAfter);
+    }
+
+    function test_GivenThereIsErc20TokenBalance() external whenCallerIsController {
+        // it will burn tokens
+
+        // Find the storage slot to set credit balance
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        // Ensure it's set
+        IJBToken _storedToken = _tokens.tokenOf(_projectId);
+        assertEq(address(_storedToken), address(_token));
+
+        // mock call to token balanceOf
+        mockExpect(address(_token), abi.encodeCall(IJBToken.balanceOf, (address(this))), abi.encode(_defaultAmount));
+
+        // mock call to token burn()
+        mockExpect(address(_token), abi.encodeCall(IJBToken.burn, (address(this), _defaultAmount)), "");
+
+        _tokens.burnFrom(address(this), _projectId, _defaultAmount);
+    }
+
+    function test_WhenCallerDNEQController() external {
+        // it will revert CONTROLLER_UNAUTHORIZED
+
+        // mock call that says zero address is controller of project
+        mockExpect(
+            address(directory),
+            abi.encodeCall(IJBDirectory.controllerOf, (_projectId)),
+            // will cause revert
+            abi.encode(address(0))
+        );
+
+        vm.expectRevert(abi.encodeWithSelector(JBControlled.JBControlled_ControllerUnauthorized.selector, address(0)));
+        _tokens.burnFrom(address(this), _projectId, _defaultAmount);
+    }
+}

package/test/units/static/JBTokens/TestClaimTokensFor.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+
+contract TestClaimTokensFor_Local is JBTokensSetup {
+    uint256 _projectId = 1;
+    uint256 _defaultAmount = 1e18;
+    address _holder = address(this);
+    address _beneficiary = makeAddr("guy");
+
+    // Mocks
+    IJBToken _token = IJBToken(makeAddr("token"));
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    modifier whenCallerIsController() {
+        // mock call to JBDirectory controllerOf
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        _;
+    }
+
+    function test_GivenTokenAddressEQZero() external whenCallerIsController {
+        // it will revert TOKEN_NOT_FOUND
+
+        // Find the storage slot to set credit balance
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(0)))));
+
+        vm.expectRevert(JBTokens.JBTokens_TokenNotFound.selector);
+        _tokens.claimTokensFor(_holder, _projectId, _defaultAmount, _beneficiary);
+    }
+
+    function test_GivenCreditBalanceOfGTCallingAmount() external whenCallerIsController {
+        // it will revert INSUFFICIENT_CREDITS
+
+        // Find the storage slot to set credit balance
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_InsufficientCredits.selector, _defaultAmount, 0));
+        _tokens.claimTokensFor(_holder, _projectId, _defaultAmount, _beneficiary);
+    }
+
+    function test_GivenHappyPath() external whenCallerIsController {
+        // it will mint to the beneficiary and emit ClaimTokens
+
+        // Find the storage slot to set credit balance
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        // Find the storage slot to set credit balance
+        bytes32 creditBalanceOfSlot = keccak256(abi.encode(address(this), uint256(0)));
+        bytes32 slot = keccak256(abi.encode(_projectId, uint256(creditBalanceOfSlot)));
+
+        // Set storage
+        vm.store(address(_tokens), slot, bytes32(_defaultAmount));
+
+        // Ensure it is correctly set
+        uint256 _creditBalance = _tokens.creditBalanceOf(address(this), _projectId);
+        assertEq(_defaultAmount, _creditBalance);
+
+        // Find the storage slot to set totalCreditSupplyOf
+        bytes32 totalCreditSlot = keccak256(abi.encode(_projectId, uint256(3)));
+        // Set storage
+        vm.store(address(_tokens), totalCreditSlot, bytes32(_defaultAmount));
+
+        // Ensure it is correctly set
+        uint256 _totalCreditSupply = _tokens.totalCreditSupplyOf(_projectId);
+        assertEq(_defaultAmount, _totalCreditSupply);
+
+        // mock call to token mint()
+        mockExpect(address(_token), abi.encodeCall(IJBToken.mint, (_beneficiary, _defaultAmount)), "");
+
+        _tokens.claimTokensFor(_holder, _projectId, _defaultAmount, _beneficiary);
+
+        // Ensure amount is zeroed now
+        uint256 _totalCreditSupplyAfter = _tokens.totalCreditSupplyOf(_projectId);
+        assertEq(0, _totalCreditSupplyAfter);
+
+        // Ensure it is correctly set
+        uint256 _creditBalanceAfter = _tokens.creditBalanceOf(address(this), _projectId);
+        assertEq(0, _creditBalanceAfter);
+    }
+
+    function test_WhenCallerIsNotController() external {
+        // it will revert CONTROLLER_UNAUTHORIZED
+
+        // mock call to JBDirectory controllerOf
+        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(0)));
+
+        vm.expectRevert(abi.encodeWithSelector(JBControlled.JBControlled_ControllerUnauthorized.selector, address(0)));
+        _tokens.claimTokensFor(_holder, _projectId, _defaultAmount, _beneficiary);
+    }
+}

package/test/units/static/JBTokens/TestDeployERC20ForUnits.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+
+contract TestDeployERC20ForUnits_Local is JBTokensSetup {
+    uint256 _projectId = 1;
+    string _name = "Juice";
+    string _symbol = "JBX";
+    IJBToken _token = IJBToken(makeAddr("JBX"));
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    modifier whenCallerIsController() {
+        // mock call to JBDirectory controllerOf
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        _;
+    }
+
+    function test_WhenNameLengthEQZero() external whenCallerIsController {
+        // it will revert EMPTY_NAME
+
+        vm.expectRevert(JBTokens.JBTokens_EmptyName.selector);
+        _tokens.deployERC20For({projectId: _projectId, name: "", symbol: _symbol, salt: bytes32(0)});
+    }
+
+    function test_WhenSymbolLengthEQZero() external whenCallerIsController {
+        // it will revert EMPTY_SYMBOL
+
+        vm.expectRevert(JBTokens.JBTokens_EmptySymbol.selector);
+        _tokens.deployERC20For({projectId: _projectId, name: _name, symbol: "", salt: bytes32(0)});
+    }
+
+    function test_WhenProjectAlreadyHasAConfiguredToken() external whenCallerIsController {
+        // it will revert PROJECT_ALREADY_HAS_TOKEN
+
+        // Find the storage slot to set credit balance
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        // Ensure it's set
+        IJBToken _storedToken = _tokens.tokenOf(_projectId);
+        assertEq(address(_storedToken), address(_token));
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_ProjectAlreadyHasToken.selector, _storedToken));
+        _tokens.deployERC20For({projectId: _projectId, name: _name, symbol: _symbol, salt: bytes32(0)});
+    }
+
+    modifier whenHappyPath() {
+        _;
+    }
+
+    function test_GivenASaltIsProvided() external whenHappyPath whenCallerIsController {
+        // it will create and initialize a deterministic clone based on the msgsender and salt
+
+        bytes32 salt = bytes32(uint256(1));
+        bytes32 hashedSalt = keccak256(abi.encode(address(this), salt));
+        address deployer = address(_tokens);
+        address token = address(jbToken);
+
+        address predicted = Clones.predictDeterministicAddress(token, hashedSalt, deployer);
+
+        vm.expectEmit();
+        emit IJBTokens.DeployERC20(_projectId, IJBToken(predicted), _name, _symbol, salt, address(this));
+
+        IJBToken deployedToken =
+            _tokens.deployERC20For({projectId: _projectId, name: _name, symbol: _symbol, salt: salt});
+
+        assertEq(predicted, address(deployedToken));
+    }
+
+    function test_GivenASaltIsNotProvided() external whenHappyPath whenCallerIsController {
+        // it will clone and initialize a indeterministically generated clone
+
+        IJBToken deployedToken =
+            _tokens.deployERC20For({projectId: _projectId, name: _name, symbol: _symbol, salt: bytes32(0)});
+
+        if (address(deployedToken) == address(0)) revert();
+    }
+}

package/test/units/static/JBTokens/TestMintFor.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+
+contract TestMintFor_Local is JBTokensSetup {
+    uint256 _projectId = 1;
+    uint256 _defaultAmount = 1e18;
+    uint256 _totalSupply = 1e19;
+    uint256 _overflowedSupply = uint256(type(uint208).max) + 1;
+    address _holder = address(this);
+
+    // Mocks
+    IJBToken _token = IJBToken(makeAddr("token"));
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    modifier whenCallerIsControllerOfProject() {
+        // mock call to JBDirectory controllerOf
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        _;
+    }
+
+    function test_GivenTokenOfTheProjectEQZeroAddress() external whenCallerIsControllerOfProject {
+        // it will add tokens to credit balances and total credit supply
+
+        // Find the storage slot to set token
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(0)))));
+
+        _tokens.mintFor(_holder, _projectId, _defaultAmount);
+
+        // Ensure credit supply increase
+        uint256 _totalCreditSupplyAfter = _tokens.totalCreditSupplyOf(_projectId);
+        assertEq(_defaultAmount, _totalCreditSupplyAfter);
+
+        // Ensure credit balance increase
+        uint256 _creditBalanceAfter = _tokens.creditBalanceOf(address(this), _projectId);
+        assertEq(_defaultAmount, _creditBalanceAfter);
+    }
+
+    function test_GivenTokenDNEQZeroAddress() external whenCallerIsControllerOfProject {
+        // it will call token mint
+
+        // Find the storage slot to set token
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        // mock call to token mint()
+        mockExpect(address(_token), abi.encodeCall(IJBToken.mint, (_holder, _defaultAmount)), "");
+
+        // mock call to token totalSupply()
+        mockExpect(address(_token), abi.encodeCall(IJBToken.totalSupply, ()), abi.encode(_totalSupply));
+
+        _tokens.mintFor(_holder, _projectId, _defaultAmount);
+    }
+
+    function test_GivenTotalSupplyAfterMintOrCreditsGTUint208Max() external whenCallerIsControllerOfProject {
+        // it will revert OVERFLOW_ALERT
+
+        // Find the storage slot to set token
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        // mock call to token totalSupply() - overflow check happens before mint
+        mockExpect(address(_token), abi.encodeCall(IJBToken.totalSupply, ()), abi.encode(_overflowedSupply));
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBTokens.JBTokens_OverflowAlert.selector, _overflowedSupply + _defaultAmount, type(uint208).max
+            )
+        );
+        _tokens.mintFor(_holder, _projectId, _defaultAmount);
+    }
+
+    function test_WhenCallerIsNotController() external {
+        // it will revert CONTROLLER_UNAUTHORIZED
+
+        // mock call to JBDirectory controllerOf
+        mockExpect(address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(0)));
+
+        vm.expectRevert(abi.encodeWithSelector(JBControlled.JBControlled_ControllerUnauthorized.selector, address(0)));
+        _tokens.mintFor(_holder, _projectId, _defaultAmount);
+    }
+}

package/test/units/static/JBTokens/TestSetTokenFor.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+
+contract TestSetTokenFor_Local is JBTokensSetup {
+    uint256 _projectId = 1;
+
+    // Mocks
+    IJBToken _token = IJBToken(makeAddr("token"));
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    modifier whenCallerIsControllerOfProject() {
+        // mock call to JBDirectory controllerOf
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        _;
+    }
+
+    function test_WhenTokenIsTheZeroAddress() external whenCallerIsControllerOfProject {
+        // it will revert EMPTY_TOKEN
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_EmptyToken.selector, _projectId));
+        _tokens.setTokenFor(_projectId, IJBToken(address(0)));
+    }
+
+    function test_WhenATokenIsAlreadySet() external whenCallerIsControllerOfProject {
+        // it will revert TOKEN_ALREADY_SET
+
+        // Find the storage slot to set token
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_ProjectAlreadyHasToken.selector, _token));
+        _tokens.setTokenFor(_projectId, IJBToken(address(_token)));
+    }
+
+    function test_WhenATokenIsAssociatedWithAnotherProject() external whenCallerIsControllerOfProject {
+        // it will revert TOKEN_ALREADY_SET
+
+        // Find the storage slot to set token
+        bytes32 projectIdOfSlot = keccak256(abi.encode(_token, uint256(1)));
+
+        uint256 otherProjectId = 1234;
+
+        // Set storage
+        vm.store(address(_tokens), projectIdOfSlot, bytes32(uint256(otherProjectId)));
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_TokenAlreadyBeingUsed.selector, otherProjectId));
+        _tokens.setTokenFor(_projectId, IJBToken(address(_token)));
+    }
+
+    function test_WhenATokensDecimalsDNEQ18() external whenCallerIsControllerOfProject {
+        // it will revert TOKENS_MUST_HAVE_18_DECIMALS
+
+        //mock call to token decimals
+        mockExpect(address(_token), abi.encodeCall(IJBToken.decimals, ()), abi.encode(6));
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_TokensMustHave18Decimals.selector, 6));
+        _tokens.setTokenFor(_projectId, IJBToken(address(_token)));
+    }
+
+    function test_WhenHappyPath() external whenCallerIsControllerOfProject {
+        // it will set token states and emit SetToken
+
+        //mock call to token decimals
+        mockExpect(address(_token), abi.encodeCall(IJBToken.decimals, ()), abi.encode(18));
+        mockExpect(address(_token), abi.encodeCall(IJBToken.canBeAddedTo, (_projectId)), abi.encode(true));
+
+        vm.expectEmit();
+        emit IJBTokens.SetToken(_projectId, _token, address(this));
+
+        _tokens.setTokenFor(_projectId, IJBToken(address(_token)));
+    }
+
+    function test_WhenCantBeAddedTo() external whenCallerIsControllerOfProject {
+        // it will set token states and emit SetToken
+
+        //mock call to token decimals
+        mockExpect(address(_token), abi.encodeCall(IJBToken.decimals, ()), abi.encode(18));
+        mockExpect(address(_token), abi.encodeCall(IJBToken.canBeAddedTo, (_projectId)), abi.encode(false));
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_TokenCantBeAdded.selector, _projectId));
+
+        _tokens.setTokenFor(_projectId, IJBToken(address(_token)));
+    }
+}

package/test/units/static/JBTokens/TestTotalBalanceOf.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+
+contract TestTotalBalanceOf_Local is JBTokensSetup {
+    address _holder = address(this);
+    uint256 _projectId = 1;
+    uint256 _creditBalance = 1e18;
+    uint256 _tokenBalance = 2e18;
+
+    // Mocks
+    IJBToken _token = IJBToken(makeAddr("token"));
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    function test_WhenAProjectsTokenDNEQZeroAddress() external {
+        // it will return creditBalanceOf plus token balance of holder
+
+        // Find the storage slot to set credit balance
+        bytes32 creditBalanceOfSlot = keccak256(abi.encode(address(this), uint256(0)));
+        bytes32 slot = keccak256(abi.encode(_projectId, uint256(creditBalanceOfSlot)));
+
+        // Set storage
+        vm.store(address(_tokens), slot, bytes32(_creditBalance));
+
+        // Find the storage slot to set token
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        // mock call to token balanceOf
+        mockExpect(address(_token), abi.encodeCall(IJBToken.balanceOf, (_holder)), abi.encode(_tokenBalance));
+
+        uint256 totalBalance = _tokens.totalBalanceOf(_holder, _projectId);
+
+        // Ensure correct balance
+        assertEq(totalBalance, _tokenBalance + _creditBalance);
+    }
+
+    function test_WhenAProjectsTokenEQZeroAddressAndCreditBalanceEQZero() external view {
+        // it will return zero
+
+        uint256 totalBalance = _tokens.totalBalanceOf(_holder, _projectId);
+        assertEq(totalBalance, 0);
+    }
+
+    function test_WhenThereIsOnlyCreditBalance() external {
+        // it will return only the credit balance
+
+        // Find the storage slot to set credit balance
+        bytes32 creditBalanceOfSlot = keccak256(abi.encode(address(this), uint256(0)));
+        bytes32 slot = keccak256(abi.encode(_projectId, uint256(creditBalanceOfSlot)));
+
+        // Set storage
+        vm.store(address(_tokens), slot, bytes32(_creditBalance));
+
+        uint256 totalBalance = _tokens.totalBalanceOf(_holder, _projectId);
+        assertEq(totalBalance, _creditBalance);
+    }
+}

package/test/units/static/JBTokens/TestTotalSupplyOf.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+
+contract TestTotalSupplyOf_Local is JBTokensSetup {
+    uint256 _projectId = 1;
+    uint256 _defaultAmount = 1e18;
+
+    // Mocks
+    IJBToken _token = IJBToken(makeAddr("token"));
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    function test_WhenAProjectsTokenDNEQZeroAddress() external {
+        // it will return totalCreditSupplyOf plus token total supply
+
+        // Find the storage slot to set totalCreditSupplyOf
+        bytes32 totalCreditSlot = keccak256(abi.encode(_projectId, uint256(3)));
+        // Set storage
+        vm.store(address(_tokens), totalCreditSlot, bytes32(_defaultAmount));
+
+        uint256 supply = _tokens.totalSupplyOf(_projectId);
+        assertEq(supply, _defaultAmount);
+    }
+
+    function test_WhenATokenIsConfigured() external {
+        // it will return totalCreditSupply + total token supply
+
+        // Find the storage slot to set totalCreditSupplyOf
+        bytes32 totalCreditSlot = keccak256(abi.encode(_projectId, uint256(3)));
+        // Set storage
+        vm.store(address(_tokens), totalCreditSlot, bytes32(_defaultAmount));
+
+        // Find the storage slot to set totalCreditSupplyOf
+        bytes32 tokenOfSlot = keccak256(abi.encode(_projectId, uint256(2)));
+        // Set storage
+        vm.store(address(_tokens), tokenOfSlot, bytes32(uint256(uint160(address(_token)))));
+
+        // mock call to token totalSupply()
+        mockExpect(address(_token), abi.encodeCall(IJBToken.totalSupply, ()), abi.encode(_defaultAmount));
+
+        uint256 supply = _tokens.totalSupplyOf(_projectId);
+        assertEq(supply, _defaultAmount * 2);
+    }
+
+    function test_WhenAProjectsTokenEQZeroAddressAndNoCreditSupply() external view {
+        // it will return zero
+
+        uint256 zeroSupply = _tokens.totalSupplyOf(_projectId);
+        assertEq(zeroSupply, 0);
+    }
+}

package/test/units/static/JBTokens/TestTransferCreditsFrom.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBTokensSetup} from "./JBTokensSetup.sol";
+
+contract TestTransferCreditsFrom_Local is JBTokensSetup {
+    address _holder = address(this);
+    uint256 _projectId = 1;
+    address _recipient = makeAddr("guy");
+    uint256 _defaultAmount = 1e18;
+
+    function setUp() public {
+        super.tokensSetup();
+    }
+
+    modifier whenCallerIsController() {
+        // mock call to JBDirectory controllerOf
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        _;
+    }
+
+    function test_GivenCallingAmountGTCreditBalance() external whenCallerIsController {
+        // it will revert INSUFFICIENT_CREDITS
+
+        vm.expectRevert(abi.encodeWithSelector(JBTokens.JBTokens_InsufficientCredits.selector, _defaultAmount, 0));
+        _tokens.transferCreditsFrom(_holder, _projectId, _recipient, _defaultAmount);
+    }
+
+    function test_GivenHappyPath() external whenCallerIsController {
+        // it will subtract creditBalanceOf from holder to recipient and emit TransferCredits
+
+        // Find the storage slot to set credit balance
+        bytes32 creditBalanceOfSlot = keccak256(abi.encode(_holder, uint256(0)));
+        bytes32 slot = keccak256(abi.encode(_projectId, uint256(creditBalanceOfSlot)));
+
+        // Set storage
+        vm.store(address(_tokens), slot, bytes32(_defaultAmount));
+
+        // Ensure it is correctly set
+        uint256 _creditBalance = _tokens.creditBalanceOf(address(this), _projectId);
+        assertEq(_defaultAmount, _creditBalance);
+
+        vm.expectEmit();
+        emit IJBTokens.TransferCredits(_holder, _projectId, _recipient, _defaultAmount, _holder);
+
+        _tokens.transferCreditsFrom(_holder, _projectId, _recipient, _defaultAmount);
+        uint256 recipientBalance = _tokens.creditBalanceOf(_recipient, _projectId);
+        assertEq(recipientBalance, _defaultAmount);
+    }
+}