@towns-protocol/contracts 0.0.302

package/scripts/interactions/InteractRiverAlphaSparse.s.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+
+// libraries
+import {stdJson} from "forge-std/StdJson.sol";
+import "forge-std/console.sol";
+
+// contracts
+import {AlphaHelper, DiamondFacetData, FacetData} from "scripts/interactions/helpers/AlphaHelper.sol";
+
+import {DeployRiverRegistry} from "scripts/deployments/diamonds/DeployRiverRegistry.s.sol";
+import {IDiamondInitHelper} from "../deployments/diamonds/IDiamondInitHelper.sol";
+
+contract InteractRiverAlphaSparse is AlphaHelper {
+    mapping(string => address) private diamondDeployments;
+
+    constructor() {
+        diamondDeployments["riverRegistry"] = address(new DeployRiverRegistry());
+    }
+
+    string constant DEFAULT_JSON_FILE = "compiled_source_diff.json";
+    string constant DEFAULT_REPORT_PATH = "/scripts/bytecode-diff/source-diffs/";
+
+    string private jsonData;
+
+    function readJSON(string memory jsonPath) internal {
+        jsonData = vm.readFile(jsonPath);
+    }
+
+    /**
+     * @notice Decodes diamond and facet data from a JSON file output by the bytecode-diff script
+     * @dev Reads the JSON file specified by the DEFAULT_JSON_FILE constant
+     *      and parses it to extract information about updated diamonds and their facets
+     * @return An array of DiamondFacetData structs containing the decoded information
+     */
+    function decodeDiamondsFromJSON() internal view returns (DiamondFacetData[] memory) {
+        uint256 updatedDiamondLen = abi.decode(vm.parseJson(jsonData, ".numUpdated"), (uint256));
+        DiamondFacetData[] memory diamonds = new DiamondFacetData[](updatedDiamondLen);
+
+        for (uint256 i = 0; i < updatedDiamondLen; i++) {
+            // Decode diamond name and number of facets
+            DiamondFacetData memory diamondData = abi.decode(
+                vm.parseJson(jsonData, string.concat("$.updated[", vm.toString(i), "]")),
+                (DiamondFacetData)
+            );
+
+            diamonds[i] = diamondData;
+        }
+
+        return diamonds;
+    }
+
+    /**
+     * @notice Processes diamond and facet updates based on JSON input
+     * @dev This function reads a JSON file containing information about diamond and facet updates,
+     *      then applies these updates to the corresponding diamonds. It performs the following
+     * steps:
+     *      1. Sets the OVERRIDE_DEPLOYMENTS environment variable
+     *      2. Determines the JSON input path (either from INTERACTION_INPUT_PATH env var or using a
+     * default)
+     *      3. Reads and decodes the JSON data
+     *      4. Iterates through each diamond update:
+     *         - Identifies the diamond type (space, spaceOwner, spaceFactory, or baseRegistry)
+     *         - Removes existing facets that are to be updated
+     *         - Prepares new facet cuts
+     *         - Executes a diamondCut operation to apply the updates
+     * @param deployer The address of the account that will deploy and interact with the contracts
+     */
+    function __interact(address deployer) internal override {
+        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
+
+        string memory jsonPath;
+        try vm.envString("INTERACTION_INPUT_PATH") returns (string memory path) {
+            jsonPath = path;
+        } catch {
+            jsonPath = string.concat(vm.projectRoot(), DEFAULT_REPORT_PATH, DEFAULT_JSON_FILE);
+        }
+
+        readJSON(jsonPath);
+
+        DiamondFacetData[] memory diamonds = decodeDiamondsFromJSON();
+
+        // Iterate over diamonds array and process each diamond
+        for (uint256 i = 0; i < diamonds.length; i++) {
+            console.log("interact::diamondName", diamonds[i].diamond);
+            string memory diamondName = diamonds[i].diamond;
+            address diamondDeployedAddress;
+            FacetCut[] memory newCuts;
+            uint256 numFacets = diamonds[i].facets.length;
+            string[] memory facetNames = new string[](numFacets);
+            address[] memory facetAddresses = new address[](numFacets);
+
+            for (uint256 j = 0; j < numFacets; j++) {
+                FacetData memory facetData = diamonds[i].facets[j];
+                facetAddresses[j] = facetData.deployedAddress;
+                facetNames[j] = facetData.facetName;
+            }
+
+            address diamondHelper = diamondDeployments[diamondName];
+            if (diamondHelper != address(0)) {
+                console.log("interact::diamondDeployedName", diamondName);
+                diamondDeployedAddress = getDeployment(diamondName);
+                removeRemoteFacetsByAddresses(deployer, diamondDeployedAddress, facetAddresses);
+                console.log("interact::diamondHelper", diamondHelper);
+                console.log("interact::facetNames", facetNames[0]);
+                console.log("diamondDeployedAddress", diamondDeployedAddress);
+                newCuts = IDiamondInitHelper(diamondHelper).diamondInitHelper(deployer, facetNames);
+
+                vm.broadcast(deployer);
+                IDiamondCut(diamondDeployedAddress).diamondCut(newCuts, address(0), "");
+            }
+        }
+    }
+}

package/scripts/interactions/InteractRiverMainnet.s.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {Towns} from "src/tokens/towns/mainnet/Towns.sol";
+
+// debugging
+import {console} from "forge-std/console.sol";
+
+contract InteractRiverMainnet is Interaction {
+    function __interact(address) internal view override {
+        address towns = address(0);
+
+        address[] memory delegators = Towns(towns).getDelegators();
+
+        for (uint256 i = 0; i < delegators.length; i++) {
+            address delegator = delegators[i];
+            console.log("Delegator:", delegator);
+            console.log("Delegates:", Towns(towns).delegates(delegator));
+        }
+    }
+}

package/scripts/interactions/InteractRiverRegistry.s.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractRiverRegistry is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64[] memory chains = new uint64[](9);
+        chains[0] = 1; // mainnet
+        chains[1] = 11_155_111; // sepolia
+        chains[2] = 8453; // base
+        chains[3] = 84_532; // base sepolia
+        chains[4] = 137; // polygon
+        chains[5] = 42_161; // arbitrum
+        chains[6] = 10; // optimism
+        chains[7] = 100; // gnosis
+        chains[8] = 10_200; // gnosis chiado
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.XCHAIN_BLOCKCHAINS,
+            0,
+            abi.encode(chains)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractRiverRegistrySetBlocklist.s.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractRiverRegistrySetFreq is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        address[] memory value = new address[](3);
+        value[0] = 0xa7f7D83843aB78706344D3Ae882b1d4f9404F254;
+        value[1] = 0x01A7dCd51409758f220c171c209eF3E1C8b10F1E;
+        value[2] = 0xC6CF68A1BCD3B9285fe1d13c128953a14Dd1Bb60;
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.NODE_BLOCKLIST,
+            13_396_808,
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractRiverRegistrySetFreq.s.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractRiverRegistrySetFreq is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64 value = 10;
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_MINIBLOCK_REGISTRATION_FREQUENCY,
+            0,
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractRiverRegistrySetRepl.s.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractRiverRegistrySetFreq is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64 value = 3;
+
+        // NOTE: Set block to something recent, otherwise older records will supersede the new one
+        // For get recent block from command line for env:
+        //     ./core/env/<ENV_NAME>/run.sh registry blocknumber
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_REPLICATION_FACTOR,
+            13824246, // Block number
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractSetDefaultUri.s.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Interaction} from "../common/Interaction.s.sol";
+import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+contract InteractSetDefaultUri is Interaction {
+    string internal constant URI = "https://alpha.river.delivery/";
+
+    function __interact(address deployer) internal override {
+        // vm.setEnv("DEPLOYMENT_CONTEXT", "alpha");
+        address spaceOwner = getDeployment("spaceOwner");
+
+        vm.broadcast(deployer);
+        ISpaceOwner(spaceOwner).setDefaultUri(URI);
+
+        require(LibString.eq(ISpaceOwner(spaceOwner).getDefaultUri(), URI));
+    }
+}

package/scripts/interactions/InteractSetDefaultUriLocalhost.s.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Interaction} from "../common/Interaction.s.sol";
+import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+contract InteractSetDefaultUriLocalhost is Interaction {
+    string internal constant URI = "http://localhost:3002/";
+
+    function __interact(address deployer) internal override {
+        address spaceOwner = getDeployment("spaceOwner");
+
+        vm.broadcast(deployer);
+        ISpaceOwner(spaceOwner).setDefaultUri(URI);
+
+        require(LibString.eq(ISpaceOwner(spaceOwner).getDefaultUri(), URI));
+    }
+}

package/scripts/interactions/InteractTransferOwnership.s.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC173} from "@towns-protocol/diamond/src/facets/ownable/IERC173.sol";
+
+// libraries
+
+// contracts
+import {Interaction} from "../common/Interaction.s.sol";
+
+contract InteractTransferOwnership is Interaction {
+    function __interact(address deployer) internal override {
+        address registry = getDeployment("space");
+        address newOwner = 0x92D549e96C470573b2af464F4E4A865C46C6D728;
+
+        vm.startBroadcast(deployer);
+        IERC173(registry).transferOwnership(newOwner);
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractUpdateMbRecencyCheck.s.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractUpdateMbRecencyCheck is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64 value = 30;
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.MB_RECENCY_CHECK,
+            0,
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractUpdateMediaChunkCount.s.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractUpdateMediaChunkCount is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64 value = 21;
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.MEDIA_CHUNK_COUNT,
+            0,
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractUpdateMediaChunkSize.s.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractUpdateMediaChunkSize is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64 value = 1200000;
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.MEDIA_CHUNK_SIZE,
+            0,
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/helpers/AlphaHelper.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+import {IDiamondLoupe, IDiamondLoupeBase} from "@towns-protocol/diamond/src/facets/loupe/IDiamondLoupe.sol";
+import {IERC173} from "@towns-protocol/diamond/src/facets/ownable/IERC173.sol";
+import {IOwnablePending} from "@towns-protocol/diamond/src/facets/ownable/pending/IOwnablePending.sol";
+
+// libraries
+
+// contracts
+import {DiamondHelper} from "@towns-protocol/diamond/scripts/common/helpers/DiamondHelper.s.sol";
+import {Diamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+/// @dev note: struct fields must be in alphabetical order for the json parser to work
+// see: https://book.getfoundry.sh/cheatcodes/parse-json
+struct DiamondFacetData {
+    string chainName;
+    string diamond;
+    FacetData[] facets;
+    uint256 numFacets;
+}
+
+struct FacetData {
+    address deployedAddress;
+    string facetName;
+    bytes32 sourceHash;
+}
+
+abstract contract AlphaHelper is Interaction, DiamondHelper, IDiamondLoupeBase {
+    /// @notice Get addresses of core facets that should never be removed
+    /// @param diamond The diamond contract address
+    /// @return coreFacets An array of core facet addresses
+    function getCoreFacetAddresses(
+        address diamond
+    ) internal view returns (address[] memory coreFacets) {
+        coreFacets = new address[](5);
+
+        coreFacets[0] = IDiamondLoupe(diamond).facetAddress(IDiamondCut.diamondCut.selector);
+        coreFacets[1] = IDiamondLoupe(diamond).facetAddress(IDiamondLoupe.facets.selector);
+        coreFacets[2] = IDiamondLoupe(diamond).facetAddress(IERC165.supportsInterface.selector);
+        coreFacets[3] = IDiamondLoupe(diamond).facetAddress(IERC173.owner.selector);
+        coreFacets[4] = IDiamondLoupe(diamond).facetAddress(IOwnablePending.currentOwner.selector);
+    }
+
+    /// @notice Check if an address is a core facet that should not be removed
+    /// @param facetAddress The facet address to check
+    /// @param coreFacets Array of core facet addresses
+    /// @return True if the address is a core facet
+    function isCoreFacet(
+        address facetAddress,
+        address[] memory coreFacets
+    ) internal pure returns (bool) {
+        for (uint256 i; i < coreFacets.length; ++i) {
+            if (facetAddress == coreFacets[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// @notice Execute a diamond cut to remove facets
+    /// @param deployer The address that will execute the diamond cut
+    /// @param diamond The diamond contract address
+    function executeDiamondCut(address deployer, address diamond) internal {
+        FacetCut[] memory cuts = baseFacets();
+        if (cuts.length == 0) return;
+        vm.broadcast(deployer);
+        IDiamondCut(diamond).diamondCut(cuts, address(0), "");
+        clearCuts();
+    }
+
+    /// @notice Remove all non-core facets from a diamond
+    /// @param deployer The address that will execute the diamond cut
+    /// @param diamond The diamond contract address
+    function removeRemoteFacets(address deployer, address diamond) internal {
+        Facet[] memory facets = IDiamondLoupe(diamond).facets();
+        address[] memory coreFacets = getCoreFacetAddresses(diamond);
+
+        for (uint256 i; i < facets.length; ++i) {
+            address facet = facets[i].facet;
+
+            if (isCoreFacet(facet, coreFacets)) {
+                info("Skipping core facet: %s", facet);
+                continue;
+            }
+
+            addCut(
+                FacetCut({
+                    facetAddress: facet,
+                    action: FacetCutAction.Remove,
+                    functionSelectors: facets[i].selectors
+                })
+            );
+        }
+
+        executeDiamondCut(deployer, diamond);
+    }
+
+    /// @notice Remove specific facets from a diamond by address
+    /// @param deployer The address that will execute the diamond cut
+    /// @param diamond The diamond contract address
+    /// @param facetAddresses Array of facet addresses to remove
+    function removeRemoteFacetsByAddresses(
+        address deployer,
+        address diamond,
+        address[] memory facetAddresses
+    ) internal {
+        addCutsToRemove(diamond, facetAddresses);
+        executeDiamondCut(deployer, diamond);
+    }
+
+    /// @notice Add the facet cuts to remove from a diamond
+    /// @param diamond The diamond contract address
+    /// @param facetAddresses Array of facet addresses to remove
+    function addCutsToRemove(address diamond, address[] memory facetAddresses) internal {
+        Facet[] memory facets = IDiamondLoupe(diamond).facets();
+        address[] memory coreFacets = getCoreFacetAddresses(diamond);
+
+        for (uint256 i; i < facets.length; ++i) {
+            address facet = facets[i].facet;
+
+            if (isCoreFacet(facet, coreFacets)) {
+                continue;
+            }
+
+            if (contains(facetAddresses, facet)) {
+                addCut(
+                    FacetCut({
+                        facetAddress: facet,
+                        action: FacetCutAction.Remove,
+                        functionSelectors: facets[i].selectors
+                    })
+                );
+            }
+        }
+    }
+
+    /// @notice Check if an address is in an array of addresses
+    function contains(address[] memory facetAddresses, address facet) internal pure returns (bool) {
+        for (uint256 i; i < facetAddresses.length; ++i) {
+            if (facet == facetAddresses[i]) return true;
+        }
+        return false;
+    }
+}

package/scripts/interactions/helpers/RiverConfigValues.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library RiverConfigValues {
+    bytes32 public constant ENABLE_NEW_SNAPSHOT_FORMAT =
+        keccak256("stream.enablenewsnapshotformat");
+    bytes32 public constant XCHAIN_BLOCKCHAINS = keccak256("xchain.blockchains");
+    bytes32 public constant NODE_BLOCKLIST = keccak256("node.blocklist");
+    bytes32 public constant STREAM_MINIBLOCK_REGISTRATION_FREQUENCY =
+        keccak256("stream.miniblockregistrationfrequency");
+    bytes32 public constant STREAM_REPLICATION_FACTOR = keccak256("stream.replicationfactor");
+    bytes32 public constant MEDIA_CHUNK_SIZE = keccak256("stream.media.maxchunksize");
+    bytes32 public constant MEDIA_CHUNK_COUNT = keccak256("stream.media.maxchunkcount");
+    bytes32 public constant ENABLE_NODE_2_NODE_AUTH = keccak256("server.enablenode2nodeauth");
+    bytes32 public constant MB_RECENCY_CHECK = keccak256("stream.recencyconstraints.ageseconds");
+}

package/scripts/interactions/interfaces/IL1StandardBridge.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IL1StandardBridge {
+    function depositETH(uint32 _minGasLimit, bytes calldata _extraData) external payable;
+
+    function depositETHTo(
+        address _to,
+        uint32 _minGasLimit,
+        bytes calldata _extraData
+    ) external payable;
+
+    function depositERC20(
+        address _l1Token,
+        address _l2Token,
+        uint256 _amount,
+        uint32 _minGasLimit,
+        bytes calldata _extraData
+    ) external;
+
+    function depositERC20To(
+        address _l1Token,
+        address _l2Token,
+        address _to,
+        uint256 _amount,
+        uint32 _minGasLimit,
+        bytes calldata _extraData
+    ) external;
+}