@towns-protocol/contracts 0.0.302

package/src/airdrop/drop/IDropFacet.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {DropClaim} from "./DropClaim.sol";
+import {DropGroup} from "./DropGroup.sol";
+
+// libraries
+
+// contracts
+
+interface IDropFacetBase {
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event DropFacet_Claimed_WithPenalty(
+        uint256 indexed conditionId,
+        address indexed claimer,
+        address indexed account,
+        uint256 amount
+    );
+
+    event DropFacet_Claimed_And_Staked(
+        uint256 indexed conditionId,
+        address indexed claimer,
+        address indexed account,
+        uint256 amount
+    );
+
+    event DropFacet_ClaimConditionsUpdated(
+        uint256 indexed conditionId,
+        DropGroup.ClaimCondition[] conditions
+    );
+
+    event DropFacet_ClaimConditionAdded(
+        uint256 indexed conditionId,
+        DropGroup.ClaimCondition condition
+    );
+
+    // =============================================================
+    //                           Errors
+    // =============================================================
+    error DropFacet__NoActiveClaimCondition();
+    error DropFacet__MerkleRootNotSet();
+    error DropFacet__QuantityMustBeGreaterThanZero();
+    error DropFacet__ExceedsMaxClaimableSupply();
+    error DropFacet__ClaimHasNotStarted();
+    error DropFacet__AlreadyClaimed();
+    error DropFacet__InvalidProof();
+    error DropFacet__ClaimConditionsNotInAscendingOrder();
+    error DropFacet__CannotSetClaimConditions();
+    error DropFacet__ClaimHasEnded();
+    error DropFacet__UnexpectedPenaltyBps();
+    error DropFacet__CurrencyNotSet();
+    error DropFacet__RewardsDistributionNotSet();
+    error DropFacet__InsufficientBalance();
+    error DropFacet__NotClaimingAccount();
+    error DropFacet__InvalidRecipient();
+}
+
+interface IDropFacet is IDropFacetBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ADMIN FUNCTIONS                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Adds a new claim condition
+    /// @param condition The ClaimCondition struct defining the condition
+    function addClaimCondition(DropGroup.ClaimCondition calldata condition) external;
+
+    /// @notice Sets the claim conditions for the drop
+    /// @param conditions An array of ClaimCondition structs defining the conditions
+    function setClaimConditions(DropGroup.ClaimCondition[] calldata conditions) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          CLAIMING                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Claims tokens with a penalty
+    /// @param req The claim request
+    /// @param expectedPenaltyBps The expected penalty in basis points
+    /// @return The amount of tokens claimed
+    function claimWithPenalty(
+        DropClaim.Claim calldata req,
+        uint16 expectedPenaltyBps
+    ) external returns (uint256);
+
+    /// @notice Claims tokens and stakes them in the staking contract
+    /// @param req The claim request
+    /// @param delegatee The address of the delegatee
+    /// @param deadline The deadline for the transaction
+    /// @param signature The signature of the delegatee
+    /// @return The amount of tokens claimed
+    function claimAndStake(
+        DropClaim.Claim calldata req,
+        address delegatee,
+        uint256 deadline,
+        bytes calldata signature
+    ) external returns (uint256);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Gets the ID of the currently active claim condition
+    /// @return The ID of the active claim condition
+    function getActiveClaimConditionId() external view returns (uint256);
+
+    /// @notice Gets all claim conditions
+    /// @return An array of ClaimCondition structs
+    function getClaimConditions() external view returns (DropGroup.ClaimCondition[] memory);
+
+    /// @notice Retrieves a specific claim condition by its ID
+    /// @param conditionId The ID of the claim condition to retrieve
+    /// @return The ClaimCondition struct for the specified ID
+    function getClaimConditionById(
+        uint256 conditionId
+    ) external view returns (DropGroup.ClaimCondition memory);
+
+    /// @notice Gets the amount of tokens claimed by a specific wallet for a given condition
+    /// @param account The address of the wallet to check
+    /// @param conditionId The ID of the claim condition
+    /// @return The number of tokens claimed by the wallet for the specified condition
+    function getSupplyClaimedByWallet(
+        address account,
+        uint256 conditionId
+    ) external view returns (uint256);
+
+    /// @notice Gets the deposit ID of a specific wallet for a given condition
+    /// @param account The address of the wallet to check
+    /// @param conditionId The ID of the claim condition
+    /// @return The deposit ID of the wallet for the specified condition
+    function getDepositIdByWallet(
+        address account,
+        uint256 conditionId
+    ) external view returns (uint256);
+}

package/src/airdrop/points/CheckIn.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library CheckIn {
+    // keccak256(abi.encode(uint256(keccak256("river.tokens.checkin.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x62755009e737dbac2f30b2876987ec999edfaa30486a87d0930a58dbf1ec6800;
+
+    uint256 internal constant MAX_STREAK_PER_CHECKIN = 30; // Maximum streak per check-in
+    uint256 internal constant MAX_POINTS_PER_CHECKIN = 30 ether; // Maximum points per check-in
+    uint256 internal constant CHECK_IN_FORGIVENESS_PERIOD = 2 days; // Time window to continue
+    // streak
+    uint256 internal constant CHECK_IN_WAIT_PERIOD = 1 days; // Time between check-ins
+
+    struct CheckInData {
+        uint256 streak;
+        uint256 lastCheckIn;
+    }
+
+    struct Layout {
+        mapping(address => CheckInData) checkInsByAddress;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+
+    function getPointsAndStreak(
+        uint256 lastCheckIn,
+        uint256 currentStreak,
+        uint256 currentTime
+    ) internal pure returns (uint256 pointsToAward, uint256 streak) {
+        // First time checking in
+        if (lastCheckIn == 0) {
+            return (1 ether, 1); // equivalent to 1 point
+        }
+
+        // Must wait at least 24 hours between check-ins
+        if (currentTime <= lastCheckIn + CHECK_IN_WAIT_PERIOD) {
+            return (0, 0);
+        }
+
+        // Update streak based on timing
+        bool isWithinForgiveness = currentTime <= lastCheckIn + CHECK_IN_FORGIVENESS_PERIOD;
+        uint256 newStreak = isWithinForgiveness ? currentStreak + 1 : 1;
+
+        // Calculate points based on new streak
+        pointsToAward = newStreak > MAX_STREAK_PER_CHECKIN
+            ? MAX_POINTS_PER_CHECKIN
+            : newStreak * 1 ether;
+
+        return (pointsToAward, newStreak);
+    }
+
+    function getCurrentStreak(address user) internal view returns (uint256) {
+        return layout().checkInsByAddress[user].streak;
+    }
+
+    function getLastCheckIn(address user) internal view returns (uint256) {
+        return layout().checkInsByAddress[user].lastCheckIn;
+    }
+}

package/src/airdrop/points/ITownsPoints.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface ITownsPointsBase {
+    enum Action {
+        JoinSpace,
+        CheckIn,
+        Tip,
+        Swap
+    }
+
+    /// @notice Emitted when a user successfully checks in and receives points
+    /// @param user The address of the user who checked in
+    /// @param points The number of points awarded for this check-in
+    /// @param streak The user's current check-in streak after this check-in
+    /// @param lastCheckIn The timestamp when this check-in occurred
+    event CheckedIn(address indexed user, uint256 points, uint256 streak, uint256 lastCheckIn);
+
+    /// @notice Error thrown when the space is invalid
+    error TownsPoints__InvalidSpace();
+
+    /// @notice Error thrown when the call data is invalid
+    error TownsPoints__InvalidCallData();
+
+    /// @notice Error thrown when the array length is invalid
+    error TownsPoints__InvalidArrayLength();
+
+    /// @notice Error thrown when a user attempts to check in too soon after their last check-in
+    error TownsPoints__CheckInPeriodNotPassed();
+}
+
+interface ITownsPoints is ITownsPointsBase {
+    /// @notice Batch mint points to multiple users
+    /// @dev Only callable by the owner
+    /// @param data The abi-encoded array of addresses and values to mint
+    function batchMintPoints(bytes calldata data) external;
+
+    /// @notice Mint points to a user
+    /// @dev Only spaces can mint points
+    /// @param to The address to mint the points to
+    /// @param value The amount of points to mint
+    function mint(address to, uint256 value) external;
+
+    /// @notice Get the points from an eligible action
+    /// @param action The action to get the points from
+    /// @param data The data of the action
+    function getPoints(Action action, bytes calldata data) external view returns (uint256);
+
+    /// @notice Allows a user to check in and earn points based on their streak
+    /// @dev Users must wait at least 24 hours between check-ins
+    /// @dev If a user checks in within 48 hours of their last check-in, their streak continues
+    /// @dev Otherwise, their streak resets to 1
+    function checkIn() external;
+
+    /// @notice Gets the current check-in streak for a user
+    /// @param user The address of the user to query
+    /// @return The current streak count for the user
+    function getCurrentStreak(address user) external view returns (uint256);
+
+    /// @notice Gets the timestamp of the user's last check-in
+    /// @param user The address of the user to query
+    /// @return The timestamp of the user's last check-in, 0 if never checked in
+    function getLastCheckIn(address user) external view returns (uint256);
+}

package/src/airdrop/points/TownsPoints.sol

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {ITownsPoints} from "./ITownsPoints.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IArchitect} from "src/factory/facets/architect/IArchitect.sol";
+
+// libraries
+
+import {CheckIn} from "./CheckIn.sol";
+import {TownsPointsStorage} from "./TownsPointsStorage.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+
+contract TownsPoints is IERC20Metadata, ITownsPoints, OwnableBase, Facet {
+    function __TownsPoints_init(address spaceFactory) external onlyInitializing {
+        TownsPointsStorage.Layout storage ds = TownsPointsStorage.layout();
+        ds.spaceFactory = spaceFactory;
+        _addInterface(type(IERC20).interfaceId);
+        _addInterface(type(IERC20Metadata).interfaceId);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           POINTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    modifier onlySpace() {
+        address spaceFactory = TownsPointsStorage.layout().spaceFactory;
+        if (IArchitect(spaceFactory).getTokenIdBySpace(msg.sender) == 0) {
+            CustomRevert.revertWith(TownsPoints__InvalidSpace.selector);
+        }
+        _;
+    }
+
+    /// @inheritdoc ITownsPoints
+    function batchMintPoints(bytes calldata data) external onlyOwner {
+        address[] calldata accounts;
+        uint256[] calldata values;
+        uint256 relativeOffset;
+        assembly {
+            // call data layout:
+            // address                  | value
+            // data.offset              | 0x40 (accounts relative offset)
+            // + 0x20                   | values relative offset
+            // + 0x40                   | accounts.length
+            // + 0x60 (accounts.offset) | accounts[0]
+            let accountsLengthPtr := add(data.offset, calldataload(data.offset))
+            accounts.length := calldataload(accountsLengthPtr)
+            accounts.offset := add(accountsLengthPtr, 0x20)
+            let valuesLengthPtr := add(data.offset, calldataload(add(data.offset, 0x20)))
+            values.length := calldataload(valuesLengthPtr)
+            values.offset := add(valuesLengthPtr, 0x20)
+            relativeOffset := sub(values.offset, data.offset)
+        }
+        if (data.length < relativeOffset + (values.length << 5)) {
+            CustomRevert.revertWith(TownsPoints__InvalidCallData.selector);
+        }
+
+        if (accounts.length != values.length) {
+            CustomRevert.revertWith(TownsPoints__InvalidArrayLength.selector);
+        }
+
+        TownsPointsStorage.Layout storage self = TownsPointsStorage.layout();
+        for (uint256 i; i < accounts.length; ++i) {
+            self.inner.mint(accounts[i], values[i]);
+            emit Transfer(address(0), accounts[i], values[i]);
+        }
+    }
+
+    /// @inheritdoc ITownsPoints
+    function getPoints(Action action, bytes calldata data) external pure returns (uint256 points) {
+        if (action == Action.JoinSpace) {
+            uint256 membershipPrice = abi.decode(data, (uint256));
+            points = membershipPrice * 200_000;
+        }
+
+        if (action == Action.CheckIn) {
+            (uint256 lastCheckIn, uint256 streak, uint256 currentTime) = abi.decode(
+                data,
+                (uint256, uint256, uint256)
+            );
+            (points, ) = CheckIn.getPointsAndStreak(lastCheckIn, streak, currentTime);
+        }
+
+        if (action == Action.Tip || action == Action.Swap) {
+            uint256 protocolFee = abi.decode(data, (uint256));
+            points = (protocolFee * 2_000_000) / 3;
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           CHECKIN                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc ITownsPoints
+    function checkIn() external {
+        CheckIn.CheckInData storage userCheckIn = CheckIn.layout().checkInsByAddress[msg.sender];
+
+        (uint256 pointsToAward, uint256 newStreak) = CheckIn.getPointsAndStreak(
+            userCheckIn.lastCheckIn,
+            userCheckIn.streak,
+            block.timestamp
+        );
+
+        // Must wait at least 24 hours between check-ins
+        if (pointsToAward == 0 && newStreak == 0) {
+            CustomRevert.revertWith(TownsPoints__CheckInPeriodNotPassed.selector);
+        }
+
+        (userCheckIn.streak, userCheckIn.lastCheckIn) = (newStreak, block.timestamp);
+        TownsPointsStorage.layout().inner.mint(msg.sender, pointsToAward);
+        emit Transfer(address(0), msg.sender, pointsToAward);
+        emit CheckedIn(msg.sender, pointsToAward, newStreak, block.timestamp);
+    }
+
+    /// @inheritdoc ITownsPoints
+    function getCurrentStreak(address user) external view returns (uint256) {
+        return CheckIn.getCurrentStreak(user);
+    }
+
+    /// @inheritdoc ITownsPoints
+    function getLastCheckIn(address user) external view returns (uint256) {
+        return CheckIn.getLastCheckIn(user);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERC20                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IERC20
+    function approve(address spender, uint256 value) external returns (bool) {
+        TownsPointsStorage.layout().inner.approve(spender, value);
+        emit Approval(msg.sender, spender, value);
+        return true;
+    }
+
+    /// @inheritdoc ITownsPoints
+    function mint(address to, uint256 value) external onlySpace {
+        TownsPointsStorage.layout().inner.mint(to, value);
+        emit Transfer(address(0), to, value);
+    }
+
+    /// @inheritdoc IERC20
+    function transfer(address to, uint256 value) external returns (bool) {
+        TownsPointsStorage.layout().inner.transfer(to, value);
+        emit Transfer(msg.sender, to, value);
+        return true;
+    }
+
+    /// @inheritdoc IERC20
+    function transferFrom(address from, address to, uint256 value) external returns (bool) {
+        TownsPointsStorage.layout().inner.transferFrom(from, to, value);
+        emit Transfer(from, to, value);
+        return true;
+    }
+
+    /// @inheritdoc IERC20
+    function allowance(address owner, address spender) external view returns (uint256) {
+        return TownsPointsStorage.layout().inner.allowance(owner, spender);
+    }
+
+    /// @inheritdoc IERC20
+    function balanceOf(address account) external view returns (uint256) {
+        return TownsPointsStorage.layout().inner.balanceOf(account);
+    }
+
+    /// @inheritdoc IERC20
+    function totalSupply() external view returns (uint256) {
+        return TownsPointsStorage.layout().inner.totalSupply;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ERC20 METADATA                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IERC20Metadata
+    function name() external pure returns (string memory) {
+        return "Towns Points";
+    }
+
+    /// @inheritdoc IERC20Metadata
+    function symbol() external pure returns (string memory) {
+        return "TWP";
+    }
+
+    /// @inheritdoc IERC20Metadata
+    function decimals() public pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/src/airdrop/points/TownsPointsStorage.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {MinimalERC20Storage} from "@towns-protocol/diamond/src/primitive/ERC20.sol";
+
+library TownsPointsStorage {
+    // keccak256(abi.encode(uint256(keccak256("tokens.points.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x25a22d57af6f735dc617e9781981413da3bc5a71376b4237270a04c144aaf700;
+
+    struct Layout {
+        MinimalERC20Storage inner;
+        address spaceFactory;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/apps/BaseApp.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC6900ExecutionModule} from "@erc6900/reference-implementation/interfaces/IERC6900ExecutionModule.sol";
+import {IERC6900Module} from "@erc6900/reference-implementation/interfaces/IERC6900Module.sol";
+import {ITownsApp} from "./ITownsApp.sol";
+
+/// @title BaseApp
+/// @notice Base contract for Towns apps implementing core ERC-6900 module functionality
+/// @dev Provides base implementation for module installation/uninstallation and interface support
+/// @dev Inheriting contracts should override _onInstall and _onUninstall as needed
+/// @dev Implements IERC6900Module, IERC6900ExecutionModule, and ITownsApp interfaces
+
+abstract contract BaseApp is ITownsApp {
+    receive() external payable {
+        _onPayment(msg.sender, msg.value);
+    }
+
+    // External functions
+    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
+        return
+            interfaceId == type(IERC6900ExecutionModule).interfaceId ||
+            interfaceId == type(IERC6900Module).interfaceId ||
+            interfaceId == type(ITownsApp).interfaceId;
+    }
+
+    /// @notice Required by IERC6900Module - called when module is installed
+    function onInstall(bytes calldata postInstallData) external {
+        _onInstall(postInstallData);
+    }
+
+    /// @notice Required by IERC6900Module - called when module is uninstalled
+    function onUninstall(bytes calldata postUninstallData) external {
+        _onUninstall(postUninstallData);
+    }
+
+    function moduleOwner() external view returns (address) {
+        return _moduleOwner();
+    }
+
+    function installPrice() external view returns (uint256) {
+        return _installPrice();
+    }
+
+    function accessDuration() external view returns (uint48) {
+        return _accessDuration();
+    }
+
+    // Internal functions
+    function _onInstall(bytes calldata postInstallData) internal virtual {}
+
+    function _onUninstall(bytes calldata postUninstallData) internal virtual {}
+
+    function _moduleOwner() internal view virtual returns (address) {}
+
+    function _installPrice() internal view virtual returns (uint256) {}
+
+    function _accessDuration() internal view virtual returns (uint48) {}
+
+    function _onPayment(address payer, uint256 amount) internal virtual {}
+}

package/src/apps/ITownsApp.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC6900ExecutionModule} from "@erc6900/reference-implementation/interfaces/IERC6900ExecutionModule.sol";
+import {IERC6900Module} from "@erc6900/reference-implementation/interfaces/IERC6900Module.sol";
+
+/// @title ITownsApp Interface
+/// @notice Base interface for Towns apps implementing core module functionality
+/// @dev Combines IERC6900Module (module lifecycle), and IERC6900ExecutionModule (execution)
+/// @dev Apps must implement required permissions and support these interfaces
+interface ITownsApp is IERC6900Module, IERC6900ExecutionModule {
+    /// @notice Returns the required permissions for the app
+    /// @return permissions The required permissions for the app
+    function requiredPermissions() external view returns (bytes32[] memory);
+
+    /// @notice Returns the owner of the app
+    /// @return owner The owner of the app
+    function moduleOwner() external view returns (address);
+
+    /// @notice Returns the install price of the app
+    /// @return installPrice The install price of the app
+    function installPrice() external view returns (uint256);
+
+    /// @notice Returns the access duration of the app
+    /// @return accessDuration The access duration of the app
+    function accessDuration() external view returns (uint48);
+}