@towns-protocol/contracts 0.0.374 → 0.0.375

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.374",
+  "version": "0.0.375",
   "packageManager": "yarn@3.8.0",
   "scripts": {
     "build-types": "bash scripts/build-contract-types.sh",
@@ -35,7 +35,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.374",
+    "@towns-protocol/prettier-config": "^0.0.375",
     "@typechain/ethers-v5": "^11.1.2",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
@@ -57,5 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b6f28ce51336d969161de5c5aa0aa012f03a182a"
+  "gitHead": "f64537fbf8d7eca815c5c5e52f601a387e713a0a"
 }

package/scripts/deployments/facets/DeployTipping.s.sol

@@ -7,15 +7,26 @@ import {ITipping} from "src/spaces/facets/tipping/ITipping.sol";
 
 // libraries
 import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
 
 library DeployTipping {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
     function selectors() internal pure returns (bytes4[] memory res) {
-        res = new bytes4[](5);
-        res[0] = ITipping.tip.selector;
-        res[1] = ITipping.tipsByCurrencyAndTokenId.selector;
-        res[2] = ITipping.tippingCurrencies.selector;
-        res[3] = ITipping.totalTipsByCurrency.selector;
-        res[4] = ITipping.tipAmountByCurrency.selector;
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(8);
+        arr.p(ITipping.sendTip.selector);
+        arr.p(ITipping.tip.selector);
+        arr.p(ITipping.tipsByWalletAndCurrency.selector);
+        arr.p(ITipping.tipCountByWalletAndCurrency.selector);
+        arr.p(ITipping.tipsByCurrencyAndTokenId.selector);
+        arr.p(ITipping.tippingCurrencies.selector);
+        arr.p(ITipping.totalTipsByCurrency.selector);
+        arr.p(ITipping.tipAmountByCurrency.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
     }
 
     function makeCut(

package/src/spaces/facets/tipping/ITipping.sol

@@ -2,10 +2,45 @@
 pragma solidity ^0.8.23;
 
 interface ITippingBase {
+    // =============================================================
+    //                           Enums
+    // =============================================================
+
+    enum TipRecipientType {
+        Member, // Tips to token holders
+        Bot, // Tips to bot wallets
+        Pool // Tips to pool wallets
+    }
+
     // =============================================================
     //                           Structs
     // =============================================================
 
+    struct TipMetadata {
+        bytes32 messageId;
+        bytes32 channelId;
+        bytes data; // Extensible metadata
+    }
+
+    /// @notice Params for Member tips (includes tokenId)
+    struct MembershipTipParams {
+        address receiver;
+        uint256 tokenId;
+        address currency;
+        uint256 amount;
+        TipMetadata metadata;
+    }
+
+    /// @notice Params for Bot tips (similar to Wallet but distinct type)
+    struct BotTipParams {
+        address receiver;
+        address currency;
+        bytes32 appId;
+        uint256 amount;
+        TipMetadata metadata;
+    }
+
+    /// @notice Legacy tip request (maintain backwards compatibility)
     struct TipRequest {
         address receiver;
         uint256 tokenId;
@@ -19,6 +54,16 @@ interface ITippingBase {
     //                           Events
     // =============================================================
 
+    event TipSent(
+        address indexed sender,
+        address indexed receiver,
+        TipRecipientType indexed recipientType,
+        address currency,
+        uint256 amount,
+        uint256 tokenId // 0 if not a member tip
+    );
+
+    // Maintain legacy event for backwards compatibility
     event Tip(
         uint256 indexed tokenId,
         address indexed currency,
@@ -33,6 +78,8 @@ interface ITippingBase {
     //                           Errors
     // =============================================================
 
+    error InvalidRecipientType();
+    error InvalidTipData();
     error TokenDoesNotExist();
     error ReceiverIsNotMember();
     error CannotTipSelf();
@@ -43,7 +90,16 @@ interface ITippingBase {
 }
 
 interface ITipping is ITippingBase {
-    /// @notice Sends a tip to a space member
+    /// @notice Send a tip using flexible encoding based on recipient type
+    /// @param recipientType The type of recipient (Member, Wallet, Bot, Pool)
+    /// @param data ABI-encoded tip params based on recipientType:
+    ///   - Member: abi.encode(MembershipTipParams)
+    ///   - Wallet: abi.encode(WalletTipParams)
+    ///   - Bot: abi.encode(BotTipParams)
+    ///   - Pool: Reserved for future implementation
+    function sendTip(TipRecipientType recipientType, bytes calldata data) external payable;
+
+    /// @notice Sends a tip to a space member (legacy)
     /// @param tipRequest The tip request containing token ID, currency, amount, message ID and
     /// channel ID
     /// @dev Requires sender and receiver to be members of the space
@@ -51,6 +107,24 @@ interface ITipping is ITippingBase {
     /// @dev Emits Tip event
     function tip(TipRequest calldata tipRequest) external payable;
 
+    /// @notice Get tips received by wallet address and currency
+    /// @param wallet The wallet address to get tips for
+    /// @param currency The currency address to get tips in
+    /// @return The total amount of tips received in the specified currency
+    function tipsByWalletAndCurrency(
+        address wallet,
+        address currency
+    ) external view returns (uint256);
+
+    /// @notice Get tip count by wallet and currency
+    /// @param wallet The wallet address to get tip count for
+    /// @param currency The currency address to get tip count in
+    /// @return The total number of tips received in the specified currency
+    function tipCountByWalletAndCurrency(
+        address wallet,
+        address currency
+    ) external view returns (uint256);
+
     /// @notice Gets the total tips received for a token ID in a specific currency
     /// @param tokenId The token ID to get tips for
     /// @param currency The currency address to get tips in

package/src/spaces/facets/tipping/TippingBase.sol

@@ -2,73 +2,269 @@
 pragma solidity ^0.8.23;
 
 // interfaces
+import {ITippingBase} from "./ITipping.sol";
+import {ITownsPointsBase} from "../../../airdrop/points/ITownsPoints.sol";
+import {IPlatformRequirements} from "../../../factory/facets/platform/requirements/IPlatformRequirements.sol";
 
 // libraries
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {BasisPoints} from "../../../utils/libraries/BasisPoints.sol";
 import {CurrencyTransfer} from "../../../utils/libraries/CurrencyTransfer.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {MembershipStorage} from "../membership/MembershipStorage.sol";
+import {TippingStorage} from "./TippingStorage.sol";
 
 // contracts
+import {PointsBase} from "../points/PointsBase.sol";
 
-library TippingBase {
+abstract contract TippingBase is ITippingBase, PointsBase {
     using EnumerableSet for EnumerableSet.AddressSet;
+    using CustomRevert for bytes4;
 
-    // keccak256(abi.encode(uint256(keccak256("spaces.facets.tipping.storage")) - 1)) &
-    // ~bytes32(uint256(0xff))
-    bytes32 internal constant STORAGE_SLOT =
-        0xb6cb334a9eea0cca2581db4520b45ac6f03de8e3927292302206bb82168be300;
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      Internal Functions                    */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    struct TippingStats {
-        uint256 totalTips;
-        uint256 tipAmount;
+    /// @dev Processes sendTip based on recipient type
+    function _sendTip(TipRecipientType recipientType, bytes calldata data) internal {
+        if (recipientType == TipRecipientType.Member) {
+            _sendMemberTip(data);
+        } else if (recipientType == TipRecipientType.Bot) {
+            _sendBotTip(data);
+        } else {
+            InvalidRecipientType.selector.revertWith();
+        }
+    }
+
+    /// @dev Processes legacy tip function
+    function _tip(TipRequest calldata tipRequest) internal {
+        _validateTipRequest(
+            msg.sender,
+            tipRequest.receiver,
+            tipRequest.currency,
+            tipRequest.amount
+        );
+
+        uint256 tipAmount = tipRequest.amount;
+
+        // Handle native token
+        if (tipRequest.currency == CurrencyTransfer.NATIVE_TOKEN) {
+            if (msg.value != tipAmount) MsgValueMismatch.selector.revertWith();
+            uint256 protocolFee = _handleProtocolFee(tipAmount);
+            tipAmount -= protocolFee;
+        } else {
+            if (msg.value != 0) UnexpectedETH.selector.revertWith();
+        }
+
+        // Process tip
+        _processTip(
+            msg.sender,
+            tipRequest.receiver,
+            tipRequest.tokenId,
+            TipRecipientType.Member,
+            tipRequest.currency,
+            tipAmount
+        );
+
+        // Emit legacy event (with original amount for backwards compatibility)
+        emit Tip(
+            tipRequest.tokenId,
+            tipRequest.currency,
+            msg.sender,
+            tipRequest.receiver,
+            tipRequest.amount,
+            tipRequest.messageId,
+            tipRequest.channelId
+        );
+
+        // Emit new event (with actual tip amount after fees)
+        emit TipSent(
+            msg.sender,
+            tipRequest.receiver,
+            TipRecipientType.Member,
+            tipRequest.currency,
+            tipAmount,
+            tipRequest.tokenId
+        );
     }
 
-    struct Layout {
-        EnumerableSet.AddressSet currencies;
-        mapping(uint256 tokenId => mapping(address currency => uint256 amount)) tipsByCurrencyByTokenId;
-        mapping(address currency => TippingStats) tippingStatsByCurrency;
+    /// @dev Handles member tips
+    function _sendMemberTip(bytes calldata data) internal {
+        MembershipTipParams memory params = abi.decode(data, (MembershipTipParams));
+        _validateTipRequest(msg.sender, params.receiver, params.currency, params.amount);
+
+        uint256 tipAmount = params.amount;
+
+        // Handle native token
+        if (params.currency == CurrencyTransfer.NATIVE_TOKEN) {
+            if (msg.value != tipAmount) MsgValueMismatch.selector.revertWith();
+            uint256 protocolFee = _handleProtocolFee(tipAmount);
+            tipAmount -= protocolFee;
+        } else {
+            if (msg.value != 0) UnexpectedETH.selector.revertWith();
+        }
+
+        // Process tip
+        _processTip(
+            msg.sender,
+            params.receiver,
+            params.tokenId,
+            TipRecipientType.Member,
+            params.currency,
+            tipAmount
+        );
+
+        // Emit events
+        emit TipSent(
+            msg.sender,
+            params.receiver,
+            TipRecipientType.Member,
+            params.currency,
+            tipAmount,
+            params.tokenId
+        );
+
+        emit Tip(
+            params.tokenId,
+            params.currency,
+            msg.sender,
+            params.receiver,
+            tipAmount,
+            params.metadata.messageId,
+            params.metadata.channelId
+        );
     }
 
-    function layout() internal pure returns (Layout storage l) {
-        assembly {
-            l.slot := STORAGE_SLOT
+    /// @dev Handles bot tips
+    function _sendBotTip(bytes calldata data) internal {
+        BotTipParams memory params = abi.decode(data, (BotTipParams));
+        _validateTipRequest(msg.sender, params.receiver, params.currency, params.amount);
+
+        uint256 tipAmount = params.amount;
+
+        // Handle native token (no protocol fee for bot tips)
+        if (params.currency == CurrencyTransfer.NATIVE_TOKEN) {
+            if (msg.value != tipAmount) MsgValueMismatch.selector.revertWith();
+        } else {
+            if (msg.value != 0) UnexpectedETH.selector.revertWith();
         }
+
+        // Process tip (tokenId = 0 for bot tips)
+        _processTip(
+            msg.sender,
+            params.receiver,
+            0, // No tokenId for bot tips
+            TipRecipientType.Bot,
+            params.currency,
+            tipAmount
+        );
+
+        emit TipSent(
+            msg.sender,
+            params.receiver,
+            TipRecipientType.Bot,
+            params.currency,
+            tipAmount,
+            0
+        );
     }
 
-    function tip(
+    /// @dev Core tip processing logic
+    function _processTip(
         address sender,
         address receiver,
         uint256 tokenId,
+        TipRecipientType recipientType,
         address currency,
         uint256 amount
     ) internal {
-        Layout storage ds = layout();
+        TippingStorage.Layout storage $ = TippingStorage.layout();
 
-        ds.currencies.add(currency);
-        ds.tipsByCurrencyByTokenId[tokenId][currency] += amount;
+        // Add currency to set
+        $.currencies.add(currency);
 
-        TippingStats storage stats = ds.tippingStatsByCurrency[currency];
+        // Update stats by currency
+        TippingStorage.TippingStats storage stats = $.tippingStatsByCurrency[currency];
         stats.tipAmount += amount;
         stats.totalTips += 1;
 
+        // Update wallet-based tracking (all tips)
+        $.tippingStatsByCurrencyByWallet[receiver][currency].tipAmount += amount;
+        $.tippingStatsByCurrencyByWallet[receiver][currency].totalTips += 1;
+
+        // Update tokenId-based tracking (backwards compatibility, only for Member tips)
+        if (recipientType == TipRecipientType.Member) {
+            $.tipsByCurrencyByTokenId[tokenId][currency] += amount;
+        }
+
+        // Transfer currency
         CurrencyTransfer.transferCurrency(currency, sender, receiver, amount);
     }
 
-    function totalTipsByCurrency(address currency) internal view returns (uint256) {
-        return layout().tippingStatsByCurrency[currency].totalTips;
+    /// @dev Handles protocol fee and points minting
+    function _handleProtocolFee(uint256 amount) internal returns (uint256 protocolFee) {
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+        IPlatformRequirements platform = IPlatformRequirements(ds.spaceFactory);
+
+        protocolFee = BasisPoints.calculate(amount, 50); // 0.5%
+
+        CurrencyTransfer.transferCurrency(
+            CurrencyTransfer.NATIVE_TOKEN,
+            msg.sender,
+            platform.getFeeRecipient(),
+            protocolFee
+        );
+
+        // Mint points
+        address airdropDiamond = _getAirdropDiamond();
+        uint256 points = _getPoints(
+            airdropDiamond,
+            ITownsPointsBase.Action.Tip,
+            abi.encode(protocolFee)
+        );
+        _mintPoints(airdropDiamond, msg.sender, points);
     }
 
-    function tipAmountByCurrency(address currency) internal view returns (uint256) {
-        return layout().tippingStatsByCurrency[currency].tipAmount;
+    /// @dev Validates common tip requirements
+    function _validateTipRequest(
+        address sender,
+        address receiver,
+        address currency,
+        uint256 amount
+    ) internal pure {
+        if (currency == address(0)) CurrencyIsZero.selector.revertWith();
+        if (sender == receiver) CannotTipSelf.selector.revertWith();
+        if (amount == 0) AmountIsZero.selector.revertWith();
     }
 
-    function tipsByCurrencyByTokenId(
-        uint256 tokenId,
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      Internal View Functions               */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _getTipsByWallet(address wallet, address currency) internal view returns (uint256) {
+        return TippingStorage.layout().tippingStatsByCurrencyByWallet[wallet][currency].tipAmount;
+    }
+
+    function _getTipCountByWallet(
+        address wallet,
         address currency
     ) internal view returns (uint256) {
-        return layout().tipsByCurrencyByTokenId[tokenId][currency];
+        return TippingStorage.layout().tippingStatsByCurrencyByWallet[wallet][currency].totalTips;
+    }
+
+    function _getTipsByTokenId(uint256 tokenId, address currency) internal view returns (uint256) {
+        return TippingStorage.layout().tipsByCurrencyByTokenId[tokenId][currency];
+    }
+
+    function _getTippingCurrencies() internal view returns (address[] memory) {
+        return TippingStorage.layout().currencies.values();
+    }
+
+    function _getTotalTipsByCurrency(address currency) internal view returns (uint256) {
+        return TippingStorage.layout().tippingStatsByCurrency[currency].totalTips;
     }
 
-    function tippingCurrencies() internal view returns (address[] memory) {
-        return layout().currencies.values();
+    function _getTipAmountByCurrency(address currency) internal view returns (uint256) {
+        return TippingStorage.layout().tippingStatsByCurrency[currency].tipAmount;
     }
 }

package/src/spaces/facets/tipping/TippingFacet.sol

@@ -2,80 +2,48 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {ITownsPointsBase} from "../../../airdrop/points/ITownsPoints.sol";
-import {IPlatformRequirements} from "../../../factory/facets/platform/requirements/IPlatformRequirements.sol";
 import {ITipping} from "./ITipping.sol";
 
 // libraries
-import {BasisPoints} from "../../../utils/libraries/BasisPoints.sol";
-import {CurrencyTransfer} from "../../../utils/libraries/CurrencyTransfer.sol";
-import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
-import {MembershipStorage} from "../membership/MembershipStorage.sol";
-import {TippingBase} from "./TippingBase.sol";
 
 // contracts
 import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
 import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
 import {ERC721ABase} from "../../../diamond/facets/token/ERC721A/ERC721ABase.sol";
-import {PointsBase} from "../points/PointsBase.sol";
-
-contract TippingFacet is ITipping, ERC721ABase, PointsBase, Facet, ReentrancyGuard {
-    using CustomRevert for bytes4;
+import {TippingBase} from "./TippingBase.sol";
 
+contract TippingFacet is ITipping, TippingBase, ERC721ABase, Facet, ReentrancyGuard {
     function __Tipping_init() external onlyInitializing {
         _addInterface(type(ITipping).interfaceId);
     }
 
     /// @inheritdoc ITipping
-    function tip(TipRequest calldata tipRequest) external payable nonReentrant {
-        _validateTipRequest(
-            msg.sender,
-            tipRequest.receiver,
-            tipRequest.currency,
-            tipRequest.amount
-        );
-
-        uint256 tipAmount = tipRequest.amount;
-
-        if (tipRequest.currency != CurrencyTransfer.NATIVE_TOKEN) {
-            if (msg.value != 0) UnexpectedETH.selector.revertWith();
-        } else {
-            if (msg.value != tipAmount) MsgValueMismatch.selector.revertWith();
-
-            uint256 protocolFee = _payProtocol(msg.sender, tipAmount);
-            tipAmount -= protocolFee;
-
-            address airdropDiamond = _getAirdropDiamond();
-            uint256 points = _getPoints(
-                airdropDiamond,
-                ITownsPointsBase.Action.Tip,
-                abi.encode(protocolFee)
-            );
-            _mintPoints(airdropDiamond, msg.sender, points);
-        }
+    function sendTip(
+        TipRecipientType recipientType,
+        bytes calldata data
+    ) external payable nonReentrant {
+        _sendTip(recipientType, data);
+    }
 
-        TippingBase.tip(
-            msg.sender,
-            tipRequest.receiver,
-            tipRequest.tokenId,
-            tipRequest.currency,
-            tipAmount
-        );
+    /// @inheritdoc ITipping
+    function tip(TipRequest calldata tipRequest) external payable nonReentrant {
+        _tip(tipRequest);
+    }
 
-        emit Tip(
-            tipRequest.tokenId,
-            tipRequest.currency,
-            msg.sender,
-            tipRequest.receiver,
-            tipRequest.amount,
-            tipRequest.messageId,
-            tipRequest.channelId
-        );
+    /// @inheritdoc ITipping
+    function tipsByWalletAndCurrency(
+        address wallet,
+        address currency
+    ) external view returns (uint256) {
+        return _getTipsByWallet(wallet, currency);
     }
 
     /// @inheritdoc ITipping
-    function tippingCurrencies() external view returns (address[] memory) {
-        return TippingBase.tippingCurrencies();
+    function tipCountByWalletAndCurrency(
+        address wallet,
+        address currency
+    ) external view returns (uint256) {
+        return _getTipCountByWallet(wallet, currency);
     }
 
     /// @inheritdoc ITipping
@@ -83,45 +51,21 @@ contract TippingFacet is ITipping, ERC721ABase, PointsBase, Facet, ReentrancyGua
         uint256 tokenId,
         address currency
     ) external view returns (uint256) {
-        return TippingBase.tipsByCurrencyByTokenId(tokenId, currency);
+        return _getTipsByTokenId(tokenId, currency);
     }
 
     /// @inheritdoc ITipping
-    function totalTipsByCurrency(address currency) external view returns (uint256) {
-        return TippingBase.totalTipsByCurrency(currency);
+    function tippingCurrencies() external view returns (address[] memory) {
+        return _getTippingCurrencies();
     }
 
     /// @inheritdoc ITipping
-    function tipAmountByCurrency(address currency) external view returns (uint256) {
-        return TippingBase.tipAmountByCurrency(currency);
-    }
-
-    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                         Internal                           */
-    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
-
-    function _validateTipRequest(
-        address sender,
-        address receiver,
-        address currency,
-        uint256 amount
-    ) internal pure {
-        if (currency == address(0)) CurrencyIsZero.selector.revertWith();
-        if (sender == receiver) CannotTipSelf.selector.revertWith();
-        if (amount == 0) AmountIsZero.selector.revertWith();
+    function totalTipsByCurrency(address currency) external view returns (uint256) {
+        return _getTotalTipsByCurrency(currency);
     }
 
-    function _payProtocol(address sender, uint256 amount) internal returns (uint256 protocolFee) {
-        MembershipStorage.Layout storage ds = MembershipStorage.layout();
-        IPlatformRequirements platform = IPlatformRequirements(ds.spaceFactory);
-
-        protocolFee = BasisPoints.calculate(amount, 50); // 0.5%
-
-        CurrencyTransfer.transferCurrency(
-            CurrencyTransfer.NATIVE_TOKEN,
-            sender,
-            platform.getFeeRecipient(),
-            protocolFee
-        );
+    /// @inheritdoc ITipping
+    function tipAmountByCurrency(address currency) external view returns (uint256) {
+        return _getTipAmountByCurrency(currency);
     }
 }

package/src/spaces/facets/tipping/TippingStorage.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+library TippingStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.tipping.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xb6cb334a9eea0cca2581db4520b45ac6f03de8e3927292302206bb82168be300;
+
+    struct TippingStats {
+        uint256 totalTips;
+        uint256 tipAmount;
+    }
+
+    struct Layout {
+        EnumerableSet.AddressSet currencies;
+        mapping(uint256 tokenId => mapping(address currency => uint256 amount)) tipsByCurrencyByTokenId;
+        mapping(address currency => TippingStats) tippingStatsByCurrency;
+        mapping(address wallet => mapping(address currency => TippingStats)) tippingStatsByCurrencyByWallet;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}