@towns-protocol/contracts 0.0.302

package/src/spaces/facets/owner/SpaceOwnerStorage.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library SpaceOwnerStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.owner.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x7fc24c9500f4388b797f8975c0991ad4ffd0338c2cbf5335b2bf5b7fe5747700;
+
+    struct Space {
+        string name;
+        string uri;
+        uint256 tokenId;
+        uint256 createdAt;
+    }
+
+    struct SpaceMetadata {
+        string shortDescription;
+        string longDescription;
+    }
+
+    struct Layout {
+        address factory;
+        mapping(uint256 => address) spaceByTokenId;
+        mapping(address => Space) spaceByAddress;
+        mapping(address => SpaceMetadata) spaceMetadata;
+        string defaultUri;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/spaces/facets/owner/SpaceOwnerUriBase.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ISpaceOwnerBase} from "src/spaces/facets/owner/ISpaceOwner.sol";
+
+// libraries
+import {Validator} from "../../../utils/libraries/Validator.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+// contracts
+import {SpaceOwnerStorage} from "src/spaces/facets/owner/SpaceOwnerStorage.sol";
+
+abstract contract SpaceOwnerUriBase is ISpaceOwnerBase {
+    using LibString for address;
+
+    function _setDefaultUri(string memory uri) internal {
+        Validator.checkLength(uri, 1);
+
+        SpaceOwnerStorage.layout().defaultUri = uri;
+        emit SpaceOwner__SetDefaultUri(uri);
+    }
+
+    function _getDefaultUri() internal view returns (string memory) {
+        return SpaceOwnerStorage.layout().defaultUri;
+    }
+
+    /// @dev Returns `${space.uri}` or `${defaultUri}/${spaceAddress}`
+    function _render(uint256 tokenId) internal view virtual returns (string memory) {
+        SpaceOwnerStorage.Layout storage ds = SpaceOwnerStorage.layout();
+        address spaceAddress = ds.spaceByTokenId[tokenId];
+
+        if (spaceAddress == address(0)) revert SpaceOwner__SpaceNotFound();
+
+        SpaceOwnerStorage.Space storage space = ds.spaceByAddress[spaceAddress];
+
+        // if the space has set a uri, return it
+        if (bytes(space.uri).length != 0) return space.uri;
+
+        string memory defaultUri = ds.defaultUri;
+
+        uint256 length = bytes(defaultUri).length;
+        if (length == 0) revert SpaceOwner__DefaultUriNotSet();
+
+        unchecked {
+            // the ASCII code for "/" is 0x2f
+            if (bytes(defaultUri)[length - 1] != 0x2f) {
+                return string.concat(defaultUri, "/", spaceAddress.toHexStringChecksummed());
+            } else {
+                return string.concat(defaultUri, spaceAddress.toHexStringChecksummed());
+            }
+        }
+    }
+}

package/src/spaces/facets/points/PointsBase.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ITownsPoints} from "../../../airdrop/points/ITownsPoints.sol";
+import {IImplementationRegistry} from "../../../factory/facets/registry/IImplementationRegistry.sol";
+
+// libraries
+import {MembershipStorage} from "../membership/MembershipStorage.sol";
+
+// contracts
+
+/// @notice Base contract for interacting with the TownsPoints contract
+abstract contract PointsBase {
+    /// @dev The implementation ID for the TownsPoints contract
+    bytes32 internal constant AIRDROP_DIAMOND = bytes32("RiverAirdrop");
+
+    function _getAirdropDiamond() internal view returns (address) {
+        return
+            IImplementationRegistry(MembershipStorage.layout().spaceFactory)
+                .getLatestImplementation(AIRDROP_DIAMOND);
+    }
+
+    function _getPoints(
+        address airdropDiamond,
+        ITownsPoints.Action action,
+        bytes memory data
+    ) internal view returns (uint256) {
+        return ITownsPoints(airdropDiamond).getPoints(action, data);
+    }
+
+    function _mintPoints(address airdropDiamond, address to, uint256 amount) internal {
+        ITownsPoints(airdropDiamond).mint(to, amount);
+    }
+}

package/src/spaces/facets/prepay/IPrepay.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+interface IPrepayBase {
+    // =============================================================
+    //                           ERRORS
+    // =============================================================
+    error Prepay__InvalidSupplyAmount();
+    error Prepay__InvalidAmount();
+    error Prepay__InvalidAddress();
+    error Prepay__InvalidMembership();
+
+    // =============================================================
+    //                           EVENTS
+    // =============================================================
+    event Prepay__Prepaid(uint256 supply);
+}
+
+interface IPrepay is IPrepayBase {
+    /**
+     * @notice Prepay a membership
+     * @param supply The amount of memberships to prepay
+     */
+    function prepayMembership(uint256 supply) external payable;
+
+    /**
+     * @notice Get the prepaid supply
+     * @return The remaining prepaid supply
+     */
+    function prepaidMembershipSupply() external view returns (uint256);
+
+    /**
+     * @notice Calculate the prepay fee for a given supply
+     * @param supply The supply to calculate the fee for
+     * @return The fee
+     */
+    function calculateMembershipPrepayFee(uint256 supply) external view returns (uint256);
+}

package/src/spaces/facets/prepay/PrepayBase.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IPrepayBase} from "./IPrepay.sol";
+
+// libraries
+import {PrepayStorage} from "./PrepayStorage.sol";
+
+// contracts
+
+abstract contract PrepayBase is IPrepayBase {
+    function _addPrepay(uint256 supply) internal {
+        PrepayStorage.Layout storage ds = PrepayStorage.layout();
+        ds.supply += supply;
+        emit Prepay__Prepaid(supply);
+    }
+
+    function _reducePrepay(uint256 supply) internal {
+        PrepayStorage.Layout storage ds = PrepayStorage.layout();
+        ds.supply -= supply;
+    }
+
+    function _getPrepaidSupply() internal view returns (uint256) {
+        return PrepayStorage.layout().supply;
+    }
+}

package/src/spaces/facets/prepay/PrepayFacet.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {IPlatformRequirements} from "src/factory/facets/platform/requirements/IPlatformRequirements.sol";
+import {IPrepay} from "src/spaces/facets/prepay/IPrepay.sol";
+
+// libraries
+import {MembershipStorage} from "src/spaces/facets/membership/MembershipStorage.sol";
+import {CurrencyTransfer} from "src/utils/libraries/CurrencyTransfer.sol";
+
+// contracts
+import {PrepayBase} from "./PrepayBase.sol";
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {Entitled} from "src/spaces/facets/Entitled.sol";
+import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
+
+contract PrepayFacet is IPrepay, PrepayBase, ReentrancyGuard, Entitled, Facet {
+    function __PrepayFacet_init() external onlyInitializing {
+        _addInterface(type(IPrepay).interfaceId);
+    }
+
+    function prepayMembership(uint256 supply) external payable nonReentrant {
+        if (supply == 0) revert Prepay__InvalidSupplyAmount();
+
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+        IPlatformRequirements platform = IPlatformRequirements(ds.spaceFactory);
+
+        uint256 cost = supply * platform.getMembershipFee();
+
+        // validate payment covers membership fee
+        if (msg.value != cost) revert Prepay__InvalidAmount();
+
+        // add prepay
+        _addPrepay(supply);
+
+        // transfer fee to platform recipient
+        address currency = ds.membershipCurrency;
+        address platformRecipient = platform.getFeeRecipient();
+        CurrencyTransfer.transferCurrency(
+            currency,
+            msg.sender, // from
+            platformRecipient, // to
+            cost
+        );
+    }
+
+    function prepaidMembershipSupply() external view returns (uint256) {
+        return _getPrepaidSupply();
+    }
+
+    function calculateMembershipPrepayFee(uint256 supply) external view returns (uint256) {
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+        IPlatformRequirements platform = IPlatformRequirements(ds.spaceFactory);
+        return supply * platform.getMembershipFee();
+    }
+}

package/src/spaces/facets/prepay/PrepayStorage.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library PrepayStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.prepay.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_SLOT =
+        0x097b4f25b64e012d0cf55f67e9b34fe5d57f15b11b95baa4ddd136b424967c00;
+
+    struct Layout {
+        uint256 supply;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+}

package/src/spaces/facets/proxy/ISpaceProxyInitializer.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {ITokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/ITokenOwnable.sol";
+import {IManagedProxyBase} from "@towns-protocol/diamond/src/proxy/managed/IManagedProxy.sol";
+import {IMembershipBase} from "src/spaces/facets/membership/IMembership.sol";
+
+// libraries
+
+// contracts
+
+interface ISpaceProxyInitializer is ITokenOwnableBase, IMembershipBase, IManagedProxyBase {
+    function initialize(
+        address owner,
+        address manager,
+        TokenOwnable memory tokenOwnable,
+        Membership memory membership
+    ) external;
+}

package/src/spaces/facets/proxy/SpaceProxy.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {ManagedProxyBase} from "@towns-protocol/diamond/src/proxy/managed/ManagedProxyBase.sol";
+import {Multicallable} from "solady/utils/Multicallable.sol";
+
+contract SpaceProxy is ManagedProxyBase, Multicallable {
+    constructor(ManagedProxy memory init, address initializer, bytes memory data) {
+        __ManagedProxyBase_init(init);
+        Address.functionDelegateCall(initializer, data);
+    }
+
+    receive() external payable {}
+}

package/src/spaces/facets/proxy/SpaceProxyInitializer.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {IERC173} from "@towns-protocol/diamond/src/facets/ownable/IERC173.sol";
+import {IERC5643} from "src/diamond/facets/token/ERC5643/IERC5643.sol";
+import {IMembership} from "src/spaces/facets/membership/IMembership.sol";
+import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+
+// libraries
+
+// contracts
+
+import {Initializable} from "@towns-protocol/diamond/src/facets/initializable/Initializable.sol";
+import {IntrospectionBase} from "@towns-protocol/diamond/src/facets/introspection/IntrospectionBase.sol";
+import {TokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/TokenOwnableBase.sol";
+import {ERC721ABase} from "src/diamond/facets/token/ERC721A/ERC721ABase.sol";
+import {EntitlementGatedBase} from "src/spaces/facets/gated/EntitlementGatedBase.sol";
+import {MembershipBase} from "src/spaces/facets/membership/MembershipBase.sol";
+
+contract SpaceProxyInitializer is
+    ISpaceProxyInitializer,
+    IntrospectionBase,
+    TokenOwnableBase,
+    ERC721ABase,
+    MembershipBase,
+    EntitlementGatedBase,
+    Initializable
+{
+    function initialize(
+        address owner,
+        address manager,
+        TokenOwnable memory tokenOwnable,
+        Membership memory membership
+    ) external initializer {
+        __IntrospectionBase_init();
+        __TokenOwnableBase_init(tokenOwnable);
+        __ERC721ABase_init(membership.name, membership.symbol);
+        __MembershipBase_init(membership, manager);
+
+        _safeMint(owner, 1);
+        _setFallbackEntitlementChecker();
+
+        _setInterfaceIds();
+    }
+
+    function _setInterfaceIds() internal {
+        _addInterface(0x80ac58cd); // ERC165 Interface ID for ERC721
+        _addInterface(0x5b5e139f); // ERC165 Interface ID for ERC721Metadata
+        _addInterface(type(IERC5643).interfaceId); // ERC165 Interface ID for IERC5643
+        _addInterface(type(IERC173).interfaceId); // ERC165 Interface ID for IERC173 (owner)
+        _addInterface(type(IMembership).interfaceId); // ERC165 Interface ID for IMembership
+    }
+}

package/src/spaces/facets/referrals/IReferrals.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+/// @title IReferralsBase
+/// @notice Base interface for referral functionality
+interface IReferralsBase {
+    /// @notice Structure to represent a referral
+    /// @param referralCode Unique code for the referral
+    /// @param basisPoints Percentage of the referral reward in basis points
+    /// @param recipient Address to receive the referral reward
+    struct Referral {
+        string referralCode;
+        uint256 basisPoints;
+        address recipient;
+    }
+
+    // errors
+
+    /// @notice Error thrown when an invalid referral code is provided
+    error Referrals__InvalidReferralCode();
+    /// @notice Error thrown when invalid basis points are provided
+    error Referrals__InvalidBasisPoints();
+    /// @notice Error thrown when an invalid recipient address is provided
+    error Referrals__InvalidRecipient();
+    /// @notice Error thrown when an invalid bps fee is provided
+    error Referrals__InvalidBpsFee();
+    /// @notice Error thrown when a referral already exists
+    error Referrals__ReferralAlreadyExists();
+
+    // events
+
+    /// @notice Event emitted when a new referral is registered
+    /// @param referralCode Unique identifier for the referral
+    /// @param basisPoints Percentage of the referral reward in basis points
+    /// @param recipient Address to receive the referral reward
+    event ReferralRegistered(bytes32 referralCode, uint256 basisPoints, address recipient);
+
+    /// @notice Event emitted when a referral is updated
+    /// @param referralCode Unique identifier for the referral
+    /// @param basisPoints Updated percentage of the referral reward in basis points
+    /// @param recipient Updated address to receive the referral reward
+    event ReferralUpdated(bytes32 referralCode, uint256 basisPoints, address recipient);
+
+    /// @notice Event emitted when a referral is removed
+    /// @param referralCode Unique identifier for the referral
+    event ReferralRemoved(bytes32 referralCode);
+
+    /// @notice Event emitted when the max bps fee is updated
+    /// @param maxBpsFee The new max bps fee
+    event MaxBpsFeeUpdated(uint256 maxBpsFee);
+
+    /// @notice Event emitted when the default bps fee is updated
+    /// @param defaultBpsFee The new default bps fee
+    event DefaultBpsFeeUpdated(uint256 defaultBpsFee);
+}
+
+/// @title IReferrals
+/// @notice Interface for managing referrals
+interface IReferrals is IReferralsBase {
+    /// @notice Register a new referral
+    /// @param referral The referral information to register
+    function registerReferral(Referral memory referral) external;
+
+    /// @notice Get information about a specific referral
+    /// @param referralCode The unique code of the referral to retrieve
+    /// @return The referral information
+    function referralInfo(string memory referralCode) external view returns (Referral memory);
+
+    /// @notice Update a referral
+    /// @param referral The referral information to update
+    function updateReferral(Referral memory referral) external;
+
+    /// @notice Remove a referral
+    /// @param referralCode The unique code of the referral to remove
+    function removeReferral(string memory referralCode) external;
+
+    /// @notice Set the max bps fee
+    /// @param bps The new max bps fee
+    function setMaxBpsFee(uint256 bps) external;
+
+    /// @notice Get the max bps fee
+    /// @return The max bps fee
+    function maxBpsFee() external view returns (uint256);
+
+    /// @notice Set the default bps fee
+    /// @param bps The new default bps fee
+    function setDefaultBpsFee(uint256 bps) external;
+
+    /// @notice Get the default bps fee
+    /// @return The default bps fee
+    function defaultBpsFee() external view returns (uint256);
+}

package/src/spaces/facets/referrals/ReferralsBase.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IReferralsBase} from "./IReferrals.sol";
+import {ReferralsStorage} from "./ReferralsStorage.sol";
+
+abstract contract ReferralsBase is IReferralsBase {
+    function _validateReferral(Referral memory referral) internal view {
+        if (referral.recipient == address(0)) revert Referrals__InvalidRecipient();
+        if (referral.basisPoints == 0) revert Referrals__InvalidBasisPoints();
+        if (bytes(referral.referralCode).length == 0) {
+            revert Referrals__InvalidReferralCode();
+        }
+        uint256 maxBpsFee = _maxBpsFee();
+        if (maxBpsFee > 0 && referral.basisPoints > maxBpsFee) {
+            revert Referrals__InvalidBpsFee();
+        }
+    }
+
+    function _registerReferral(Referral memory referral) internal {
+        bytes32 referralCode = keccak256(bytes(referral.referralCode));
+        ReferralsStorage.Layout storage ds = ReferralsStorage.layout();
+        if (ds.referrals[referralCode].recipient != address(0)) {
+            revert Referrals__ReferralAlreadyExists();
+        }
+
+        _validateReferral(referral);
+
+        ds.referrals[referralCode] = ReferralsStorage.Referral(
+            referral.basisPoints,
+            referral.recipient
+        );
+
+        emit ReferralRegistered(referralCode, referral.basisPoints, referral.recipient);
+    }
+
+    function _referralInfo(string memory referralCode) internal view returns (Referral memory) {
+        ReferralsStorage.Referral storage storedReferral = ReferralsStorage.layout().referrals[
+            keccak256(bytes(referralCode))
+        ];
+        return Referral(referralCode, storedReferral.bpsFee, storedReferral.recipient);
+    }
+
+    function _updateReferral(Referral memory referral) internal {
+        _validateReferral(referral);
+        bytes32 referralCode = keccak256(bytes(referral.referralCode));
+        ReferralsStorage.Layout storage ds = ReferralsStorage.layout();
+        if (ds.referrals[referralCode].recipient == address(0)) {
+            revert Referrals__InvalidReferralCode();
+        }
+        ds.referrals[referralCode] = ReferralsStorage.Referral(
+            referral.basisPoints,
+            referral.recipient
+        );
+        emit ReferralUpdated(referralCode, referral.basisPoints, referral.recipient);
+    }
+
+    function _removeReferral(string memory referralCode) internal {
+        bytes32 referralCodeHash = keccak256(bytes(referralCode));
+        delete ReferralsStorage.layout().referrals[referralCodeHash];
+        emit ReferralRemoved(referralCodeHash);
+    }
+
+    function _setMaxBpsFee(uint256 maxBpsFee) internal {
+        ReferralsStorage.layout().referralSettings.maxBpsFee = maxBpsFee;
+        emit MaxBpsFeeUpdated(maxBpsFee);
+    }
+
+    function _maxBpsFee() internal view returns (uint256) {
+        return ReferralsStorage.layout().referralSettings.maxBpsFee;
+    }
+
+    function _setDefaultBpsFee(uint256 defaultBpsFee) internal {
+        ReferralsStorage.layout().referralSettings.defaultBpsFee = defaultBpsFee;
+        emit DefaultBpsFeeUpdated(defaultBpsFee);
+    }
+
+    function _defaultBpsFee() internal view returns (uint256) {
+        return ReferralsStorage.layout().referralSettings.defaultBpsFee;
+    }
+}

package/src/spaces/facets/referrals/ReferralsFacet.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {Permissions} from "src/spaces/facets/Permissions.sol";
+
+// contracts
+
+import {IReferrals} from "./IReferrals.sol";
+import {ReferralsBase} from "./ReferralsBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {Entitled} from "src/spaces/facets/Entitled.sol";
+
+contract ReferralsFacet is IReferrals, ReferralsBase, Entitled, Facet {
+    function __ReferralsFacet_init() external onlyInitializing {
+        _addInterface(type(IReferrals).interfaceId);
+    }
+
+    /// @inheritdoc IReferrals
+    function registerReferral(Referral memory referral) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _registerReferral(referral);
+    }
+
+    /// @inheritdoc IReferrals
+    function referralInfo(string memory referralCode) external view returns (Referral memory) {
+        return _referralInfo(referralCode);
+    }
+
+    /// @inheritdoc IReferrals
+    function updateReferral(Referral memory referral) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _updateReferral(referral);
+    }
+
+    /// @inheritdoc IReferrals
+    function removeReferral(string memory referralCode) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _removeReferral(referralCode);
+    }
+
+    /// @inheritdoc IReferrals
+    function setMaxBpsFee(uint256 bps) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _setMaxBpsFee(bps);
+    }
+
+    /// @inheritdoc IReferrals
+    function maxBpsFee() external view returns (uint256) {
+        return _maxBpsFee();
+    }
+
+    /// @inheritdoc IReferrals
+    function setDefaultBpsFee(uint256 bps) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _setDefaultBpsFee(bps);
+    }
+
+    /// @inheritdoc IReferrals
+    function defaultBpsFee() external view returns (uint256) {
+        return _defaultBpsFee();
+    }
+}

package/src/spaces/facets/referrals/ReferralsStorage.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library ReferralsStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.referrals.v2.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xaca21cc4d2a125f3e0ae03aa135d42b2b9177631aca87599d42a68b47e900800;
+
+    struct Referral {
+        uint256 bpsFee; // fee in basis points
+        address recipient;
+    }
+
+    struct ReferralSettings {
+        uint256 maxBpsFee; // fee in basis points
+        uint256 defaultBpsFee; // fee in basis points
+    }
+
+    struct Layout {
+        ReferralSettings referralSettings;
+        mapping(bytes32 referralCode => Referral) referrals;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        assembly {
+            ds.slot := STORAGE_SLOT
+        }
+    }
+}