@towns-protocol/contracts 0.0.302

package/scripts/interactions/InteractBridgeLayerZero.s.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// common
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+import {LibLayerZeroValues} from "scripts/deployments/utils/LibLayerZeroValues.sol";
+
+// contracts
+import {Towns} from "src/tokens/towns/multichain/Towns.sol";
+import {SendParam} from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
+import {OptionsBuilder} from "@layerzerolabs/oapp-evm/contracts/oapp/libs/OptionsBuilder.sol";
+import {MessagingFee} from "@layerzerolabs/oapp-evm/contracts/oapp/OApp.sol";
+
+// debugging
+import {console} from "forge-std/console.sol";
+contract InteractBridgeLayerZero is Interaction {
+    using OptionsBuilder for bytes;
+
+    address internal BNB_MULTISIG = address(1);
+
+    function addressToBytes32(address _addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(_addr)));
+    }
+
+    function __interact(address deployer) internal override {}
+
+    function sendToEth(address deployer) internal {
+        address towns = getDeployment("townsBnb");
+        uint256 amount = 11 ether;
+        uint32 dstEid = LibLayerZeroValues.getEid(1); // Ethereum
+
+        Towns oft = Towns(towns);
+
+        bytes memory extraOptions = OptionsBuilder.newOptions().addExecutorLzReceiveOption(
+            65000,
+            0
+        );
+        SendParam memory sendParam = SendParam({
+            dstEid: dstEid,
+            to: addressToBytes32(deployer),
+            amountLD: amount,
+            minAmountLD: (amount * 95) / 100, // 5% slippage tolerance
+            extraOptions: extraOptions,
+            composeMsg: "",
+            oftCmd: ""
+        });
+
+        // Get fee quote
+        MessagingFee memory fee = oft.quoteSend(sendParam, false);
+
+        console.log("Sending tokens...");
+        console.log("Towns address:", towns);
+        console.log("Fee amount:", fee.nativeFee);
+
+        // Send tokens
+        vm.startBroadcast(deployer);
+        oft.send{value: fee.nativeFee}(sendParam, fee, msg.sender);
+        vm.stopBroadcast();
+    }
+
+    function sendToBnb(address deployer) internal {
+        address towns = getDeployment("townsMainnet");
+        address wrappedTowns = getDeployment("wTowns");
+        uint256 amount = 11 ether;
+        uint32 dstEid = LibLayerZeroValues.getEid(56); // Binance
+
+        Towns oft = Towns(wrappedTowns);
+
+        bytes memory extraOptions = OptionsBuilder.newOptions().addExecutorLzReceiveOption(
+            65000,
+            0
+        );
+
+        SendParam memory sendParam = SendParam({
+            dstEid: dstEid,
+            to: addressToBytes32(BNB_MULTISIG),
+            amountLD: amount,
+            minAmountLD: (amount * 95) / 100, // 5% slippage tolerance
+            extraOptions: extraOptions,
+            composeMsg: "",
+            oftCmd: ""
+        });
+
+        // Get fee quote
+        MessagingFee memory fee = oft.quoteSend(sendParam, false);
+
+        console.log("Sending tokens...");
+        console.log("Towns address:", towns);
+        console.log("Wrapped Towns address:", wrappedTowns);
+        console.log("Fee amount:", fee.nativeFee);
+
+        // Send tokens
+        vm.startBroadcast(deployer);
+        IERC20(towns).approve(address(oft), amount);
+        oft.send{value: fee.nativeFee}(sendParam, fee, msg.sender);
+        IERC20(towns).approve(address(oft), 0);
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractClaimCondition.s.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDropFacet, IDropFacetBase} from "src/airdrop/drop/IDropFacet.sol";
+
+// libraries
+import {DropGroup} from "src/airdrop/drop/DropGroup.sol";
+import {MerkleTree} from "test/utils/MerkleTree.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+// deployments
+import {DeployRiverAirdrop} from "scripts/deployments/diamonds/DeployRiverAirdrop.s.sol";
+import {DeployTownsBase} from "scripts/deployments/utils/DeployTownsBase.s.sol";
+
+uint256 constant MAX_CLAIMABLE_SUPPLY = 5 ether;
+
+contract InteractClaimCondition is IDropFacetBase, Interaction {
+    address[] public wallets;
+    uint256[] public amounts;
+    uint256[] public points;
+
+    function setUp() public {
+        wallets.push(0x86312a65B491CF25D9D265f6218AB013DaCa5e19);
+        amounts.push(1 ether); // equivalent to 1 token
+        points.push(1);
+    }
+
+    function __interact(address deployer) internal override {
+        vm.pauseGasMetering();
+
+        DeployRiverAirdrop deployRiverAirdrop = new DeployRiverAirdrop();
+        DeployTownsBase deployTownsBase = new DeployTownsBase();
+        MerkleTree merkleTree = new MerkleTree();
+
+        address riverAirdrop = deployRiverAirdrop.deploy(deployer);
+        address townsBase = deployTownsBase.deploy(deployer);
+        (bytes32 root, ) = merkleTree.constructTree(wallets, amounts, points);
+
+        DropGroup.ClaimCondition[] memory conditions = new DropGroup.ClaimCondition[](1);
+        conditions[0] = DropGroup.ClaimCondition({
+            startTimestamp: uint40(block.timestamp),
+            endTimestamp: 0,
+            maxClaimableSupply: MAX_CLAIMABLE_SUPPLY,
+            supplyClaimed: 0,
+            merkleRoot: root,
+            currency: address(townsBase),
+            penaltyBps: 1000 // 10%
+        });
+
+        vm.broadcast(deployer);
+        IDropFacet(riverAirdrop).setClaimConditions(conditions);
+    }
+}

package/scripts/interactions/InteractCreateSpace.s.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IArchitectBase} from "src/factory/facets/architect/IArchitect.sol";
+
+import {IPricingModules, IPricingModulesBase} from "src/factory/facets/architect/pricing/IPricingModules.sol";
+import {ICreateSpace} from "src/factory/facets/create/ICreateSpace.sol";
+
+// common
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {SpaceHelper} from "test/spaces/SpaceHelper.sol";
+
+// libraries
+import {LibString} from "solady/utils/LibString.sol";
+
+// debugging
+import {console} from "forge-std/console.sol";
+
+contract InteractCreateSpace is Interaction, SpaceHelper, IPricingModulesBase {
+    string public constant TIERED_LOG_PRICING_MODULE = "TieredLogPricingOracleV3";
+
+    function __interact(address deployer) internal override {
+        // Get SpaceFactory deployment address
+        address spaceFactory = getDeployment("spaceFactory");
+
+        ICreateSpace createSpace = ICreateSpace(spaceFactory);
+        IPricingModules pricingModules = IPricingModules(spaceFactory);
+
+        PricingModule[] memory modules = pricingModules.listPricingModules();
+
+        address tieredLogPricing;
+        for (uint256 i = 0; i < modules.length; i++) {
+            if (LibString.eq(modules[i].name, TIERED_LOG_PRICING_MODULE)) {
+                tieredLogPricing = modules[i].module;
+            }
+        }
+
+        require(tieredLogPricing != address(0), "TieredLogPricingOracleV3 not found");
+
+        IArchitectBase.SpaceInfo memory info = _createEveryoneSpaceInfo("test");
+        info.membership.settings.pricingModule = tieredLogPricing;
+
+        vm.startBroadcast(deployer);
+        address space = createSpace.createSpace(info);
+        vm.stopBroadcast();
+
+        console.log("Space created at address:", space);
+    }
+}

package/scripts/interactions/InteractDiamondCut.s.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+
+// libraries
+import {console} from "forge-std/console.sol";
+
+// contracts
+import {Interaction} from "../common/Interaction.s.sol";
+import {AlphaHelper} from "./helpers/AlphaHelper.sol";
+
+// facet
+import {DeploySpaceOwnerFacet} from "scripts/deployments/facets/DeploySpaceOwnerFacet.s.sol";
+
+contract InteractDiamondCut is Interaction, AlphaHelper {
+    function __interact(address deployer) internal override {
+        address diamond = getDeployment("spaceOwner");
+        address spaceOwnerFacet = 0x09FCbC926F9Ec236fa3f825bF65b62776a9413aD;
+
+        address[] memory facetAddresses = new address[](1);
+        facetAddresses[0] = spaceOwnerFacet;
+
+        // add the diamond cut to remove the facet
+        addCutsToRemove(diamond, facetAddresses);
+
+        // deploy the new facet
+        console.log("deployer", deployer);
+        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
+        vm.broadcast(deployer);
+        spaceOwnerFacet = DeploySpaceOwnerFacet.deploy();
+
+        // add the new facet to the diamond
+        addCut(DeploySpaceOwnerFacet.makeCut(spaceOwnerFacet, FacetCutAction.Add));
+
+        bytes memory initData = "";
+
+        vm.broadcast(deployer);
+        IDiamondCut(diamond).diamondCut(
+            baseFacets(),
+            initData.length > 0 ? spaceOwnerFacet : address(0),
+            initData
+        );
+    }
+}

package/scripts/interactions/InteractDropFacet.s.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDropFacet, IDropFacetBase} from "src/airdrop/drop/IDropFacet.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+import {DropClaim} from "src/airdrop/drop/DropClaim.sol";
+import {DropGroup} from "src/airdrop/drop/DropGroup.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {console} from "forge-std/console.sol";
+
+// deployments
+import {DeployRiverAirdrop} from "scripts/deployments/diamonds/DeployRiverAirdrop.s.sol";
+import {DropFacet} from "src/airdrop/drop/DropFacet.sol";
+
+contract InteractDropFacet is Interaction, IDropFacetBase {
+    function __interact(address) internal override {
+        address airdrop = getDeployment("riverAirdrop");
+        address dropFacet = 0x8DB408fD918e80D09Afb895f41480076ba96C74b;
+
+        DropFacet facet = new DropFacet();
+        bytes memory bytecode = address(facet).code;
+        vm.etch(dropFacet, bytecode);
+
+        vm.expectRevert(DropFacet__NoActiveClaimCondition.selector);
+        IDropFacet(airdrop).getActiveClaimConditionId();
+    }
+}

package/scripts/interactions/InteractEnableNewSnapshotFormat.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 InteractEnableNewSnapshotFormat is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64 value = 1;
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.ENABLE_NEW_SNAPSHOT_FORMAT,
+            0,
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractEnableNode2NodeAuth.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 InteractEnableNode2NodeAuth is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        uint64 value = 1;
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.ENABLE_NODE_2_NODE_AUTH,
+            0,
+            abi.encode(value)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractMembership.s.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {IMembership} from "src/spaces/facets/membership/IMembership.sol";
+import {MembershipFacet} from "src/spaces/facets/membership/MembershipFacet.sol";
+import {IPlatformRequirements} from "src/factory/facets/platform/requirements/IPlatformRequirements.sol";
+
+import {console} from "forge-std/console.sol";
+
+contract InteractMembership is Interaction {
+    address SPACE = 0x5494249cFF3F856d4611159f00C0eE916A96396D;
+    address MEMBERSHIP_FACET = 0xfE645928B2EdB6176E6b792c09708d9421E7f91b;
+    address SPACE_FACTORY = 0xC09Ac0FFeecAaE5100158247512DC177AeacA3e3;
+
+    function __interact(address) internal override {
+        IPlatformRequirements requirements = _getMembershipReqs();
+
+        console.log("requirements.getMembershipMinPrice()", requirements.getMembershipMinPrice());
+        console.log("requirements.getMembershipFee()", requirements.getMembershipFee());
+
+        MembershipFacet facet = new MembershipFacet();
+        bytes memory bytecode = address(facet).code;
+        vm.etch(MEMBERSHIP_FACET, bytecode);
+
+        IMembership membership = IMembership(SPACE);
+
+        console.log("membership.getMembershipPrice()", membership.getMembershipPrice());
+        console.log(
+            "membership.getMembershipRenewalPrice(0)",
+            membership.getMembershipRenewalPrice(0)
+        );
+        console.log(
+            "membership.getMembershipRenewalPrice(1)",
+            membership.getMembershipRenewalPrice(1)
+        );
+    }
+
+    function _getMembershipReqs() internal view returns (IPlatformRequirements) {
+        return IPlatformRequirements(SPACE_FACTORY);
+    }
+}

package/scripts/interactions/InteractMockERC721A.s.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {MockERC721A} from "test/mocks/MockERC721A.sol";
+
+contract InteractMockERC721A is Interaction {
+    function __interact(address deployer) internal override {
+        address nft = getDeployment("mockERC721A");
+
+        vm.startBroadcast(deployer);
+        MockERC721A(nft).mintTo(deployer);
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractNodeOperators.s.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {NodeOperatorStatus} from "src/base/registry/facets/operator/NodeOperatorStorage.sol";
+
+// libraries
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {NodeOperatorFacet} from "src/base/registry/facets/operator/NodeOperatorFacet.sol";
+
+// debugging
+import {console} from "forge-std/console.sol";
+
+contract InteractNodeOperators is Interaction {
+    function __interact(address) internal override {
+        address baseRegistry = getDeployment("baseRegistry");
+
+        address[] memory operators = NodeOperatorFacet(baseRegistry).getOperators();
+
+        for (uint256 i = 0; i < operators.length; i++) {
+            address operator = operators[i];
+            NodeOperatorStatus status = NodeOperatorFacet(baseRegistry).getOperatorStatus(operator);
+            console.log("Operator:", operator);
+            _logStatus(status);
+        }
+    }
+
+    function _logStatus(NodeOperatorStatus status) internal pure {
+        if (status == NodeOperatorStatus.Exiting) {
+            console.log("Exiting");
+        } else if (status == NodeOperatorStatus.Standby) {
+            console.log("Standby");
+        } else if (status == NodeOperatorStatus.Approved) {
+            console.log("Approved");
+        } else if (status == NodeOperatorStatus.Active) {
+            console.log("Active");
+        }
+    }
+}

package/scripts/interactions/InteractPostDeploy.s.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IImplementationRegistry} from "../../src/factory/facets/registry/IImplementationRegistry.sol";
+import {ISpaceDelegation} from "src/base/registry/facets/delegation/ISpaceDelegation.sol";
+import {IMainnetDelegation} from "src/base/registry/facets/mainnet/IMainnetDelegation.sol";
+import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
+import {INodeOperator} from "src/base/registry/facets/operator/INodeOperator.sol";
+import {IRewardsDistribution} from "src/base/registry/facets/distribution/v2/IRewardsDistribution.sol";
+
+// libraries
+import {NodeOperatorStatus} from "src/base/registry/facets/operator/NodeOperatorStorage.sol";
+
+// contracts
+import {MAX_CLAIMABLE_SUPPLY} from "./InteractClaimCondition.s.sol";
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {MockTowns} from "test/mocks/MockTowns.sol";
+
+// deployments
+import {DeployProxyBatchDelegation} from "scripts/deployments/utils/DeployProxyBatchDelegation.s.sol";
+import {DeployTownsBase} from "scripts/deployments/utils/DeployTownsBase.s.sol";
+
+contract InteractPostDeploy is Interaction {
+    DeployProxyBatchDelegation deployProxyDelegation = new DeployProxyBatchDelegation();
+    DeployTownsBase deployTownsBase = new DeployTownsBase();
+
+    address internal constant OPERATOR = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
+    address internal constant STAKER = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8;
+
+    function __interact(address deployer) internal override {
+        vm.pauseGasMetering();
+        address spaceOwner = getDeployment("spaceOwner");
+        address spaceFactory = getDeployment("spaceFactory");
+        address baseRegistry = getDeployment("baseRegistry");
+        address riverAirdrop = getDeployment("riverAirdrop");
+        address appRegistry = getDeployment("appRegistry");
+        address townsBase = deployTownsBase.deploy(deployer);
+        address proxyDelegation = deployProxyDelegation.deploy(deployer);
+
+        // this is for anvil deployment only
+        vm.startBroadcast(deployer);
+        MockTowns(townsBase).localMint(riverAirdrop, MAX_CLAIMABLE_SUPPLY);
+        MockTowns(townsBase).localMint(STAKER, MAX_CLAIMABLE_SUPPLY);
+        MockTowns(townsBase).localMint(baseRegistry, MAX_CLAIMABLE_SUPPLY);
+        ISpaceOwner(spaceOwner).setFactory(spaceFactory);
+        IImplementationRegistry(spaceFactory).addImplementation(baseRegistry);
+        IImplementationRegistry(spaceFactory).addImplementation(riverAirdrop);
+        IImplementationRegistry(spaceFactory).addImplementation(appRegistry);
+        IMainnetDelegation(baseRegistry).setProxyDelegation(proxyDelegation);
+        IRewardsDistribution(baseRegistry).setRewardNotifier(deployer, true);
+        IRewardsDistribution(baseRegistry).notifyRewardAmount(MAX_CLAIMABLE_SUPPLY);
+
+        INodeOperator operatorFacet = INodeOperator(baseRegistry);
+        operatorFacet.registerOperator(OPERATOR);
+        operatorFacet.setOperatorStatus(OPERATOR, NodeOperatorStatus.Approved);
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractPrepay.s.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+import {IPrepay} from "src/spaces/facets/prepay/IPrepay.sol";
+
+// debuggging
+import {console} from "forge-std/console.sol";
+
+contract InteractPrepay is Interaction {
+    IPrepay prepay = IPrepay(0x0000000000000000000000000000000000000000);
+
+    function __interact(address deployer) internal override {
+        uint256 expectedAmount = 1000;
+        uint256 totalAmount = prepay.calculateMembershipPrepayFee(expectedAmount);
+
+        console.log("paying:", totalAmount);
+
+        vm.startBroadcast(deployer);
+        IPrepay(prepay).prepayMembership{value: totalAmount}(expectedAmount);
+        vm.stopBroadcast();
+
+        console.log("prepaidSupply", prepay.prepaidMembershipSupply());
+    }
+}

package/scripts/interactions/InteractRegisterApp.s.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IAppRegistry} from "src/apps/facets/registry/IAppRegistry.sol";
+
+//contracts
+import {Interaction} from "../common/Interaction.s.sol";
+import {SimpleApp} from "src/apps/helpers/SimpleApp.sol";
+import {IAppRegistryBase} from "src/apps/facets/registry/IAppRegistry.sol";
+
+contract InteractRegisterApp is Interaction, IAppRegistryBase {
+    function __interact(address deployer) internal override {
+        address appRegistry = getDeployment("appRegistry");
+
+        // update with the bot public keys you want to register
+        address client = deployer; // update this with you public key bot address
+
+        // update with the permissions you want to set for the app
+        bytes32[] memory permissions = new bytes32[](1);
+        permissions[0] = bytes32("Read");
+
+        uint256 installPrice = 0.001 ether;
+        uint48 accessDuration = 365 days;
+
+        AppParams memory appData = AppParams({
+            name: "simple.app",
+            permissions: permissions,
+            client: client,
+            installPrice: installPrice,
+            accessDuration: accessDuration
+        });
+
+        vm.broadcast(deployer);
+        (address app, bytes32 appId) = IAppRegistry(appRegistry).createApp(appData);
+
+        saveApp("SimpleApp", appId, address(app));
+    }
+
+    function saveApp(string memory versionName, bytes32 appId, address contractAddr) internal {
+        if (!shouldSaveDeployments()) {
+            debug("(set SAVE_DEPLOYMENTS=1 to save deployments to file)");
+            return;
+        }
+
+        string memory networkDir = networkDirPath();
+
+        // create addresses directory
+        createDir(string.concat(networkDir, "/apps"));
+
+        // get deployment path
+        string memory path = string.concat(networkDir, "/apps/", versionName, ".json");
+
+        // save deployment
+        debug("saving deployment to: ", path);
+        string memory contractJson = vm.serializeAddress("apps", "address", contractAddr);
+        string memory appJson = vm.serializeBytes32("apps", "appId", appId);
+        vm.writeJson(contractJson, path);
+        vm.writeJson(appJson, path);
+    }
+}

package/scripts/interactions/InteractRiverAlpha.s.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+
+// libraries
+
+// contracts
+import {AlphaHelper} from "scripts/interactions/helpers/AlphaHelper.sol";
+
+import {DeployRiverRegistry} from "scripts/deployments/diamonds/DeployRiverRegistry.s.sol";
+
+contract InteractRiverAlpha is AlphaHelper {
+    DeployRiverRegistry deployRiverRegistry = new DeployRiverRegistry();
+
+    function __interact(address deployer) internal override {
+        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
+        address riverRegistry = getDeployment("riverRegistry");
+
+        removeRemoteFacets(deployer, riverRegistry);
+        FacetCut[] memory newCuts;
+
+        deployRiverRegistry.diamondInitParams(deployer);
+        newCuts = deployRiverRegistry.getCuts();
+
+        vm.broadcast(deployer);
+        IDiamondCut(riverRegistry).diamondCut(newCuts, address(0), "");
+    }
+}