@towns-protocol/contracts 0.0.302

package/src/factory/facets/wallet-link/interfaces/ISCL_EIP6565.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface ISCL_EIP6565 {
+    function Verify(
+        string memory m,
+        uint256 r,
+        uint256 s,
+        uint256[5] memory extKpub
+    ) external returns (bool flag);
+
+    function Verify_LE(
+        string memory m,
+        uint256 r,
+        uint256 s,
+        uint256[5] memory extKpub
+    ) external returns (bool flag);
+}

package/src/factory/facets/wallet-link/libraries/SolanaUtils.sol

@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// libraries
+import {LibBit} from "solady/utils/LibBit.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+/**
+ * @dev Utility library for Solana address and public key operations
+ */
+library SolanaUtils {
+    /// @notice Character set for Base58 encoding
+    bytes internal constant ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+    /// @notice Lookup table for the first 32 characters of the Base58 alphabet
+    uint256 internal constant ALPHABET0 =
+        0x31323334353637383941424344454647484a4b4c4d4e50515253545556575859;
+    /// @notice Lookup table for the last 26 characters of the Base58 alphabet
+    uint256 internal constant ALPHABET1 =
+        0x5a6162636465666768696a6b6d6e6f707172737475767778797a000000000000;
+    /// @notice XOR mask for the Base58 alphabet to handle both halves
+    uint256 internal constant XOR_ALPHABET =
+        0x31323334353637383941424344454647484a4b4c4d4e50515253545556575859 ^
+            0x5a6162636465666768696a6b6d6e6f707172737475767778797a000000000000;
+
+    /// @notice Precomputed bitmask for Base58 allowed characters
+    uint256 internal constant BASE58_MAP = 0x07ffeffe07ff7dfe03fe000000000000;
+
+    /**
+     * @dev Get the compressed public key from an extended public key array
+     * @param pubkey The extended public key array (5 elements)
+     * @return The compressed public key as bytes32
+     */
+    function getCompressedPublicKey(uint256[5] memory pubkey) internal pure returns (bytes32) {
+        return bytes32(pubkey[4]);
+    }
+
+    /**
+     * @dev Convert bytes32 to a Base58 encoded string
+     * @param data The bytes32 data to encode
+     * @return finalResult The Base58 encoded string
+     */
+    function toBase58String(bytes32 data) internal pure returns (string memory finalResult) {
+        // Count leading zeros using Solady's LibBit.clz
+        uint256 value = uint256(data);
+        uint256 zeros = LibBit.clz(value) >> 3; // Divide by 8 to convert bits to bytes
+
+        // Calculate the maximum possible length of the result
+        uint8 resultSize = 44; // Max size of a base58 encoded 32 byte value
+
+        // Perform base58 encoding
+        assembly ("memory-safe") {
+            let result := mload(0x40)
+            mstore(result, resultSize)
+            mstore(0x40, add(result, 0x60))
+            // pointer to the last byte of the result, 0x4c = 32 + 44
+            let end := add(result, 0x4c)
+            let ptr := end
+            // encode from the end of the result array
+            for {} 1 {} {
+                if iszero(value) {
+                    break
+                }
+                let remainder := mod(value, 58)
+                value := div(value, 58)
+                // equivalent: table = remainder < 32 ? ALPHABET0 : ALPHABET1
+                let table := xor(ALPHABET1, mul(lt(remainder, 32), XOR_ALPHABET))
+                ptr := sub(ptr, 1)
+                mstore8(ptr, byte(and(remainder, 0x1f), table))
+            }
+            // Add leading '1's for each leading zero byte
+            mstore(
+                sub(ptr, 0x20),
+                0x3131313131313131313131313131313131313131313131313131313131313131
+            )
+            // starting offset of the result
+            ptr := sub(ptr, zeros)
+            // Create the final string with the correct length
+            finalResult := sub(ptr, 0x20)
+            mstore(finalResult, sub(end, ptr))
+        }
+    }
+
+    /**
+     * @dev Get the Solana address as a string from the extended public key
+     * @param pubkey The extended public key array (5 elements)
+     * @return The Base58 encoded Solana address string
+     */
+    function getCompressedPublicKeyAsString(
+        uint256[5] memory pubkey
+    ) internal pure returns (string memory) {
+        bytes32 compressedKey = getCompressedPublicKey(pubkey);
+        return toBase58String(compressedKey);
+    }
+
+    /**
+     * @dev Get Solana address string directly from a compressed public key
+     * @param compressedPubkey The compressed public key (typically extPubKey[4])
+     * @return The Base58 encoded Solana address
+     */
+    function getSolanaAddressFromCompressedKey(
+        uint256 compressedPubkey
+    ) internal pure returns (string memory) {
+        return toBase58String(bytes32(compressedPubkey));
+    }
+
+    /**
+     * @dev Safely extracts the Solana address from a fixed-size extPubKey array
+     * @param extPubKey The extended public key fixed array
+     * @return The Base58 encoded Solana address string
+     */
+    function getSolanaAddressFromFixedExtPubKey(
+        uint256[5] memory extPubKey
+    ) internal pure returns (string memory) {
+        return toBase58String(bytes32(extPubKey[4]));
+    }
+
+    /**
+     * @dev Validates if a string matches the Solana address derived from the given public key
+     * @param solanaAddress The address string to validate
+     * @param extPubKey The extended public key array
+     * @return True if the address matches the derived address from the public key
+     */
+    function isValidSolanaAddress(
+        string memory solanaAddress,
+        uint256[5] memory extPubKey
+    ) internal pure returns (bool) {
+        return LibString.eq(solanaAddress, getSolanaAddressFromFixedExtPubKey(extPubKey));
+    }
+
+    /**
+     * @dev Validates if a string is a valid Solana address (basic validation only)
+     * @param solanaAddress The address string to validate
+     * @return True if the address has valid format, false otherwise
+     */
+    function isValidSolanaAddress(string memory solanaAddress) internal pure returns (bool) {
+        uint256 len = bytes(solanaAddress).length;
+
+        // Solana addresses are between 32-44 characters
+        if (len < 32 || len > 44) {
+            return false;
+        }
+
+        bool isValid = true;
+        assembly ("memory-safe") {
+            let ptr := add(solanaAddress, 0x20)
+            let end := add(ptr, len)
+            for {} lt(ptr, end) {} {
+                let char := byte(0, mload(ptr))
+                // Check if the character is valid using the bitmask
+                // If the bit at position 'char' is not set in the map, the character is invalid
+                if iszero(and(shr(char, BASE58_MAP), 1)) {
+                    isValid := false
+                    break
+                }
+                ptr := add(ptr, 1)
+            }
+        }
+        return isValid;
+    }
+}

package/src/factory/facets/wallet-link/libraries/WalletLib.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+// contracts
+
+library WalletLib {
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STORAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    enum VirtualMachineType {
+        EVM, // Ethereum Virtual Machine (Ethereum, BSC, Polygon, etc.)
+        SVM, // Solana Virtual Machine
+        MOVE, // Move Virtual Machine (Aptos, Sui)
+        CVM, // Cosmos Virtual Machine
+        WASM, // WebAssembly VM (Polkadot, NEAR)
+        AVM, // Avalanche Virtual Machine
+        UNKNOWN // For future compatibility
+    }
+
+    struct Wallet {
+        string addr; // Base58/Bech32/etc. encoded address
+        VirtualMachineType vmType; // Type of VM this wallet belongs to
+    }
+
+    struct RootWallet {
+        EnumerableSet.Bytes32Set walletHashes;
+        address defaultWallet;
+        mapping(bytes32 => Wallet) walletByHash;
+    }
+
+    struct Layout {
+        // mapping RootKeys to Ethereum Wallets is a 1 to many relationship, a root key can have many wallets
+        mapping(address => EnumerableSet.AddressSet) walletsByRootKey;
+        // mapping Ethereum Wallets to RootKey is a 1 to 1 relationship, a wallet can only be linked to 1 root key
+        mapping(address => address) rootKeyByWallet;
+        // mapping of wallet link external dependencies
+        mapping(bytes32 => address) dependencies;
+        // mapping of root key to root wallet
+        mapping(address => RootWallet) rootWalletByRootKey;
+        // mapping of root key hash to root key
+        mapping(bytes32 => address) rootKeyByHash;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("river.wallet.link.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_SLOT =
+        0x19511ce7944c192b1007be99b82019218d1decfc513f05239612743360a0dc00;
+
+    function layout() internal pure returns (Layout storage s) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            s.slot := slot
+        }
+    }
+}

package/src/river/registry/facets/config/IRiverConfig.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// libraries
+import {Setting} from "src/river/registry/libraries/RegistryStorage.sol";
+
+interface IRiverConfigBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /**
+     * @notice Emitted when a setting is changed
+     * @dev if deleted is true and block is max value of uint64, the setting is deleted on all
+     * blocks
+     * @param key The setting key that is changed
+     * @param block The block number on which the setting becomes active
+     * @param value The new setting value
+     * @param deleted True if the setting is deleted (value is empty in this case)
+     */
+    event ConfigurationChanged(bytes32 key, uint64 block, bytes value, bool deleted);
+
+    /**
+     * @notice Emitted when a configuration manager is added
+     * @param manager The configuration manager address
+     */
+    event ConfigurationManagerAdded(address indexed manager);
+
+    /**
+     * @notice Emitted when a configuration manager is removed
+     * @param manager The configuration manager address
+     */
+    event ConfigurationManagerRemoved(address indexed manager);
+}
+
+/**
+ * @title IRiverConfig
+ * @notice The interface for the RiverConfig facet
+ */
+interface IRiverConfig is IRiverConfigBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ADMIN FUNCTIONS                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /**
+     * @notice Add a configuration manager
+     * @param manager The address to add
+     */
+    function approveConfigurationManager(address manager) external;
+
+    /**
+     * @notice Remove a configuration manager
+     * @param manager The address to remove
+     */
+    function removeConfigurationManager(address manager) external;
+
+    /**
+     * @notice Set a bytes setting for the given key
+     * @dev Emits ConfigurationChanged event
+     * @param key The keccak256 hash of the setting name
+     * @param blockNumber The block number on which the setting becomes active, can't be max value
+     * of
+     * uint64
+     * @param value The setting value (value must be its ABI representation), can't be empty
+     */
+    function setConfiguration(bytes32 key, uint64 blockNumber, bytes calldata value) external;
+
+    /**
+     * @notice Deletes the setting for the given key on all blocks
+     * @dev Emits ConfigurationChanged event with deleted flag set to true and block number set to
+     * max
+     * value of uint64
+     * @param key The setting key
+     */
+    function deleteConfiguration(bytes32 key) external;
+
+    /**
+     * @notice Deletes the setting for the given key at the given block
+     * @dev Emits ConfigurationChanged event with deleted flag set to true
+     * @param key The setting key
+     * @param blockNumber The block number on which the setting becomes active
+     */
+    function deleteConfigurationOnBlock(bytes32 key, uint64 blockNumber) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /**
+     * @notice Indication if one or more settings exists for the given key
+     * @param key The setting key
+     * @return True if the setting exists
+     */
+    function configurationExists(bytes32 key) external view returns (bool);
+
+    /**
+     * @notice Get settings for the given key
+     * @dev Note that the returned list isn't ordered by block number
+     * @param key The setting key
+     * @return The setting value
+     */
+    function getConfiguration(bytes32 key) external view returns (Setting[] memory);
+
+    /**
+     * @notice Get all settings store in the registry
+     * @dev Note that the returned list is ordered on key but NOT on block number
+     * @return List will all stored settings
+     */
+    function getAllConfiguration() external view returns (Setting[] memory);
+
+    /**
+     * @notice Check if the given address is a configuration manager
+     * @param manager The address to check
+     * @return True if the address is a configuration manager
+     */
+    function isConfigurationManager(address manager) external view returns (bool);
+}

package/src/river/registry/facets/config/RiverConfig.sol

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IRiverConfig} from "./IRiverConfig.sol";
+import {Setting} from "src/river/registry/libraries/RegistryStorage.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import {RiverRegistryErrors} from "src/river/registry/libraries/RegistryErrors.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";
+import {RegistryModifiers} from "src/river/registry/libraries/RegistryStorage.sol";
+
+contract RiverConfig is IRiverConfig, RegistryModifiers, OwnableBase, Facet {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+    using CustomRevert for string;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ADMIN FUNCTIONS                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function __RiverConfig_init(address[] calldata configManagers) external onlyInitializing {
+        for (uint256 i; i < configManagers.length; ++i) {
+            _approveConfigurationManager(configManagers[i]);
+        }
+    }
+
+    /// @inheritdoc IRiverConfig
+    function approveConfigurationManager(address manager) external onlyOwner {
+        _approveConfigurationManager(manager);
+    }
+
+    /// @inheritdoc IRiverConfig
+    function removeConfigurationManager(address manager) external onlyOwner {
+        if (manager == address(0)) RiverRegistryErrors.BAD_ARG.revertWith();
+
+        if (!ds.configurationManagers.remove(manager)) {
+            RiverRegistryErrors.NOT_FOUND.revertWith();
+        }
+
+        emit ConfigurationManagerRemoved(manager);
+    }
+
+    /// @inheritdoc IRiverConfig
+    function setConfiguration(
+        bytes32 key,
+        uint64 blockNumber,
+        bytes calldata value
+    ) external onlyConfigurationManager(msg.sender) {
+        if (blockNumber == type(uint64).max) {
+            RiverRegistryErrors.BAD_ARG.revertWith();
+        }
+        if (value.length == 0) RiverRegistryErrors.BAD_ARG.revertWith();
+
+        if (!ds.configurationKeys.contains(key)) {
+            ds.configurationKeys.add(key);
+        }
+
+        // if there is already a setting on the given block override it
+        Setting[] storage configs = ds.configuration[key];
+        uint256 configurationLen = configs.length;
+        for (uint256 i; i < configurationLen; ++i) {
+            Setting storage config = configs[i];
+            if (config.blockNumber == blockNumber) {
+                config.value = value;
+                emit ConfigurationChanged(key, blockNumber, value, false);
+                return;
+            }
+        }
+
+        configs.push(Setting(key, blockNumber, value));
+        emit ConfigurationChanged(key, blockNumber, value, false);
+    }
+
+    /// @inheritdoc IRiverConfig
+    function deleteConfiguration(
+        bytes32 key
+    ) external onlyConfigurationManager(msg.sender) configKeyExists(key) {
+        delete ds.configuration[key];
+
+        ds.configurationKeys.remove(key);
+
+        emit ConfigurationChanged(key, type(uint64).max, "", true);
+    }
+
+    /// @inheritdoc IRiverConfig
+    function deleteConfigurationOnBlock(
+        bytes32 key,
+        uint64 blockNumber
+    ) external onlyConfigurationManager(msg.sender) {
+        bool found = false;
+        Setting[] storage configs = ds.configuration[key];
+        uint256 configurationLen = configs.length;
+        for (uint256 i; i < configurationLen; ++i) {
+            if (configs[i].blockNumber == blockNumber) {
+                configs[i] = configs[configurationLen - 1];
+                configs.pop();
+                found = true;
+                break;
+            }
+        }
+
+        if (!found) RiverRegistryErrors.NOT_FOUND.revertWith();
+
+        emit ConfigurationChanged(key, blockNumber, "", true);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IRiverConfig
+    function configurationExists(bytes32 key) external view returns (bool) {
+        return ds.configurationKeys.contains(key);
+    }
+
+    /// @inheritdoc IRiverConfig
+    function getConfiguration(
+        bytes32 key
+    ) external view configKeyExists(key) returns (Setting[] memory) {
+        return ds.configuration[key];
+    }
+
+    /// @inheritdoc IRiverConfig
+    function getAllConfiguration() external view returns (Setting[] memory settings) {
+        uint256 settingCount = 0;
+
+        uint256 configurationLen = ds.configurationKeys.length();
+        for (uint256 i; i < configurationLen; ++i) {
+            bytes32 key = ds.configurationKeys.at(i);
+            settingCount += ds.configuration[key].length;
+        }
+
+        settings = new Setting[](settingCount);
+
+        uint256 keysLen = ds.configurationKeys.length();
+        uint256 c = 0;
+        for (uint256 i; i < keysLen; ++i) {
+            bytes32 key = ds.configurationKeys.at(i);
+            Setting[] storage configs = ds.configuration[key];
+            uint256 configsLen = configs.length;
+            for (uint256 j; j < configsLen; ++j) {
+                settings[c++] = configs[j];
+            }
+        }
+    }
+
+    /// @inheritdoc IRiverConfig
+    function isConfigurationManager(address manager) external view returns (bool) {
+        return ds.configurationManagers.contains(manager);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          INTERNAL                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Internal function to approve a configuration manager, doesn't do any
+    /// validation
+    function _approveConfigurationManager(address manager) internal {
+        if (manager == address(0)) RiverRegistryErrors.BAD_ARG.revertWith();
+
+        if (!ds.configurationManagers.add(manager)) {
+            RiverRegistryErrors.ALREADY_EXISTS.revertWith();
+        }
+
+        emit ConfigurationManagerAdded(manager);
+    }
+}

package/src/river/registry/facets/node/INodeRegistry.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Node, NodeStatus} from "src/river/registry/libraries/RegistryStorage.sol";
+
+// libraries
+
+// contracts
+interface INodeRegistryBase {
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event NodeAdded(
+        address indexed nodeAddress,
+        address indexed operator,
+        string url,
+        NodeStatus status
+    );
+    event NodeStatusUpdated(address indexed nodeAddress, NodeStatus status);
+    event NodeUrlUpdated(address indexed nodeAddress, string url);
+    event NodeRemoved(address indexed nodeAddress);
+}
+
+interface INodeRegistry is INodeRegistryBase {
+    // =============================================================
+    //                           Nodes
+    // =============================================================
+
+    function isNode(address nodeAddress) external view returns (bool);
+    function registerNode(address nodeAddress, string memory url, NodeStatus status) external;
+
+    function removeNode(address nodeAddress) external;
+
+    function updateNodeStatus(address nodeAddress, NodeStatus status) external;
+
+    function updateNodeUrl(address nodeAddress, string memory url) external;
+
+    function getNode(address nodeAddress) external view returns (Node memory);
+
+    function getNodeCount() external view returns (uint256);
+
+    /**
+     * @notice Return array containing all node addresses
+     * @dev WARNING: This operation will copy the entire storage to memory, which can be quite
+     * expensive. This is designed
+     * to mostly be used by view accessors that are queried without any gas fees. Developers should
+     * keep in mind that
+     * this function has an unbounded cost, and using it as part of a state-changing function may
+     * render the function
+     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit
+     * in
+     * a block.
+     */
+    function getAllNodeAddresses() external view returns (address[] memory);
+
+    /**
+     * @notice Return array containing all nodes
+     * @dev WARNING: This operation will copy the entire storage to memory, which can be quite
+     * expensive. This is designed
+     * to mostly be used by view accessors that are queried without any gas fees. Developers should
+     * keep in mind that
+     * this function has an unbounded cost, and using it as part of a state-changing function may
+     * render the function
+     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit
+     * in
+     * a block.
+     */
+    function getAllNodes() external view returns (Node[] memory);
+}