Feature/mint and call

contracts/Wallet.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/access/Ownable2Step.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "./interfaces/ERC1363.sol";
+import "./ContinuousFundraising.sol";
+
+/**
+
+ */
+
+contract Wallet is Ownable2Step, ERC1363Receiver {
+    using SafeERC20 for IERC20;
+    /**
+    @notice stores the receiving address for each IBAN hash
+    */
+    mapping(bytes32 => address) public receiverAddress;
+
+    ContinuousFundraising public fundraising;
+
+    event Set(bytes32 indexed ibanHash, address tokenReceiver);
+
+    constructor(ContinuousFundraising _fundraising) Ownable2Step() {
+        fundraising = _fundraising;
+    }
+
+    /**
+    @notice sets (or updates) the receiving address for an IBAN hash
+    */
+    function set(bytes32 _ibanHash, address _tokenReceiver) external onlyOwner {
+        receiverAddress[_ibanHash] = _tokenReceiver;
+        emit Set(_ibanHash, _tokenReceiver);
+    }
+
+    /**
+     * @notice ERC1363 callback
+     * @dev to support the mintAndCall standard, this function MUST NOT revert!
+     */
+    function onTransferReceived(
+        address operator,
+        address from,
+        uint256 value,
+        bytes memory data
+    ) external override returns (bytes4) {
+        bytes32 ibanHash = abi.decode(data, (bytes32));
+        if (receiverAddress[ibanHash] == address(0)) {
+            return bytes4(0xDEADD00D); // ERC1363ReceiverNotRegistered
+        }
+        address tokenReceiver = receiverAddress[ibanHash];
+        // todo: calculate amount
+        uint256 amount = 100;
+        // grant allowance to fundraising
+        IERC20(fundraising.currency()).approve(address(fundraising), amount);
+        // todo: add try catch https://solidity-by-example.org/try-catch/
+        fundraising.buy(amount, tokenReceiver);
+        return 0x600D600D; // ERC1363ReceiverSuccess
+    }
+
+    /*
+    @notice withdraws tokens to a given address
+    */
+    function withdraw(
+        address token,
+        address to,
+        uint256 amount
+    ) external onlyOwner {
+        IERC20(token).safeTransferFrom(address(this), to, amount);
+    }
+}

contracts/interfaces/ERC1363.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity 0.8.17;
+
+/**
+    @notice ERC1363 interface, see https://eips.ethereum.org/EIPS/eip-1363
+ */
+interface ERC1363Receiver {
+    function onTransferReceived(
+        address operator,
+        address from,
+        uint256 value,
+        bytes memory data
+    ) external returns (bytes4);
+}

test/BuyWithMintAndCall.t.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.13;
+
+import "../lib/forge-std/src/Test.sol";
+import "../contracts/Token.sol";
+import "../contracts/FeeSettings.sol";
+import "../contracts/ContinuousFundraising.sol";
+import "./resources/MintAndCallToken.sol";
+import "./resources/MaliciousPaymentToken.sol";
+import "../contracts/Wallet.sol";
+
+contract BuyWithMintAndCall is Test {
+    ContinuousFundraising raise;
+    AllowList list;
+    IFeeSettingsV1 feeSettings;
+
+    Token token;
+    MintAndCallToken paymentToken;
+    Wallet wallet;
+
+    address public constant admin = 0x0109709eCFa91a80626FF3989D68f67f5b1dD120;
+    address public constant buyer = 0x1109709ecFA91a80626ff3989D68f67F5B1Dd121;
+    address public constant mintAllower =
+        0x2109709EcFa91a80626Ff3989d68F67F5B1Dd122;
+    address public constant minter = 0x3109709ECfA91A80626fF3989D68f67F5B1Dd123;
+    address public constant owner = 0x6109709EcFA91A80626FF3989d68f67F5b1dd126;
+    address public constant receiver =
+        0x7109709eCfa91A80626Ff3989D68f67f5b1dD127;
+    address public constant paymentTokenProvider =
+        0x8109709ecfa91a80626fF3989d68f67F5B1dD128;
+    address public constant trustedForwarder =
+        0x9109709EcFA91A80626FF3989D68f67F5B1dD129;
+
+    uint8 public constant paymentTokenDecimals = 6;
+    uint256 public constant paymentTokenAmount =
+        1000 * 10 ** paymentTokenDecimals;
+
+    uint256 public constant price = 7 * 10 ** paymentTokenDecimals; // 7 payment tokens per token
+
+    uint256 public constant maxAmountOfTokenToBeSold = 20 * 10 ** 18; // 20 token
+    uint256 public constant maxAmountPerBuyer = maxAmountOfTokenToBeSold / 2; // 10 token
+    uint256 public constant minAmountPerBuyer = 1;
+
+    function setUp() public {
+        list = new AllowList();
+        Fees memory fees = Fees(100, 100, 100, 100);
+        feeSettings = new FeeSettings(fees, admin);
+
+        token = new Token(
+            trustedForwarder,
+            feeSettings,
+            admin,
+            list,
+            0x0,
+            "TESTTOKEN",
+            "TEST"
+        );
+
+        // set up currency
+        vm.startPrank(paymentTokenProvider);
+        paymentToken = new MintAndCallToken(paymentTokenDecimals);
+        vm.stopPrank();
+
+        vm.prank(owner);
+        raise = new ContinuousFundraising(
+            trustedForwarder,
+            payable(receiver),
+            minAmountPerBuyer,
+            maxAmountPerBuyer,
+            price,
+            maxAmountOfTokenToBeSold,
+            paymentToken,
+            token
+        );
+
+        // allow raise contract to mint
+        bytes32 roleMintAllower = token.MINTALLOWER_ROLE();
+
+        vm.prank(admin);
+        token.grantRole(roleMintAllower, mintAllower);
+        vm.prank(mintAllower);
+        token.increaseMintingAllowance(
+            address(raise),
+            maxAmountOfTokenToBeSold
+        );
+
+        // give raise contract allowance
+        vm.prank(buyer);
+        paymentToken.approve(address(raise), paymentTokenAmount);
+
+        // create wallet
+        vm.prank(owner);
+        wallet = new Wallet(raise);
+    }
+
+    function testBuyHappyCase() public {
+        bytes32 buyersIbanHash = keccak256(abi.encodePacked("DE1234567890"));
+        // add buyers address to wallet
+        vm.prank(owner);
+        wallet.set(buyersIbanHash, buyer);
+
+        uint currencyMintAmount = 1e20;
+
+        // make sure buyer has no tokens before
+        assertTrue(token.balanceOf(buyer) == 0);
+
+        // mint currency
+        bytes memory data = abi.encode(buyersIbanHash, 0xDEADBEEF);
+        vm.prank(paymentTokenProvider);
+        paymentToken.mintAndCall(address(wallet), currencyMintAmount, data);
+
+        // make sure buyer has tokens after
+        assertTrue(token.balanceOf(buyer) > 0);
+    }
+}

test/resources/MintAndCallToken.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.13;
+
+import "../../node_modules/@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../../node_modules/@openzeppelin/contracts/access/Ownable.sol";
+import "../../contracts/interfaces/ERC1363.sol";
+
+/*
+    fake currency to test the mint and call feature
+*/
+contract MintAndCallToken is ERC20, Ownable {
+    uint8 decimalPlaces;
+
+    constructor(uint8 _decimals) ERC20("MintAndCallToken", "MACT") Ownable() {
+        decimalPlaces = _decimals;
+    }
+
+    /// @dev price definition and deal() function rely on proper handling of decimalPlaces. Therefore we need to test if decimalPlaces other than 18 work fine, too.
+    function decimals() public view override returns (uint8) {
+        return decimalPlaces;
+    }
+
+    function mint(address _to, uint256 _amount) external onlyOwner {
+        _mint(_to, _amount);
+    }
+
+    function mintAndCall(
+        address _to,
+        uint256 _amount,
+        bytes memory _data
+    ) external onlyOwner {
+        _mint(_to, _amount);
+        ERC1363Receiver(_to).onTransferReceived(
+            msg.sender,
+            address(0),
+            _amount,
+            _data
+        );
+    }
+}