@towns-protocol/contracts 0.0.302

package/src/factory/facets/platform/requirements/PlatformRequirementsBase.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IPlatformRequirementsBase} from "./IPlatformRequirements.sol";
+
+// libraries
+import {PlatformRequirementsStorage} from "./PlatformRequirementsStorage.sol";
+import {BasisPoints} from "src/utils/libraries/BasisPoints.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+// contracts
+
+abstract contract PlatformRequirementsBase is IPlatformRequirementsBase {
+    using CustomRevert for bytes4;
+
+    // Denominator
+    function _getDenominator() internal pure virtual returns (uint256) {
+        return 10_000;
+    }
+
+    // Fee Recipient
+    function _setFeeRecipient(address recipient) internal {
+        if (recipient == address(0)) {
+            Platform__InvalidFeeRecipient.selector.revertWith();
+        }
+
+        PlatformRequirementsStorage.layout().feeRecipient = recipient;
+
+        emit PlatformFeeRecipientSet(recipient);
+    }
+
+    function _getFeeRecipient() internal view returns (address) {
+        return PlatformRequirementsStorage.layout().feeRecipient;
+    }
+
+    // Membership BPS
+    function _setMembershipBps(uint16 bps) internal {
+        if (bps > BasisPoints.MAX_BPS) {
+            Platform__InvalidMembershipBps.selector.revertWith();
+        }
+
+        PlatformRequirementsStorage.layout().membershipBps = bps;
+        emit PlatformMembershipBpsSet(bps);
+    }
+
+    function _getMembershipBps() internal view returns (uint16) {
+        return PlatformRequirementsStorage.layout().membershipBps;
+    }
+
+    // Membership Fee
+    function _setMembershipFee(uint256 fee) internal {
+        PlatformRequirementsStorage.layout().membershipFee = fee;
+        emit PlatformMembershipFeeSet(fee);
+    }
+
+    function _getMembershipFee() internal view returns (uint256) {
+        return PlatformRequirementsStorage.layout().membershipFee;
+    }
+
+    // Membership Mint Limit
+    function _setMembershipMintLimit(uint256 limit) internal {
+        if (limit == 0) Platform__InvalidMembershipMintLimit.selector.revertWith();
+
+        PlatformRequirementsStorage.layout().membershipMintLimit = limit;
+        emit PlatformMembershipMintLimitSet(limit);
+    }
+
+    function _getMembershipMintLimit() internal view returns (uint256) {
+        return PlatformRequirementsStorage.layout().membershipMintLimit;
+    }
+
+    // Membership Duration
+    function _setMembershipDuration(uint64 duration) internal {
+        if (duration == 0) {
+            Platform__InvalidMembershipDuration.selector.revertWith();
+        }
+
+        PlatformRequirementsStorage.layout().membershipDuration = duration;
+        emit PlatformMembershipDurationSet(duration);
+    }
+
+    function _getMembershipDuration() internal view returns (uint64) {
+        return PlatformRequirementsStorage.layout().membershipDuration;
+    }
+
+    // Membership Min Price
+    function _setMembershipMinPrice(uint256 minPrice) internal {
+        if (minPrice == 0) {
+            Platform__InvalidMembershipMinPrice.selector.revertWith();
+        }
+
+        PlatformRequirementsStorage.layout().membershipMinPrice = minPrice;
+        emit PlatformMembershipMinPriceSet(minPrice);
+    }
+
+    function _getMembershipMinPrice() internal view returns (uint256) {
+        return PlatformRequirementsStorage.layout().membershipMinPrice;
+    }
+
+    function _setSwapFees(uint16 protocolBps, uint16 posterBps) internal {
+        if (posterBps > BasisPoints.MAX_BPS || protocolBps > BasisPoints.MAX_BPS) {
+            Platform__InvalidSwapFeeBps.selector.revertWith();
+        }
+        PlatformRequirementsStorage.Layout storage $ = PlatformRequirementsStorage.layout();
+        ($.swapProtocolBps, $.swapPosterBps) = (protocolBps, posterBps);
+        emit PlatformSwapFeesSet(protocolBps, posterBps);
+    }
+
+    function _getSwapFees() internal view returns (uint16 protocolBps, uint16 posterBps) {
+        PlatformRequirementsStorage.Layout storage $ = PlatformRequirementsStorage.layout();
+        return ($.swapProtocolBps, $.swapPosterBps);
+    }
+
+    function _setRouterWhitelisted(address router, bool whitelisted) internal {
+        PlatformRequirementsStorage.Layout storage $ = PlatformRequirementsStorage.layout();
+        $.whitelistedRouters[router] = whitelisted;
+        emit RouterWhitelistUpdated(router, whitelisted);
+    }
+
+    function _isRouterWhitelisted(address router) internal view returns (bool) {
+        return PlatformRequirementsStorage.layout().whitelistedRouters[router];
+    }
+}

package/src/factory/facets/platform/requirements/PlatformRequirementsFacet.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IPlatformRequirements} from "./IPlatformRequirements.sol";
+
+// libraries
+
+// contracts
+
+import {PlatformRequirementsBase} from "./PlatformRequirementsBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+
+contract PlatformRequirementsFacet is
+    IPlatformRequirements,
+    PlatformRequirementsBase,
+    OwnableBase,
+    Facet
+{
+    function __PlatformRequirements_init(
+        address feeRecipient,
+        uint16 membershipBps,
+        uint256 membershipFee,
+        uint256 membershipMintLimit,
+        uint64 membershipDuration,
+        uint256 membershipMinPrice
+    ) external onlyInitializing {
+        _addInterface(type(IPlatformRequirements).interfaceId);
+        _setFeeRecipient(feeRecipient);
+        _setMembershipBps(membershipBps);
+        _setMembershipFee(membershipFee);
+        _setMembershipMintLimit(membershipMintLimit);
+        _setMembershipDuration(membershipDuration);
+        _setMembershipMinPrice(membershipMinPrice);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getFeeRecipient() external view returns (address) {
+        return _getFeeRecipient();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getMembershipBps() external view returns (uint16) {
+        return _getMembershipBps();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getMembershipFee() external view returns (uint256) {
+        return _getMembershipFee();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getMembershipMintLimit() external view returns (uint256) {
+        return _getMembershipMintLimit();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getMembershipDuration() external view returns (uint64) {
+        return _getMembershipDuration();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setMembershipMinPrice(uint256 minPrice) external onlyOwner {
+        _setMembershipMinPrice(minPrice);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getMembershipMinPrice() external view returns (uint256) {
+        return _getMembershipMinPrice();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setFeeRecipient(address recipient) external onlyOwner {
+        _setFeeRecipient(recipient);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setMembershipBps(uint16 bps) external onlyOwner {
+        _setMembershipBps(bps);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setMembershipFee(uint256 fee) external onlyOwner {
+        _setMembershipFee(fee);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setMembershipMintLimit(uint256 limit) external onlyOwner {
+        _setMembershipMintLimit(limit);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setMembershipDuration(uint64 duration) external onlyOwner {
+        _setMembershipDuration(duration);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getDenominator() external pure returns (uint256) {
+        return _getDenominator();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function getSwapFees() external view returns (uint16 protocolBps, uint16 posterBps) {
+        return _getSwapFees();
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setSwapFees(uint16 protocolBps, uint16 posterBps) external onlyOwner {
+        _setSwapFees(protocolBps, posterBps);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function isRouterWhitelisted(address router) external view returns (bool) {
+        return _isRouterWhitelisted(router);
+    }
+
+    /// @inheritdoc IPlatformRequirements
+    function setRouterWhitelisted(address router, bool whitelisted) external onlyOwner {
+        _setRouterWhitelisted(router, whitelisted);
+    }
+}

package/src/factory/facets/platform/requirements/PlatformRequirementsStorage.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library PlatformRequirementsStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.platform.requirements.storage")) - 1))
+    // &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xb29a817dd0719f30ad87abc8dff26e6354077e5b46bf38f34d5ac48732860d00;
+
+    struct Layout {
+        // slot 0
+        uint256 membershipFee;
+        // slot 1
+        uint256 membershipMintLimit;
+        // slot 2
+        address feeRecipient;
+        uint64 membershipDuration;
+        uint16 membershipBps;
+        // slot 3
+        uint256 membershipMinPrice;
+        // slot 4
+        uint16 swapProtocolBps;
+        uint16 swapPosterBps;
+        // slot 5
+        mapping(address => bool) whitelistedRouters;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+}

package/src/factory/facets/registry/IImplementationRegistry.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+interface IImplementationRegistryBase {
+    // =============================================================
+    //                           Errors
+    // =============================================================
+    error InvalidContractType();
+    error InvalidVersion();
+
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event ImplementationAdded(address implementation, bytes32 contractType, uint32 version);
+    event ImplementationApproved(address implementation, bool approved);
+}
+
+interface IImplementationRegistry is IImplementationRegistryBase {
+    /// @notice Add an implementation to the registry
+    /// @param implementation The address of the implementation
+    function addImplementation(address implementation) external;
+
+    /// @notice Approve or disapprove an implementation
+    /// @param implementation The address of the implementation
+    /// @param approval The approval status
+    function approveImplementation(address implementation, bool approval) external;
+
+    /// @notice Get an implementation by contract type and version
+    /// @param contractType The contract type
+    /// @param version The version
+    /// @return The address of the implementation
+    function getImplementation(
+        bytes32 contractType,
+        uint32 version
+    ) external view returns (address);
+
+    /// @notice Get the latest implementation by contract type
+    /// @param contractType The contract type
+    /// @return The address of the latest implementation
+    function getLatestImplementation(bytes32 contractType) external view returns (address);
+}

package/src/factory/facets/registry/ImplementationRegistry.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMetadata} from "src/diamond/facets/metadata/IMetadata.sol";
+import {IImplementationRegistry} from "src/factory/facets/registry/IImplementationRegistry.sol";
+
+// libraries
+import {ImplementationRegistryStorage} from "./ImplementationRegistryStorage.sol";
+
+// contracts
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+
+contract ImplementationRegistryFacet is IImplementationRegistry, OwnableBase, Facet {
+    function __ImplementationRegistry_init() external {
+        _addInterface(type(IImplementationRegistry).interfaceId);
+    }
+
+    /// @inheritdoc IImplementationRegistry
+    function addImplementation(address implementation) external onlyOwner {
+        IMetadata metadata = IMetadata(implementation);
+
+        bytes32 contractType = metadata.contractType();
+        if (contractType == bytes32(0)) revert InvalidContractType();
+
+        ImplementationRegistryStorage.Layout storage ds = ImplementationRegistryStorage.layout();
+
+        uint32 version = metadata.contractVersion();
+        uint32 currentVersion = ds.currentVersion[contractType];
+
+        if (version <= currentVersion) revert InvalidVersion();
+
+        ds.implementation[contractType][version] = implementation;
+        ds.currentVersion[contractType] = version;
+        ds.approved[implementation] = true;
+
+        emit ImplementationAdded(implementation, contractType, version);
+    }
+
+    /// @inheritdoc IImplementationRegistry
+    function approveImplementation(address implementation, bool approval) external onlyOwner {
+        ImplementationRegistryStorage.Layout storage ds = ImplementationRegistryStorage.layout();
+
+        ds.approved[implementation] = approval;
+
+        emit ImplementationApproved(implementation, approval);
+    }
+
+    /// @inheritdoc IImplementationRegistry
+    function getImplementation(
+        bytes32 contractType,
+        uint32 version
+    ) external view returns (address) {
+        return ImplementationRegistryStorage.layout().implementation[contractType][version];
+    }
+
+    /// @inheritdoc IImplementationRegistry
+    function getLatestImplementation(bytes32 contractType) external view returns (address) {
+        ImplementationRegistryStorage.Layout storage ds = ImplementationRegistryStorage.layout();
+        return ds.implementation[contractType][ds.currentVersion[contractType]];
+    }
+}

package/src/factory/facets/registry/ImplementationRegistryStorage.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library ImplementationRegistryStorage {
+    // keccak256(abi.encode(uint256(keccak256("factory.facets.registry.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x31d1d65d94f3e9d7ffc7a93cc3bd1ee24d47f432e2c4fc10a5d92f8e2dd98900;
+
+    struct Layout {
+        mapping(address => bool) approved;
+        mapping(bytes32 => uint32) currentVersion;
+        mapping(bytes32 => mapping(uint32 => address)) implementation;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            ds.slot := slot
+        }
+    }
+}

package/src/factory/facets/wallet-link/IWalletLink.sol

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {WalletLib} from "./libraries/WalletLib.sol";
+// contracts
+
+interface IWalletLinkBase {
+    // =============================================================
+    //                           Structs
+    // =============================================================
+
+    /// @notice Struct for EVM only linked wallets
+    struct LinkedWallet {
+        address addr;
+        bytes signature;
+        string message;
+    }
+
+    struct VMSpecificData {
+        string key;
+        bytes value;
+    }
+
+    /// @notice Struct for non-EVM linked wallets
+    struct NonEVMLinkedWallet {
+        WalletLib.Wallet wallet;
+        bytes signature; // Signature in the VM's native format
+        string message; // Message that was signed
+        VMSpecificData[] extraData; // Flexible array for VM-specific requirements
+    }
+
+    /// @notice Struct for Solana wallet linking requirements
+    /// @dev This will be encoded in extraData for Solana wallets with key being "extPubKey"
+    /// SolanaSpecificData memory solanaSpecificData = abi.decode(
+    ///   nonEVMWallet.extraData[0].value,
+    ///   (SolanaSpecificData)
+    /// );
+    struct SolanaSpecificData {
+        uint256[5] extPubKey; // Extended public key for Solana
+    }
+
+    struct WalletQueryOptions {
+        bool includeDelegations;
+    }
+
+    // =============================================================
+    //                           Events
+    // =============================================================
+
+    /// @notice Emitted when a user links their wallet to a rootKey
+    event LinkWalletToRootKey(address indexed wallet, address indexed rootKey);
+
+    /// @notice Emitted when two wallets are unlinked
+    event RemoveLink(address indexed wallet, address indexed secondWallet);
+
+    /// @notice Emitted when a default wallet is set for a root key
+    event SetDefaultWallet(address indexed rootKey, address indexed defaultWallet);
+
+    /// @notice Emitted when a non-EVM wallet is linked to a root key
+    event LinkNonEVMWalletToRootWallet(bytes32 indexed walletHash, address indexed rootKey);
+
+    /// @notice Emitted when a non-EVM wallet is removed from a root key
+    event RemoveNonEVMWalletLink(bytes32 indexed walletHash, address indexed rootKey);
+
+    // =============================================================
+    //                      Errors
+    // =============================================================
+    error WalletLink__InvalidAddress();
+    error WalletLink__LinkAlreadyExists(address wallet, address rootKey);
+    error WalletLink__LinkedToAnotherRootKey(address wallet, address rootKey);
+    error WalletLink__InvalidSignature();
+    error WalletLink__NotLinked(address wallet, address rootKey);
+    error WalletLink__CannotRemoveRootWallet();
+    error WalletLink__CannotLinkToSelf();
+    error WalletLink__CannotLinkToRootWallet(address wallet, address rootKey);
+    error WalletLink__DefaultWalletAlreadySet();
+    error WalletLink__MaxLinkedWalletsReached();
+    error WalletLink__CannotRemoveDefaultWallet();
+    error WalletLink__UnsupportedVMType();
+    error WalletLink__InvalidVMSpecificData(string key, bytes value);
+    error WalletLink__InvalidMessage();
+    error WalletLink__NonEVMWalletAlreadyLinked(string wallet, address rootKey);
+    error WalletLink__InvalidNonEVMAddress();
+    error WalletLink__RootKeyMismatch(address callerRootKey, address rootKey);
+    error WalletLink__NonEVMWalletNotLinked(string wallet, address rootKey);
+    error WalletLink__AddressMismatch();
+}
+
+interface IWalletLink is IWalletLinkBase {
+    /**
+     * @notice Link caller wallet to a root wallet
+     * @param rootWallet the root wallet that the caller is linking to
+     * @param nonce a nonce used to prevent replay attacks, nonce must always be higher than previous nonce
+     */
+    function linkCallerToRootKey(LinkedWallet memory rootWallet, uint256 nonce) external;
+
+    /**
+     * @notice Link a wallet to a root wallet
+     * @param wallet the wallet being linked to the root wallet
+     * @param rootWallet the root wallet that the caller is linking to
+     * @param nonce a nonce used to prevent replay attacks, nonce must always be higher than previous nonce
+     */
+    function linkWalletToRootKey(
+        LinkedWallet memory wallet,
+        LinkedWallet memory rootWallet,
+        uint256 nonce
+    ) external;
+
+    /**
+     * @notice Link a non-EVM wallet to a root wallet
+     * @param wallet the wallet being linked to the root wallet
+     * @param nonce a nonce used to prevent replay attacks, nonce must always be higher than previous nonce
+     * @dev The function can only be called by an already linked wallet
+     */
+    function linkNonEVMWalletToRootKey(NonEVMLinkedWallet calldata wallet, uint256 nonce) external;
+
+    /**
+     * @notice Remove a non-EVM wallet link from a root wallet
+     * @param wallet the wallet being removed from the root wallet
+     * @param nonce a nonce used to prevent replay attacks, nonce must always be higher than previous nonce
+     * @dev The function can only be called by an already linked wallet
+     */
+    function removeNonEVMWalletLink(WalletLib.Wallet memory wallet, uint256 nonce) external;
+
+    /**
+     * @notice Called via the rootkey signing a message to a remove a wallet from itself
+     * @param wallet the wallet being unlinked from the sending wallet
+     */
+    function removeLink(address wallet, LinkedWallet memory rootWallet, uint256 nonce) external;
+
+    /**
+     * @notice Remove the caller's link to their root key
+     */
+    function removeCallerLink() external;
+
+    /**
+     * @notice Set the default wallet by the root wallet
+     * @param defaultWallet the wallet being set as the default wallet
+     * @dev A wallet can only be set as the default wallet if it is already linked to the root wallet
+     * @dev The default wallet can only be an EVM wallet for now
+     */
+    function setDefaultWallet(address defaultWallet) external;
+
+    // =============================================================
+    //                      External - Read
+    // =============================================================
+
+    /**
+     * @notice Returns the default wallet for a root key
+     * @param rootKey the public key of the users rootkey to find associated wallets for
+     * @return defaultWallet the default wallet for the root key
+     */
+    function getDefaultWallet(address rootKey) external view returns (address);
+
+    /**
+     * @notice Returns all wallets linked to a root key
+     * @param rootKey the public key of the users rootkey to find associated wallets for
+     * @return wallets an array of ethereum wallets linked to this root key
+     */
+    function getWalletsByRootKey(address rootKey) external view returns (address[] memory wallets);
+
+    /**
+     * @notice Returns all wallets linked to a root key with their metadata
+     * @param rootKey the public key of the users rootkey to find associated wallets for
+     * @return wallets an array of wallets with their metadata
+     */
+    function getAllWalletsByRootKey(
+        address rootKey
+    ) external view returns (WalletLib.Wallet[] memory wallets);
+
+    /**
+     * @notice Returns the root key for a given wallet
+     * @param wallet the ethereum wallet to find associated root key for
+     * @return rootKey the rootkey that this wallet is linked to
+     */
+    function getRootKeyForWallet(address wallet) external view returns (address rootKey);
+
+    /**
+     * @notice checks if a root key and wallet are linked
+     * @param rootKey the public key of the users rootkey to check
+     * @param wallet the ethereum wallet to check
+     * @return areLinked boolean if they are linked together
+     */
+    function checkIfLinked(address rootKey, address wallet) external view returns (bool);
+
+    /**
+     * @notice checks if a root key and non-EVM wallet are linked
+     * @param rootKey the public key of the users rootkey to check
+     * @param walletHash the hash of the non-EVM wallet to check
+     * @return areLinked boolean if they are linked together
+     */
+    function checkIfNonEVMWalletLinked(
+        address rootKey,
+        bytes32 walletHash
+    ) external view returns (bool);
+
+    /**
+     * @notice gets the latest nonce for a rootkey to use a higher one for next link action
+     * @param rootKey the public key of the users rootkey to check
+     */
+    function getLatestNonceForRootKey(address rootKey) external view returns (uint256);
+
+    /**
+     * @notice gets the dependency address for a given dependency label
+     * @param dependency the dependency label to get
+     */
+    function getDependency(bytes32 dependency) external view returns (address);
+
+    /**
+     * @notice sets the dependency address for a given dependency label
+     * @param dependency the dependency label to set
+     * @param dependencyAddress the dependency address to set
+     */
+    function setDependency(bytes32 dependency, address dependencyAddress) external;
+}