wip

time to test out boost creation and allocation

Author: topocount

packages/evm/contracts/budgets/ATransparentBudget.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.24;
+
+import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {ABudget} from "contracts/budgets/ABudget.sol";
+import {ACloneable} from "contracts/shared/ACloneable.sol";
+
+/// @title Abstract Simple ABudget
+/// @notice A minimal budget implementation that simply holds and distributes tokens (ERC20-like and native)
+/// @dev This type of budget supports ETH, ERC20, and ERC1155 assets only
+abstract contract ATransparentBudget is ABudget, IERC1155Receiver {
+    /// @inheritdoc ACloneable
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ABudget, IERC165) returns (bool) {
+        return interfaceId == type(ATransparentBudget).interfaceId || interfaceId == type(IERC1155Receiver).interfaceId
+            || interfaceId == type(IERC165).interfaceId || ABudget.supportsInterface(interfaceId);
+    }
+
+    /// @inheritdoc ACloneable
+    function getComponentInterface() public pure virtual override returns (bytes4) {
+        return type(ATransparentBudget).interfaceId;
+    }
+}

packages/evm/contracts/budgets/TransparentBudget.sol

@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.24;
+
+import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {DynamicArrayLib} from "@solady/utils/DynamicArrayLib.sol";
+import {LibTransient} from "@solady/utils/LibTransient.sol";
+
+import {Ownable} from "@solady/auth/Ownable.sol";
+import {SafeTransferLib} from "@solady/utils/SafeTransferLib.sol";
+import {ReentrancyGuard} from "@solady/utils/ReentrancyGuard.sol";
+
+import {BoostCore} from "contracts/BoostCore.sol";
+import {BoostError} from "contracts/shared/BoostError.sol";
+import {ABudget} from "contracts/budgets/ABudget.sol";
+import {ACloneable} from "contracts/shared/ACloneable.sol";
+import {ATransparentBudget} from "contracts/budgets/ATransparentBudget.sol";
+
+/*
+    TODO
+    1. test deposit and boost creation logic
+    2. implement clawback logic and tracking on deposits
+    3. implement clawback auth
+    4. implement permit2 support
+*/
+
+/// @title Simple ABudget
+/// @notice A minimal budget implementation that simply holds and distributes tokens (ERC20-like and native)
+/// @dev This type of budget supports ETH, ERC20, and ERC1155 assets only
+contract TransparentBudget is ATransparentBudget, ReentrancyGuard {
+    using SafeTransferLib for address;
+    using DynamicArrayLib for *;
+    using LibTransient for *;
+
+    /// @dev The total amount of each fungible asset distributed from the budget
+    mapping(address => uint256) private _distributedFungible;
+
+    /// @dev The total amount of each ERC1155 asset and token ID distributed from the budget
+    mapping(address => mapping(uint256 => uint256)) private _distributedERC1155;
+
+    /// @inheritdoc ABudget
+    /// @notice This is unused. Call `createBoost` with a deposit payload
+    function allocate(bytes calldata) external payable virtual override returns (bool) {
+        revert BoostError.NotImplemented();
+    }
+
+    function createBoost(bytes[] calldata _allocations, BoostCore core, bytes calldata _boostPayload)
+        external
+        payable
+        nonReentrant
+    {
+        DynamicArrayLib.DynamicArray memory allocationKeys;
+        allocationKeys.reserve(_allocations.length);
+
+        for (uint256 i = 0; i < _allocations.length; i++) {
+            bytes32 key = _allocate(_allocations[i]);
+            allocationKeys.set(i, key);
+        }
+
+        core.createBoost(_boostPayload);
+
+        bytes32[] memory keys = allocationKeys.asBytes32Array();
+        for (uint256 i = 0; i < keys.length; i++) {
+            LibTransient.TUint256 storage p = LibTransient.tUint256(keys[i]);
+            if (p.get() != 0) revert BoostError.Unauthorized();
+        }
+    }
+
+    /// @notice Allocates assets to be distributed in the boost
+    /// @param data_ The packed data for the {Transfer} request
+    /// @return key The key of the amount allocated
+    /// @dev The caller must have already approved the contract to transfer the asset
+    /// @dev If the asset transfer fails, the allocation will revert
+    function _allocate(bytes calldata data_) internal virtual returns (bytes32 key) {
+        Transfer memory request = abi.decode(data_, (Transfer));
+        if (request.assetType == AssetType.ETH) {
+            FungiblePayload memory payload = abi.decode(request.data, (FungiblePayload));
+
+            // Ensure the value received is equal to the `payload.amount`
+            if (msg.value != payload.amount) {
+                revert InvalidAllocation(request.asset, payload.amount);
+            }
+            (LibTransient.TUint256 storage p, bytes32 tKey) = getFungibleAmountAndKey(address(0));
+            p.inc(payload.amount);
+            key = tKey;
+        } else if (request.assetType == AssetType.ERC20) {
+            FungiblePayload memory payload = abi.decode(request.data, (FungiblePayload));
+
+            // Transfer `payload.amount` of the token to this contract
+            request.asset.safeTransferFrom(request.target, address(this), payload.amount);
+            if (request.asset.balanceOf(address(this)) < payload.amount) {
+                revert InvalidAllocation(request.asset, payload.amount);
+            }
+            key = bytes32(uint256(uint160(request.asset)));
+            (LibTransient.TUint256 storage p, bytes32 tKey) = getFungibleAmountAndKey(request.asset);
+            p.inc(payload.amount);
+            key = tKey;
+        } else if (request.assetType == AssetType.ERC1155) {
+            ERC1155Payload memory payload = abi.decode(request.data, (ERC1155Payload));
+
+            // Transfer `payload.amount` of `payload.tokenId` to this contract
+            IERC1155(request.asset).safeTransferFrom(
+                request.target, address(this), payload.tokenId, payload.amount, payload.data
+            );
+            if (IERC1155(request.asset).balanceOf(address(this), payload.tokenId) < payload.amount) {
+                revert InvalidAllocation(request.asset, payload.amount);
+            }
+            (LibTransient.TUint256 storage p, bytes32 tKey) = getERC1155AmountAndKey(request.asset, payload.amount);
+            p.inc(payload.amount);
+            key = tKey;
+        } else {
+            // Unsupported asset type
+            revert BoostError.NotImplemented();
+        }
+    }
+
+    function getFungibleAmountAndKey(address asset)
+        internal
+        pure
+        returns (LibTransient.TUint256 storage p, bytes32 key)
+    {
+        key = bytes32(uint256(uint160(asset)));
+        p = LibTransient.tUint256(key);
+    }
+
+    function getERC1155AmountAndKey(address asset, uint256 tokenId)
+        internal
+        pure
+        returns (LibTransient.TUint256 storage p, bytes32 key)
+    {
+        key = keccak256(abi.encodePacked(asset, tokenId));
+        p = LibTransient.tUint256(key);
+    }
+
+    /// @inheritdoc ABudget
+    /// @notice Reclaims assets from the budget
+    /// @param data_ The packed {Transfer} request
+    /// @return True if the request was successful
+    /// @dev Only the owner can directly reclaim assets from the budget
+    /// @dev If the amount is zero, the entire balance of the asset will be transferred to the receiver
+    /// @dev If the asset transfer fails, the reclamation will revert
+    function clawback(bytes calldata data_) external virtual override onlyOwner returns (uint256) {
+        uint256 amount = 0;
+        Transfer memory request = abi.decode(data_, (Transfer));
+        if (request.assetType == AssetType.ETH || request.assetType == AssetType.ERC20) {
+            FungiblePayload memory payload = abi.decode(request.data, (FungiblePayload));
+            _transferFungible(
+                request.asset, request.target, payload.amount == 0 ? available(request.asset) : payload.amount
+            );
+            amount = payload.amount;
+        } else if (request.assetType == AssetType.ERC1155) {
+            ERC1155Payload memory payload = abi.decode(request.data, (ERC1155Payload));
+            _transferERC1155(
+                request.asset,
+                request.target,
+                payload.tokenId,
+                payload.amount == 0 ? IERC1155(request.asset).balanceOf(address(this), payload.tokenId) : payload.amount,
+                payload.data
+            );
+            amount = payload.amount;
+        }
+
+        return amount;
+    }
+
+    /// @inheritdoc ABudget
+    /// @notice Disburses assets from the budget to a single recipient
+    /// @param data_ The packed {Transfer} request
+    /// @return True if the disbursement was successful
+    /// @dev If the asset transfer fails, the disbursement will revert
+    function disburse(bytes calldata data_) public virtual override returns (bool) {
+        Transfer memory request = abi.decode(data_, (Transfer));
+        if (request.assetType == AssetType.ERC20 || request.assetType == AssetType.ETH) {
+            FungiblePayload memory payload = abi.decode(request.data, (FungiblePayload));
+
+            (LibTransient.TUint256 storage p,) = getFungibleAmountAndKey(request.asset);
+            uint256 avail = p.get();
+            if (payload.amount > avail) {
+                revert InsufficientFunds(request.asset, avail, payload.amount);
+            }
+
+            p.dec(payload.amount);
+
+            _transferFungible(request.asset, request.target, payload.amount);
+        } else if (request.assetType == AssetType.ERC1155) {
+            ERC1155Payload memory payload = abi.decode(request.data, (ERC1155Payload));
+
+            (LibTransient.TUint256 storage p,) = getERC1155AmountAndKey(request.asset, payload.amount);
+            uint256 avail = p.get();
+            if (payload.amount > avail) {
+                revert InsufficientFunds(request.asset, avail, payload.amount);
+            }
+
+            p.dec(payload.amount);
+
+            _transferERC1155(request.asset, request.target, payload.tokenId, payload.amount, payload.data);
+        } else {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// @inheritdoc ABudget
+    /// @notice Disburses assets from the budget to multiple recipients
+    /// @param data_ The packed array of {Transfer} requests
+    /// @return True if all disbursements were successful
+    function disburseBatch(bytes[] calldata data_) external virtual override returns (bool) {
+        for (uint256 i = 0; i < data_.length; i++) {
+            if (!disburse(data_[i])) return false;
+        }
+
+        return true;
+    }
+
+    /// @inheritdoc ABudget
+    /// @notice Get the total amount of assets allocated to the budget, including any that have been distributed
+    /// @param asset_ The address of the asset
+    /// @return The total amount of assets
+    /// @dev This is simply the sum of the current balance and the distributed amount
+    function total(address asset_) external view virtual override returns (uint256) {
+        return _distributedFungible[asset_];
+    }
+
+    /// @notice Get the total amount of ERC1155 assets allocated to the budget, including any that have been distributed
+    /// @param asset_ The address of the asset
+    /// @param tokenId_ The ID of the token
+    /// @return The total amount of assets
+    function total(address asset_, uint256 tokenId_) external view virtual returns (uint256) {
+        return _distributedERC1155[asset_][tokenId_];
+    }
+
+    /// @inheritdoc ABudget
+    /// @notice Get the amount of assets available for distribution from the budget
+    /// @return The amount of assets available
+    /// @dev This is simply the current balance held by the budget
+    /// @dev If the zero address is passed, this function will return the native balance
+    function available(address) public view virtual override returns (uint256) {
+        return 0;
+    }
+
+    /// @notice Get the amount of ERC1155 assets available for distribution from the budget
+    /// @return The amount of assets available
+    function available(address, uint256) public view virtual returns (uint256) {
+        return 0;
+    }
+
+    /// @inheritdoc ABudget
+    /// @notice Get the amount of assets that have been distributed from the budget
+    /// @param asset_ The address of the asset
+    /// @return The amount of assets distributed
+    function distributed(address asset_) external view virtual override returns (uint256) {
+        return _distributedFungible[asset_];
+    }
+
+    /// @notice Get the amount of ERC1155 assets that have been distributed from the budget
+    /// @param asset_ The address of the asset
+    /// @param tokenId_ The ID of the token
+    /// @return The amount of assets distributed
+    function distributed(address asset_, uint256 tokenId_) external view virtual returns (uint256) {
+        return _distributedERC1155[asset_][tokenId_];
+    }
+
+    /// @inheritdoc ABudget
+    /// @dev This is a no-op as there is no local balance to reconcile
+    function reconcile(bytes calldata) external virtual override returns (uint256) {
+        return 0;
+    }
+
+    /// @notice Transfer assets to the recipient
+    /// @param asset_ The address of the asset
+    /// @param to_ The address of the recipient
+    /// @param amount_ The amount of the asset to transfer
+    /// @dev This function is used to transfer assets from the budget to a given recipient (typically an incentive contract)
+    /// @dev If the destination address is the zero address, or the transfer fails for any reason, this function will revert
+    function _transferFungible(address asset_, address to_, uint256 amount_) internal virtual nonReentrant {
+        // Increment the total amount of the asset distributed from the budget
+        if (to_ == address(0)) revert TransferFailed(asset_, to_, amount_);
+        if (amount_ > available(asset_)) {
+            revert InsufficientFunds(asset_, available(asset_), amount_);
+        }
+
+        _distributedFungible[asset_] += amount_;
+
+        // Transfer the asset to the recipient
+        if (asset_ == address(0)) {
+            SafeTransferLib.safeTransferETH(to_, amount_);
+        } else {
+            asset_.safeTransfer(to_, amount_);
+        }
+
+        emit Distributed(asset_, to_, amount_);
+    }
+
+    function _transferERC1155(address asset_, address to_, uint256 tokenId_, uint256 amount_, bytes memory data_)
+        internal
+        virtual
+        nonReentrant
+    {
+        // Increment the total amount of the asset distributed from the budget
+        if (to_ == address(0)) revert TransferFailed(asset_, to_, amount_);
+        if (amount_ > available(asset_, tokenId_)) {
+            revert InsufficientFunds(asset_, available(asset_, tokenId_), amount_);
+        }
+
+        _distributedERC1155[asset_][tokenId_] += amount_;
+
+        // Transfer the asset to the recipient
+        // wake-disable-next-line reentrancy (`nonReentrant` modifier is applied to the function)
+        IERC1155(asset_).safeTransferFrom(address(this), to_, tokenId_, amount_, data_);
+
+        emit Distributed(asset_, to_, amount_);
+    }
+
+    /// @inheritdoc IERC1155Receiver
+    /// @dev This contract does not care about the specifics of the inbound token, so we simply return the magic value (i.e. the selector for `onERC1155Received`)
+    function onERC1155Received(address, address, uint256, uint256, bytes calldata)
+        external
+        pure
+        override
+        returns (bytes4)
+    {
+        // We don't need to do anything here
+        return IERC1155Receiver.onERC1155Received.selector;
+    }
+
+    /// @inheritdoc IERC1155Receiver
+    /// @dev This contract does not care about the specifics of the inbound token, so we simply return the magic value (i.e. the selector for `onERC1155Received`)
+    function onERC1155BatchReceived(address, address, uint256[] calldata, uint256[] calldata, bytes calldata)
+        external
+        pure
+        override
+        returns (bytes4)
+    {
+        // We don't need to do anything here
+        return IERC1155Receiver.onERC1155BatchReceived.selector;
+    }
+}