@towns-protocol/contracts 0.0.302

package/scripts/deployments/utils/DeployTownsMainnet.s.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+//interfaces
+import {ITownsBase} from "src/tokens/towns/mainnet/ITowns.sol";
+
+//libraries
+
+//contracts
+import {Deployer} from "scripts/common/Deployer.s.sol";
+import {Towns} from "src/tokens/towns/mainnet/Towns.sol";
+
+contract DeployTownsMainnet is Deployer, ITownsBase {
+    address public manager;
+    address public vault;
+
+    function inflationConfig(address _manager) public pure returns (InflationConfig memory) {
+        return
+            InflationConfig({
+                initialMintTime: 1_709_667_671, // Tuesday, March 5, 2024 7:41:11 PM
+                initialInflationRate: 800,
+                finalInflationRate: 200,
+                inflationDecayRate: 600,
+                finalInflationYears: 20,
+                inflationReceiver: _manager
+            });
+    }
+
+    function versionName() public pure override returns (string memory) {
+        return "townsMainnet";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        manager = _getManager();
+        vault = _getVault();
+        InflationConfig memory config = inflationConfig(manager);
+
+        vm.broadcast(deployer);
+        return address(new Towns({vault: vault, manager: manager, config: config}));
+    }
+
+    function _getVault() internal view returns (address) {
+        // Mainnet
+        if (block.chainid == 1) {
+            return address(0x23b168657744124360d3553F3bc257f3E28cBaf9);
+        } else if (block.chainid == 11_155_111) {
+            return address(0x23b168657744124360d3553F3bc257f3E28cBaf9);
+        } else if (block.chainid == 31_337 || block.chainid == 31_338) {
+            return address(0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266); // anvil deployer
+        } else {
+            revert("DeployTownsMainnet: Invalid network");
+        }
+    }
+
+    function _getManager() internal view returns (address) {
+        if (block.chainid == 1) {
+            return address(0x18038ee5692FCE1cc0B0b3F2D63e09639A597F94);
+        } else if (block.chainid == 11_155_111) {
+            return address(0x18038ee5692FCE1cc0B0b3F2D63e09639A597F94);
+        } else if (block.chainid == 31_337 || block.chainid == 31_338) {
+            return address(0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266); // anvil deployer
+        } else {
+            revert("DeployTownsMainnet: Invalid network");
+        }
+    }
+}

package/scripts/deployments/utils/DeployTownsMulti.s.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMessageLibManager} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLibManager.sol";
+
+// libraries
+import {LibLayerZeroValues} from "./LibLayerZeroValues.sol";
+import {Create2Utils} from "../../../src/utils/libraries/Create2Utils.sol";
+
+// contracts
+import {Towns} from "../../../src/tokens/towns/multichain/Towns.sol";
+import {Deployer} from "scripts/common/Deployer.s.sol";
+
+contract DeployTownsMulti is Deployer {
+    function versionName() public pure override returns (string memory) {
+        return "utils/townsBnb";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        address endpoint = LibLayerZeroValues.getEndpoint(block.chainid);
+        require(endpoint != address(0), "Endpoint not found");
+
+        IMessageLibManager libManager = IMessageLibManager(endpoint);
+
+        bytes memory initCode = abi.encodePacked(
+            type(Towns).creationCode,
+            abi.encode("Towns", "TOWNS", endpoint, deployer)
+        );
+
+        vm.startBroadcast(deployer);
+
+        // test salt, remove before deploying
+        bytes32 salt = keccak256(abi.encodePacked(block.chainid, deployer));
+        address towns = Create2Utils.create2Deploy(salt, initCode);
+
+        libManager.setSendLibrary(
+            address(towns),
+            LibLayerZeroValues.getEid(1), // Destination chain eid (Mainnet)
+            LibLayerZeroValues.getSendLib(block.chainid)
+        );
+
+        libManager.setReceiveLibrary(
+            address(towns),
+            LibLayerZeroValues.getEid(block.chainid), // Source chain eid
+            LibLayerZeroValues.getReceiveLib(block.chainid),
+            0
+        );
+
+        vm.stopBroadcast();
+        return address(towns);
+    }
+}

package/scripts/deployments/utils/DeployWrappedTowns.s.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMessageLibManager} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLibManager.sol";
+
+// libraries
+import {LibLayerZeroValues} from "./LibLayerZeroValues.sol";
+import {Create2Utils} from "../../../src/utils/libraries/Create2Utils.sol";
+
+// contracts
+import {wTowns} from "../../../src/tokens/towns/multichain/wTowns.sol";
+import {Deployer} from "scripts/common/Deployer.s.sol";
+
+contract DeployWrappedTowns is Deployer {
+    function versionName() public pure override returns (string memory) {
+        return "utils/wrapped-towns";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        address endpoint = LibLayerZeroValues.getEndpoint(block.chainid);
+
+        IMessageLibManager libManager = IMessageLibManager(endpoint);
+
+        vm.startBroadcast(deployer);
+
+        bytes memory initCode = abi.encodePacked(
+            type(wTowns).creationCode,
+            abi.encode(getDeployment("townsMainnet"), endpoint, deployer)
+        );
+
+        bytes32 salt = keccak256(abi.encodePacked(block.chainid, deployer));
+        address wrappedTowns = Create2Utils.create2Deploy(salt, initCode);
+
+        libManager.setSendLibrary(
+            wrappedTowns,
+            LibLayerZeroValues.getEid(56), // Destination chain eid (BNB Testnet)
+            LibLayerZeroValues.getSendLib(block.chainid)
+        );
+
+        libManager.setReceiveLibrary(
+            wrappedTowns,
+            LibLayerZeroValues.getEid(block.chainid), // Source chain eid
+            LibLayerZeroValues.getReceiveLib(block.chainid),
+            0
+        );
+
+        vm.stopBroadcast();
+
+        return wrappedTowns;
+    }
+}

package/scripts/deployments/utils/LibLayerZeroValues.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+library LibLayerZeroValues {
+    function getEndpoint(uint256 chainId) internal pure returns (address) {
+        if (chainId == 1) return 0x1a44076050125825900e736c501f859c50fE728c; // Mainnet
+        if (chainId == 56) return 0x1a44076050125825900e736c501f859c50fE728c; // Binance
+        return address(0);
+    }
+
+    function getDeployedToken(uint256 chainId) internal pure returns (address) {
+        if (chainId == 1) return 0x00000000Bc5Ff0261B97004a79c6D361002Ba2db; // wTowns
+        if (chainId == 56) return 0x00000000bcA93b25a6694ca3d2109d545988b13B; // townsBnb
+        return address(0);
+    }
+
+    function getEid(uint256 chainId) internal pure returns (uint32) {
+        if (chainId == 1) return 30101; // Mainnet
+        if (chainId == 56) return 30102; // Binance
+        return 0;
+    }
+
+    function getSendLib(uint256 chainId) internal pure returns (address) {
+        if (chainId == 1) return 0xbB2Ea70C9E858123480642Cf96acbcCE1372dCe1; // Mainnet
+        if (chainId == 56) return 0x9F8C645f2D0b2159767Bd6E0839DE4BE49e823DE; // Binance
+        return address(0);
+    }
+
+    function getReceiveLib(uint256 chainId) internal pure returns (address) {
+        if (chainId == 1) return 0xc02Ab410f0734EFa3F14628780e6e695156024C2; // Mainnet
+        if (chainId == 56) return 0xB217266c3A98C8B2709Ee26836C98cf12f6cCEC1; // Binance
+        return address(0);
+    }
+}

package/scripts/deployments/utils/pricing/TieredLogPricing.s.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+
+//libraries
+
+//contracts
+import {Deployer} from "scripts/common/Deployer.s.sol";
+import {MockAggregatorV3} from "test/mocks/MockAggregatorV3.sol";
+
+abstract contract TieredLogPricing is Deployer {
+    int256 public constant EXCHANGE_RATE = 222_616_000_000;
+
+    function _getOracleAddress() internal view returns (address) {
+        if (block.chainid == 8453) {
+            // Base
+            return 0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70;
+        } else if (block.chainid == 84_532) {
+            // Base (Sepolia)
+            return 0x4aDC67696bA383F43DD60A9e78F2C97Fbbfc7cb1;
+        } else {
+            revert("DeployTieredLogPricing: Invalid network");
+        }
+    }
+
+    function _setupLocalOracle(address deployer) internal returns (address) {
+        vm.startBroadcast(deployer);
+        MockAggregatorV3 oracle = new MockAggregatorV3({
+            _decimals: 8,
+            _description: "ETH/USD",
+            _version: 1
+        });
+        oracle.setRoundData({
+            _roundId: 1,
+            _answer: EXCHANGE_RATE,
+            _startedAt: 0,
+            _updatedAt: block.timestamp,
+            _answeredInRound: 0
+        });
+        vm.stopBroadcast();
+
+        return address(oracle);
+    }
+}

package/scripts/interactions/InteractAirdrop.s.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+//libraries
+
+//contracts
+import {Interaction} from "../common/Interaction.s.sol";
+import {Airdrop} from "src/utils/Airdrop.sol";
+
+contract InteractAirdrop is Interaction {
+    struct Wallet {
+        address account;
+        uint256 amount;
+        string label;
+    }
+
+    struct InputData {
+        address airdrop;
+        address token;
+        Wallet[] wallets;
+    }
+
+    function __interact(address deployer) internal override {
+        // Read JSON file and parse wallet data
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, "/contracts/in/airdrop-input-data.json");
+
+        string memory json = vm.readFile(path);
+        bytes memory parsedJson = vm.parseJson(json);
+
+        InputData memory data = abi.decode(parsedJson, (InputData));
+
+        uint256 totalAccounts = data.wallets.length;
+
+        address[] memory addresses = new address[](totalAccounts);
+        uint256[] memory amounts = new uint256[](totalAccounts);
+
+        uint256 totalAmount = 0;
+        for (uint256 i = 0; i < totalAccounts; i++) {
+            addresses[i] = data.wallets[i].account;
+            amounts[i] = data.wallets[i].amount;
+            totalAmount += data.wallets[i].amount;
+        }
+
+        vm.startBroadcast(deployer);
+        IERC20(data.token).approve(data.airdrop, totalAmount);
+        Airdrop(data.airdrop).airdropERC20({
+            token: data.token,
+            addresses: addresses,
+            amounts: amounts,
+            totalAmount: totalAmount
+        });
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractAlphaPost.s.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IArchitect} from "src/factory/facets/architect/IArchitect.sol";
+
+import {IPricingModules} from "src/factory/facets/architect/pricing/IPricingModules.sol";
+import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+
+// deployment
+import {DeployTieredLogPricingV3} from "scripts/deployments/utils/DeployTieredLogPricingV3.s.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+contract InteractAlphaPost is Interaction {
+    DeployTieredLogPricingV3 deployTieredLogPricingV3 = new DeployTieredLogPricingV3();
+
+    function __interact(address deployer) internal override {
+        address spaceFactory = getDeployment("spaceFactory");
+
+        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
+        vm.broadcast(deployer);
+        address spaceProxyInitializer = deployCode("SpaceProxyInitializer.sol", "");
+        address tieredLogPricing = deployTieredLogPricingV3.deploy(deployer);
+
+        vm.startBroadcast(deployer);
+        IArchitect(spaceFactory).setProxyInitializer(ISpaceProxyInitializer(spaceProxyInitializer));
+        IPricingModules(spaceFactory).addPricingModule(tieredLogPricing);
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractAlphaSparse.s.sol

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+import {IDiamondInitHelper} from "../deployments/diamonds/IDiamondInitHelper.sol";
+
+import {DiamondHelper} from "@towns-protocol/diamond/scripts/common/helpers/DiamondHelper.s.sol";
+import {Diamond} from "@towns-protocol/diamond/src/Diamond.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 {DeployBaseRegistry} from "scripts/deployments/diamonds/DeployBaseRegistry.s.sol";
+
+import {DeployRiverAirdrop} from "scripts/deployments/diamonds/DeployRiverAirdrop.s.sol";
+import {DeploySpace} from "scripts/deployments/diamonds/DeploySpace.s.sol";
+import {DeploySpaceFactory} from "scripts/deployments/diamonds/DeploySpaceFactory.s.sol";
+import {DeploySpaceOwner} from "scripts/deployments/diamonds/DeploySpaceOwner.s.sol";
+
+contract InteractAlphaSparse is AlphaHelper {
+    using stdJson for string;
+
+    mapping(string => address) private diamondDeployments;
+
+    constructor() {
+        // pause to avoid out of gas errors when deploying diamond helpers
+        vm.pauseGasMetering();
+
+        try new DeploySpaceOwner() returns (DeploySpaceOwner spaceOwner) {
+            diamondDeployments["spaceOwner"] = address(spaceOwner);
+            console.log("spaceOwner deployed to:", address(spaceOwner));
+        } catch Error(string memory reason) {
+            console.log("Failed to deploy SpaceOwner:", reason);
+        } catch (bytes memory) {
+            console.log("Failed to deploy SpaceOwner (low level error)");
+        }
+
+        try new DeploySpace() returns (DeploySpace space) {
+            diamondDeployments["space"] = address(space);
+            console.log("space deployed to:", address(space));
+        } catch Error(string memory reason) {
+            console.log("Failed to deploy Space:", reason);
+        } catch (bytes memory) {
+            console.log("Failed to deploy Space (low level error)");
+        }
+
+        try new DeploySpaceFactory() returns (DeploySpaceFactory spaceFactory) {
+            diamondDeployments["spaceFactory"] = address(spaceFactory);
+            console.log("spaceFactory deployed to:", address(spaceFactory));
+        } catch Error(string memory reason) {
+            console.log("Failed to deploy SpaceFactory:", reason);
+        } catch (bytes memory) {
+            console.log("Failed to deploy SpaceFactory (low level error)");
+        }
+
+        try new DeployBaseRegistry() returns (DeployBaseRegistry baseRegistry) {
+            diamondDeployments["baseRegistry"] = address(baseRegistry);
+            console.log("baseRegistry deployed to:", address(baseRegistry));
+        } catch Error(string memory reason) {
+            console.log("Failed to deploy BaseRegistry:", reason);
+        } catch (bytes memory) {
+            console.log("Failed to deploy BaseRegistry (low level error)");
+        }
+
+        try new DeployRiverAirdrop() returns (DeployRiverAirdrop riverAirdrop) {
+            diamondDeployments["riverAirdrop"] = address(riverAirdrop);
+            console.log("riverAirdrop deployed to:", address(riverAirdrop));
+        } catch Error(string memory reason) {
+            console.log("Failed to deploy RiverAirdrop:", reason);
+        } catch (bytes memory) {
+            console.log("Failed to deploy RiverAirdrop (low level error)");
+        }
+
+        vm.resumeGasMetering();
+    }
+
+    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();
+        console.log("interact::diamonds decoded", diamonds.length);
+
+        // 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);
+                newCuts = IDiamondInitHelper(diamondHelper).diamondInitHelper(deployer, facetNames);
+
+                vm.broadcast(deployer);
+                IDiamondCut(diamondDeployedAddress).diamondCut(newCuts, address(0), "");
+            }
+        }
+    }
+}

package/scripts/interactions/InteractBaseAlpha.s.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+
+// libraries
+
+// contracts
+import {DeployBaseRegistry} from "scripts/deployments/diamonds/DeployBaseRegistry.s.sol";
+import {DeployRiverAirdrop} from "scripts/deployments/diamonds/DeployRiverAirdrop.s.sol";
+import {DeploySpace} from "scripts/deployments/diamonds/DeploySpace.s.sol";
+import {DeploySpaceFactory} from "scripts/deployments/diamonds/DeploySpaceFactory.s.sol";
+import {DeploySpaceOwner} from "scripts/deployments/diamonds/DeploySpaceOwner.s.sol";
+import {AlphaHelper} from "scripts/interactions/helpers/AlphaHelper.sol";
+
+contract InteractBaseAlpha is AlphaHelper {
+    DeploySpace deploySpace = new DeploySpace();
+    DeploySpaceFactory deploySpaceFactory = new DeploySpaceFactory();
+    DeployBaseRegistry deployBaseRegistry = new DeployBaseRegistry();
+    DeploySpaceOwner deploySpaceOwner = new DeploySpaceOwner();
+    DeployRiverAirdrop deployRiverAirdrop = new DeployRiverAirdrop();
+
+    function __interact(address deployer) internal override {
+        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
+        address space = getDeployment("space");
+        address spaceOwner = getDeployment("spaceOwner");
+        address spaceFactory = getDeployment("spaceFactory");
+        address baseRegistry = getDeployment("baseRegistry");
+        address riverAirdrop = getDeployment("riverAirdrop");
+
+        vm.pauseGasMetering();
+        removeRemoteFacets(deployer, space);
+        removeRemoteFacets(deployer, spaceOwner);
+        removeRemoteFacets(deployer, spaceFactory);
+        removeRemoteFacets(deployer, baseRegistry);
+        removeRemoteFacets(deployer, riverAirdrop);
+
+        deploySpaceCuts(deployer, space);
+        deploySpaceOwnerCuts(deployer, spaceOwner);
+        deploySpaceFactoryCuts(deployer, spaceFactory);
+        deployBaseRegistryCuts(deployer, baseRegistry);
+        deployRiverAirdropCuts(deployer, riverAirdrop);
+
+        vm.resumeGasMetering();
+    }
+
+    function deploySpaceCuts(address deployer, address space) internal {
+        deploySpace.diamondInitParams(deployer);
+        FacetCut[] memory newCuts = deploySpace.getCuts();
+        vm.broadcast(deployer);
+        IDiamondCut(space).diamondCut(newCuts, address(0), "");
+    }
+
+    function deploySpaceOwnerCuts(address deployer, address spaceOwner) internal {
+        deploySpaceOwner.diamondInitParams(deployer);
+        FacetCut[] memory newCuts = deploySpaceOwner.getCuts();
+        vm.broadcast(deployer);
+        IDiamondCut(spaceOwner).diamondCut(newCuts, address(0), "");
+    }
+
+    function deploySpaceFactoryCuts(address deployer, address spaceFactory) internal {
+        deploySpaceFactory.diamondInitParams(deployer);
+        FacetCut[] memory newCuts = deploySpaceFactory.getCuts();
+        address spaceFactoryInit = deploySpaceFactory.spaceFactoryInit();
+        bytes memory initData = deploySpaceFactory.spaceFactoryInitData();
+        vm.broadcast(deployer);
+        IDiamondCut(spaceFactory).diamondCut(newCuts, spaceFactoryInit, initData);
+    }
+
+    function deployBaseRegistryCuts(address deployer, address baseRegistry) internal {
+        deployBaseRegistry.diamondInitParams(deployer);
+        FacetCut[] memory newCuts = deployBaseRegistry.getCuts();
+        vm.broadcast(deployer);
+        IDiamondCut(baseRegistry).diamondCut(newCuts, address(0), "");
+    }
+
+    function deployRiverAirdropCuts(address deployer, address riverAirdrop) internal {
+        deployRiverAirdrop.diamondInitParams(deployer);
+        FacetCut[] memory newCuts = deployRiverAirdrop.getCuts();
+        vm.broadcast(deployer);
+        IDiamondCut(riverAirdrop).diamondCut(newCuts, address(0), "");
+    }
+}

package/scripts/interactions/InteractBaseBridge.s.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+
+import {IL1StandardBridge} from "./interfaces/IL1StandardBridge.sol";
+import {IL2StandardBridge} from "./interfaces/IL2StandardBridge.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+//libraries
+
+//contracts
+import {Interaction} from "../common/Interaction.s.sol";
+
+contract InteractBaseBridge is Interaction {
+    address l1StandardBridge = 0xfd0Bf71F60660E2f608ed56e1659C450eB113120;
+    address l2StandardBridge = 0x4200000000000000000000000000000000000010;
+
+    address townsOnSepolia = 0x000000Fa00b200406de700041CFc6b19BbFB4d13;
+    address townsOnBaseSepolia = 0x00000000A22C618fd6b4D7E9A335C4B96B189a38;
+    uint256 tokensToDeposit = 10 ether;
+
+    function __interact(address deployer) internal override {
+        // Bridge from Base Sepolia to Sepolia
+        // vm.startBroadcast(deployer);
+        // IERC20(townsOnBaseSepolia).approve(l2StandardBridge, tokensToDeposit);
+        // IL2StandardBridge(l2StandardBridge).bridgeERC20({
+        //   _localToken: townsOnBaseSepolia,
+        //   _remoteToken: townsOnSepolia,
+        //   _amount: tokensToDeposit,
+        //   _minGasLimit: 100000,
+        //   _extraData: ""
+        // });
+        // vm.stopBroadcast();
+
+        // Bridge from Sepolia to Base Sepolia
+        vm.startBroadcast(deployer);
+        IERC20(townsOnSepolia).approve(l1StandardBridge, tokensToDeposit);
+        IL1StandardBridge(l1StandardBridge).depositERC20({
+            _l1Token: townsOnSepolia,
+            _l2Token: townsOnBaseSepolia,
+            _amount: tokensToDeposit,
+            _minGasLimit: 100_000,
+            _extraData: ""
+        });
+        vm.stopBroadcast();
+    }
+}