@towns-protocol/contracts 0.0.455 → 1.0.2

package/src/factory/facets/create/CreateSpace.sol

@@ -99,4 +99,9 @@ contract CreateSpaceFacet is ICreateSpace, PausableBase, ReentrancyGuard, Create
         SpaceOptions memory spaceOptions = SpaceOptions({to: msg.sender});
         return _createSpaceWithPrepayFromLegacy(spaceInfo, spaceOptions);
     }
+
+    /// @inheritdoc ICreateSpace
+    function getProxyInitializer() external view returns (address) {
+        return _getProxyInitializer();
+    }
 }

package/src/factory/facets/create/CreateSpaceBase.sol

@@ -24,6 +24,7 @@ import {Validator} from "../../../utils/libraries/Validator.sol";
 import {PricingModulesBase} from "../architect/pricing/PricingModulesBase.sol";
 import {ArchitectStorage} from "../architect/ArchitectStorage.sol";
 import {ImplementationStorage} from "../architect/ImplementationStorage.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
 
 // contracts
 import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
@@ -33,16 +34,21 @@ import {SpaceProxyInitializer} from "../../../spaces/facets/proxy/SpaceProxyInit
 abstract contract CreateSpaceBase is IArchitectBase {
     using StringSet for StringSet.Set;
     using EnumerableSet for EnumerableSet.AddressSet;
+    using CustomRevert for bytes4;
 
     address internal constant EVERYONE_ADDRESS = address(1);
     string internal constant MINTER_ROLE = "Minter";
     bytes1 internal constant CHANNEL_PREFIX = 0x20;
 
+    bytes32 private constant PROXY_INITIALIZER_INIT_CODE_HASH =
+        keccak256(type(SpaceProxyInitializer).creationCode);
+    bytes32 private constant PROXY_INITIALIZER_SALT = 0;
+
     function _createSpaceWithPrepay(
         CreateSpace calldata space,
         SpaceOptions memory spaceOptions
     ) internal returns (address spaceAddress) {
-        if (msg.value > 0) revert Architect__UnexpectedETH();
+        if (msg.value > 0) Architect__UnexpectedETH.selector.revertWith();
         Validator.checkAddress(space.membership.settings.pricingModule);
         Validator.checkAddress(spaceOptions.to);
 
@@ -61,7 +67,7 @@ abstract contract CreateSpaceBase is IArchitectBase {
         CreateSpaceOld calldata space,
         SpaceOptions memory spaceOptions
     ) internal returns (address spaceAddress) {
-        if (msg.value > 0) revert Architect__UnexpectedETH();
+        if (msg.value > 0) Architect__UnexpectedETH.selector.revertWith();
         Validator.checkAddress(space.membership.settings.pricingModule);
         Validator.checkAddress(spaceOptions.to);
 
@@ -91,7 +97,7 @@ abstract contract CreateSpaceBase is IArchitectBase {
         ChannelInfo calldata channel,
         SpaceOptions memory spaceOptions
     ) private returns (address spaceAddress) {
-        ImplementationStorage.Layout storage ims = ImplementationStorage.layout();
+        ImplementationStorage.Layout storage ims = ImplementationStorage.getStorage();
 
         // get the token id of the next space
         uint256 spaceTokenId = ims.spaceOwnerToken.nextTokenId();
@@ -309,7 +315,7 @@ abstract contract CreateSpaceBase is IArchitectBase {
             ds.tokenIdBySpace[spaceAddress] = spaceTokenId;
         }
         // mint token to and transfer to Architect
-        ImplementationStorage.Layout storage ims = ImplementationStorage.layout();
+        ImplementationStorage.Layout storage ims = ImplementationStorage.getStorage();
         ims.spaceOwnerToken.mintSpace(
             metadata.name,
             metadata.uri,
@@ -334,23 +340,41 @@ abstract contract CreateSpaceBase is IArchitectBase {
 
     function _verifyPricingModule(address pricingModule) internal view {
         if (pricingModule == address(0) || !PricingModulesBase.isPricingModule(pricingModule)) {
-            revert Architect__InvalidPricingModule();
+            Architect__InvalidPricingModule.selector.revertWith();
         }
     }
 
+    /// @dev Returns the deterministic CREATE2 address of SpaceProxyInitializer
+    function _getProxyInitializer() internal view returns (address) {
+        return
+            Factory.calculateDeploymentAddress(
+                PROXY_INITIALIZER_INIT_CODE_HASH,
+                PROXY_INITIALIZER_SALT
+            );
+    }
+
+    /// @dev Deploys SpaceProxyInitializer via CREATE2 if not already deployed, returns its address
+    function _getOrDeployProxyInitializer() internal returns (address) {
+        address computed = _getProxyInitializer();
+
+        if (computed.code.length != 0) return computed;
+
+        return Factory.deploy(type(SpaceProxyInitializer).creationCode, PROXY_INITIALIZER_SALT);
+    }
+
     function _getSpaceDeploymentInfo(
         uint256 spaceTokenId,
         IMembershipBase.Membership calldata membershipSettings,
         SpaceOptions memory spaceOptions
-    ) internal view returns (bytes memory initCode, bytes32 salt) {
+    ) internal returns (bytes memory initCode, bytes32 salt) {
         _verifyPricingModule(membershipSettings.pricingModule);
 
-        address spaceOwnerNFT = address(ImplementationStorage.layout().spaceOwnerToken);
+        address spaceOwnerNFT = address(ImplementationStorage.getStorage().spaceOwnerToken);
 
         // calculate salt
         salt = keccak256(abi.encode(spaceTokenId, block.timestamp, block.number, spaceOwnerNFT));
 
-        address proxyInitializer = address(ImplementationStorage.layout().proxyInitializer);
+        address proxyInitializer = _getOrDeployProxyInitializer();
 
         // calculate init code
         initCode = bytes.concat(

package/src/factory/facets/create/ICreateSpace.sol

@@ -67,4 +67,9 @@ interface ICreateSpace is IArchitectBase, ICreateSpaceBase {
     function createSpaceWithPrepay(
         CreateSpaceOld calldata spaceInfo
     ) external payable returns (address);
+
+    /// @notice Returns the address of the SpaceProxyInitializer contract
+    /// @return The deterministic CREATE2 address of the SpaceProxyInitializer
+    /// @dev The initializer is deployed on first space creation if not already deployed
+    function getProxyInitializer() external view returns (address);
 }

package/src/factory/facets/fee/FeeManagerFacet.sol

@@ -135,5 +135,15 @@ contract FeeManagerFacet is
             0.0005 ether,
             true
         );
+
+        // domain registration fee
+        _setFeeConfig(
+            FeeTypesLib.DOMAIN_REGISTRATION,
+            protocolRecipient,
+            FeeCalculationMethod.FIXED,
+            0,
+            0,
+            true
+        );
     }
 }

package/src/factory/facets/fee/FeeTypesLib.sol

@@ -26,6 +26,9 @@ library FeeTypesLib {
     /// @notice Fee for bot actions
     bytes32 internal constant BOT_ACTION = keccak256("FEE_TYPE.BOT_ACTION");
 
+    /// @notice Fee for domain registration
+    bytes32 internal constant DOMAIN_REGISTRATION = keccak256("FEE_TYPE.DOMAIN_REGISTRATION");
+
     /// @notice Generates fee type for membership based on currency
     /// @param currency The payment currency address
     /// @return The fee type identifier for the given currency

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

@@ -19,6 +19,7 @@ interface INodeRegistryBase {
     event NodeStatusUpdated(address indexed nodeAddress, NodeStatus status);
     event NodeUrlUpdated(address indexed nodeAddress, string url);
     event NodeRemoved(address indexed nodeAddress);
+    event NodeCometBftPubKeyUpdated(address indexed nodeAddress, bytes32 cometBftPubKey);
 }
 
 interface INodeRegistry is INodeRegistryBase {
@@ -66,4 +67,28 @@ interface INodeRegistry is INodeRegistryBase {
      * a block.
      */
     function getAllNodes() external view returns (Node[] memory);
+
+    /**
+     * @notice Backfill permanent indices for all existing nodes that don't have one assigned.
+     * @dev This should be called once after the contract upgrade. It assigns sequential indices
+     * starting from 1 to all nodes in their current array order. Subsequent registrations will
+     * continue from the last assigned index.
+     * Function can only be called once and reverts with ALREADY_EXISTS on subsequent calls.
+     */
+    function backfillPermanentIndices() external;
+
+    /**
+     * @notice Set or update the CometBFT public key for a node.
+     * @dev Can only be called by the node itself.
+     * @param nodeAddress The address of the node to update
+     * @param cometBftPubKey The 32-byte CometBFT public key
+     */
+    function setNodeCometBftPubKey(address nodeAddress, bytes32 cometBftPubKey) external;
+
+    /**
+     * @notice Get the last assigned permanent node index.
+     * @dev Returns 0 if backfill has not been called yet.
+     * @return The last assigned permanent node index
+     */
+    function getLastNodeIndex() external view returns (uint32);
 }

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

@@ -12,9 +12,10 @@ import {RiverRegistryErrors} from "src/river/registry/libraries/RegistryErrors.s
 import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
 
 // contracts
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
 import {RegistryModifiers} from "src/river/registry/libraries/RegistryStorage.sol";
 
-contract NodeRegistry is INodeRegistry, RegistryModifiers {
+contract NodeRegistry is INodeRegistry, RegistryModifiers, OwnableBase {
     using EnumerableSet for EnumerableSet.AddressSet;
     using CustomRevert for string;
 
@@ -32,16 +33,25 @@ contract NodeRegistry is INodeRegistry, RegistryModifiers {
             RiverRegistryErrors.ALREADY_EXISTS.revertWith();
         }
 
+        // Assign permanent index if backfill has been called (lastNodeIndex > 0)
+        uint32 permanentIndex = 0;
+        if (ds.lastNodeIndex > 0) {
+            permanentIndex = ++ds.lastNodeIndex;
+        }
+
         Node memory newNode = Node({
             nodeAddress: nodeAddress,
             url: url,
             status: status,
-            operator: msg.sender
+            operator: msg.sender,
+            permanentIndex: permanentIndex,
+            cometBftPubKey: bytes32(0)
         });
 
         ds.nodes.add(nodeAddress); // TODO: remove this line
         ds.nodeByAddress[nodeAddress] = newNode;
 
+        // TODO: Consider adding permanentIndex to the event
         emit NodeAdded(nodeAddress, msg.sender, url, status);
     }
 
@@ -123,6 +133,47 @@ contract NodeRegistry is INodeRegistry, RegistryModifiers {
         return nodes;
     }
 
+    function backfillPermanentIndices() external onlyOwner {
+        // Can only be called once - after execution, lastNodeIndex > 0
+        if (ds.lastNodeIndex > 0) {
+            RiverRegistryErrors.ALREADY_EXISTS.revertWith();
+        }
+
+        address[] memory nodeAddresses = ds.nodes.values();
+        uint32 currentIndex;
+
+        for (uint256 i; i < nodeAddresses.length; ++i) {
+            Node storage node = ds.nodeByAddress[nodeAddresses[i]];
+
+            if (node.permanentIndex != 0) {
+                RiverRegistryErrors.BAD_ARG.revertWith();
+            }
+
+            node.permanentIndex = ++currentIndex;
+        }
+
+        ds.lastNodeIndex = currentIndex;
+    }
+
+    function setNodeCometBftPubKey(
+        address nodeAddress,
+        bytes32 cometBftPubKey
+    ) external onlyNode(nodeAddress) {
+        // Only the node itself can set its CometBFT public key
+        if (msg.sender != nodeAddress) {
+            RiverRegistryErrors.BAD_AUTH.revertWith();
+        }
+
+        Node storage node = ds.nodeByAddress[nodeAddress];
+        node.cometBftPubKey = cometBftPubKey;
+
+        emit NodeCometBftPubKeyUpdated(nodeAddress, cometBftPubKey);
+    }
+
+    function getLastNodeIndex() external view returns (uint32) {
+        return ds.lastNodeIndex;
+    }
+
     function _checkNodeStatusTransionAllowed(NodeStatus from, NodeStatus to) internal pure {
         if (
             from == NodeStatus.NotInitialized ||

package/src/river/registry/libraries/RegistryStorage.sol

@@ -49,6 +49,8 @@ struct Node {
     string url; // dynamically sized, points to a separate location
     address nodeAddress; // 20 bytes
     address operator; // 20 bytes
+    uint32 permanentIndex; // 4 bytes, permanent index assigned to this node. 0 = not initialized
+    bytes32 cometBftPubKey; // 32 bytes, CometBFT public key for consensus
 }
 
 /**
@@ -88,6 +90,9 @@ struct AppStorage {
     uint256 deprecatedSlot;
     // Map of node address to its stream ids
     mapping(address => EnumerableSet.Bytes32Set) streamIdsByNode;
+    // Last assigned permanent node index. Used to assign unique indices to new nodes.
+    // 0 means backfill has not been called yet; after backfill, this tracks the highest assigned index.
+    uint32 lastNodeIndex;
 }
 
 library RiverRegistryStorage {

package/src/spaces/facets/ProtocolFeeLib.sol

@@ -23,6 +23,27 @@ library ProtocolFeeLib {
         address currency,
         uint256 amount,
         uint256 expectedFee
+    ) internal returns (uint256 protocolFee) {
+        return charge(spaceFactory, feeType, user, currency, amount, expectedFee, "");
+    }
+
+    /// @notice Charges protocol fee via FeeManager with ERC20 approval handling and extra data
+    /// @param spaceFactory The FeeManager address
+    /// @param feeType The type of fee being charged
+    /// @param user The user paying the fee
+    /// @param currency The payment currency (NATIVE_TOKEN or ERC20)
+    /// @param amount The base amount for fee calculation
+    /// @param expectedFee The pre-calculated expected fee
+    /// @param extraData Additional data for fee calculation (e.g., label length for domain registration)
+    /// @return protocolFee The actual fee charged
+    function charge(
+        address spaceFactory,
+        bytes32 feeType,
+        address user,
+        address currency,
+        uint256 amount,
+        uint256 expectedFee,
+        bytes memory extraData
     ) internal returns (uint256 protocolFee) {
         if (expectedFee == 0) return 0;
 
@@ -35,9 +56,43 @@ library ProtocolFeeLib {
             amount,
             currency,
             expectedFee,
-            ""
+            extraData
         );
 
         if (!isNative) currency.safeApprove(spaceFactory, 0);
     }
+
+    /// @notice Charges protocol fee via FeeManager, always calling chargeFee even when expectedFee is 0
+    /// @dev Use this when the fee hook needs to track calls regardless of fee amount (e.g., domain registration count)
+    /// @param spaceFactory The FeeManager address
+    /// @param feeType The type of fee being charged
+    /// @param user The user paying the fee
+    /// @param currency The payment currency (NATIVE_TOKEN or ERC20)
+    /// @param amount The base amount for fee calculation
+    /// @param expectedFee The pre-calculated expected fee
+    /// @param extraData Additional data for fee calculation
+    /// @return protocolFee The actual fee charged
+    function chargeAlways(
+        address spaceFactory,
+        bytes32 feeType,
+        address user,
+        address currency,
+        uint256 amount,
+        uint256 expectedFee,
+        bytes memory extraData
+    ) internal returns (uint256 protocolFee) {
+        bool isNative = currency == CurrencyTransfer.NATIVE_TOKEN;
+        if (!isNative && expectedFee > 0) currency.safeApproveWithRetry(spaceFactory, expectedFee);
+
+        protocolFee = IFeeManager(spaceFactory).chargeFee{value: isNative ? expectedFee : 0}(
+            feeType,
+            user,
+            amount,
+            currency,
+            expectedFee,
+            extraData
+        );
+
+        if (!isNative && expectedFee > 0) currency.safeApprove(spaceFactory, 0);
+    }
 }

package/src/spaces/facets/proxy/SpaceProxyInitializer.sol

@@ -2,22 +2,20 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-
 import {IERC173} from "@towns-protocol/diamond/src/facets/ownable/IERC173.sol";
-import {IERC5643} from "src/diamond/facets/token/ERC5643/IERC5643.sol";
-import {IMembership} from "src/spaces/facets/membership/IMembership.sol";
-import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+import {IERC5643} from "../../../diamond/facets/token/ERC5643/IERC5643.sol";
+import {IMembership} from "../membership/IMembership.sol";
+import {ISpaceProxyInitializer} from "./ISpaceProxyInitializer.sol";
 
 // libraries
 
 // contracts
-
 import {Initializable} from "@towns-protocol/diamond/src/facets/initializable/Initializable.sol";
 import {IntrospectionBase} from "@towns-protocol/diamond/src/facets/introspection/IntrospectionBase.sol";
 import {TokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/TokenOwnableBase.sol";
-import {ERC721ABase} from "src/diamond/facets/token/ERC721A/ERC721ABase.sol";
-import {EntitlementGatedBase} from "src/spaces/facets/gated/EntitlementGatedBase.sol";
-import {MembershipBase} from "src/spaces/facets/membership/MembershipBase.sol";
+import {ERC721ABase} from "../../../diamond/facets/token/ERC721A/ERC721ABase.sol";
+import {EntitlementGatedBase} from "../gated/EntitlementGatedBase.sol";
+import {MembershipBase} from "../membership/MembershipBase.sol";
 
 contract SpaceProxyInitializer is
     ISpaceProxyInitializer,

package/src/spaces/facets/xchain/SpaceEntitlementGated.sol

@@ -29,6 +29,15 @@ contract SpaceEntitlementGated is MembershipJoin, EntitlementGated {
         );
 
         if (result == NodeVoteStatus.PASSED) {
+            // Re-validate supply cap before minting to prevent over-minting from
+            // concurrent crosschain join requests that were all accepted when under
+            // the cap but would exceed it if all finalized
+            uint256 membershipSupplyLimit = _getMembershipSupplyLimit();
+            if (membershipSupplyLimit != 0 && _totalSupply() >= membershipSupplyLimit) {
+                _rejectMembership(transactionId, receiver);
+                return;
+            }
+
             PricingDetails memory joinDetails = _getPricingDetails();
 
             if (!joinDetails.shouldCharge) {

package/LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 River Association
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/scripts/bytecode-diff/README.md

@@ -1,182 +0,0 @@
-# Bytecode-Diff Tool
-
-Bytecode-Diff is a tool to retrieve and display contract bytecode diff for Base deployed contracts and Solidity source compiled bytecode compiled with forge. It provides functionality to run source code diffs or remote bytecode diffs and create reports that detail changes between two compiled bytecode versions of contracts.
-
-## Prerequisites
-
-- Go 1.22 or later
-- Base RPC Provider URL
-- River Chain RPC Provider URL
-- Basescan API Key
-
-## Usage
-
-### Local Source Code Diff
-
-Compile contracts with forge and run source code diff comparing nearest commit report with checked out commit.
-
-The basic command structure is:
-
-```bash
-# ensure contracts are compiled with forge
-cd ../../packages/contracts
-make build
-# disable go.work file since bytecode-diff is not a module in parent go workspace
-go mod download
-# run source diff from checked out commitSha compared nearest commit with a source diff report in SOURCE_DIFF_DIR
-GOWORK=off go run main.go -v -s
-
-# write report with contract addresses, their keccak256 compilaed bytecode hash under two keys, existing and updated.
-➜  bytecode-diff ✗ yq eval '.existing' source-diffs/00adc44f_08292024_5.yaml
-Architect: 0xd291e489716f2c9cfc2e2c6047ce777159969943c85d09c51aaf7bbad10f7c13
-ArchitectBase: 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
-ArchitectStorage: 0x86159d997458669c4df8af2da4b5ce9ca742099a3f854c5eb3e718e16a74e4da
-Banning: 0xde1354882fd30088cce4b00ff720a6dbc8c9f25653477c6ee99e20e17edb6068
-BanningBase: 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
-BanningStorage: 0x86159d997458669c4df8af2da4b5ce9ca742099a3f854c5eb3e718e16a74e4da
-ChannelBase: 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
-...
-```
-
-### Run pairwise remote bytecode diff on facets deployed to two networks
-
-Runs bytecode diff from deployed facets for diamonds in alpha, beta, and omega environments as per source coordinates of diamonds for each environment.
-
-```bash
-# compare omega against beta facets and facet selectors
-GOWORK=off go run ./main.go beta omega -v
-
-# output facet implementation changes by facet or selectors that are missing from omega
-➜  bytecode-diff git:(jt/net-62-contract-differ) ✗ yq eval deployed-diffs/facet_diff_090324_18.yaml
-diamonds:
-  - name: spaceOwner
-    source: beta
-    target: omega
-    facets:
-      - sourceContractName: ""
-        sourceFacetAddress: 0xfa98a1648761e494fc7d6efe5a06e357a76bd6fb
-        selectorsDiff:
-          - "0x3953801b"
-          - "0x91de4a83"
-        sourceBytecodeHash: 0xf86d9dbe53c89e14fa69cde925cca02b6efad519fe172f7b04d9515d7700a59b
-        sourceVerified: false
-        targetVerified: false
-      - sourceContractName: SpaceOwner
-        sourceFacetAddress: 0x30c912d8ceb9793e4cd240862acfd0e6c4436c52
-        targetContractAddresses:
-          - 0x63bC35259Ac32DF43Fba3b890F0F74951451976A
-          - 0xe7EB1313f0E7076616534225e16E971B72b50C42
-        selectorsDiff: []
-        sourceBytecodeHash: 0x461b53ab37fd24283ecd63eb0d4e71bd554a266036c73caf6d2ac39c435e7732
-        targetBytecodeHashes:
-          - 0x86d20161a13671a6138b80551e94dd8c1638bc5151807ff2194aa1e50cdb3cac
-          - 0xff0a94e93a4f4f6ee0ecd0d0e469e55ca40f1ab6c10e6af9da5b2b597f32b178
-        sourceVerified: true
-        targetVerified: true
-      - sourceContractName: ""
-        sourceFacetAddress: 0xdba2ce6125cc6b7f93c63d181a0780d5b421940b
-        selectorsDiff:
-          - "0x0d653654"
-          - "0x466a18de"
-        sourceBytecodeHash: 0x583c2852056f90c96ed1cab935489f644b8ef564e0a7f11564925d07cf3bc593
-        sourceVerified: false
-        targetVerified: false
-
-```
-
-### Run keccak256 hash generation on deployed contracts
-
-```bash
-GOWORK=off go run main.go add-hashes beta deployed-diffs/facet_diff_090624_1.yaml
-
-# output to new yaml file suffixed with _hashed.yaml including bytecodeHash for each contract in deployments section
-➜  bytecode-diff git:(jt/net-62-upgrade-script-2) ✗ yq e '.deployments' deployed-diffs/facet_diff_090624_1_hashed.yaml
-Architect:
-  address: 0xa18a3df4f63cdcae943d9c76730adf2812388de4
-  baseScanLink: https://sepolia.basescan.org/tx/0x4280ef1300fe001e7d85e7495eba13fc99be53ee7a7060e753d466f8bebf1622
-  bytecodeHash: 0x20d0a86e9ea31a39663285aacfe88705983520a4482a7bac5ada891c9adfe090
-  deploymentDate: 2024-09-06 19:04
-  transactionHash: 0x4280ef1300fe001e7d85e7495eba13fc99be53ee7a7060e753d466f8bebf1622
-Banning:
-  address: 0x4d88d1fbba6ce6bcdb4381549ee0b7c0d2b56919
-  baseScanLink: https://sepolia.basescan.org/tx/0x4ccbaf9750bcd0971975e73a24b05f1c51d4703cf72a406356c79eb54de9c33c
-  bytecodeHash: 0xa2ce3e77ba060ff1d59ed384e1c6c5788f308ad8bbbef612eb3e5de4e1d79de8
-  deploymentDate: 2024-09-06 19:05
-  transactionHash: 0x4ccbaf9750bcd0971975e73a24b05f1c51d4703cf72a406356c79eb54de9c33c
-...
-```
-
-### Flags
-
-```bash
-➜  bytecode-diff ✗ GOWORK=off go run ./main.go --help
-A tool to retrieve and display contract bytecode diff for Base
-
-Usage:
-  bytecode-diff [source_environment] [target_environment] [flags]
-
-Flags:
-  -b, --base-rpc string           Base RPC provider URL
-      --base-sepolia-rpc string   Base Sepolia RPC provider URL
-      --compiled-facets string    Path to compiled facets
-      --deployments string        Path to deployments directory (default "../../packages/contracts/deployments")
-      --facets string             Path to facet source files
-  -h, --help                      help for bytecode-diff
-      --log-level string          Set the logging level (debug, info, warn, error) (default "info")
-      --report-out-dir string     Path to report output directory (default "deployed-diffs")
-      --source-diff-log string    Path to diff log file (default "source-diffs")
-  -s, --source-diff-only          Run source code diff
-  -v, --verbose                   Enable verbose output
-```
-
-### Environment Variables
-
-You can also set the following environment variables instead of using flags:
-
-- `BASE_RPC_URL`: Base RPC provider URL
-- `BASE_SEPOLIA_RPC_URL`: Base Sepolia RPC provider URL
-- `FACET_SOURCE_PATH`: Path to facet source files
-- `ETHERSCAN_API_KEY`: Your API key for Etherscan.
-- `COMPILED_FACETS_PATH`: (Optional) Path to compiled facets
-- `DEPLOYMENTS_PATH`: (Optional) Path to deployed contracts
-- `REPORT_OUT_DIR`: (Optional) Path to report output directory
-- `SOURCE_DIFF_DIR`: (Optional) Path to source diff reports
-
-## Examples
-
-1. Run source code diff with all parameters specified via flags:
-
-```
-./bytecode-diff --source-diff-only \
-  --source-diff-dir /path/to/source-diff-reports \
-  --facets /path/to/facet/sources \
-  --compiled-facets /path/to/compiled/facets \
-  --report-out-dir /path/to/report/output \
-  --verbose
-```
-
-2. Run source code diff using environment variables:
-
-```bash
-export SOURCE_DIFF_DIR=/path/to/source_diff.log
-export FACET_SOURCE_PATH=/path/to/facet/sources
-export COMPILED_FACETS_PATH=/path/to/compiled/facets
-export REPORT_OUT_DIR=/path/to/report/output
-
-./bytecode-diff -s --verbose
-```
-
-3. Run source code diff with r/w to remote s3 bucket:
-
-```bash
-export AWS_ACCESS_KEY_ID=<your-access-key-id>
-export AWS_SECRET_ACCESS_KEY=<your-secret-access-key>
-export SOURCE_DIFF_DIR=s3://bucket/path
-./bytecode-diff -s --verbose
-```
-
-## Notes
-
-- If a `.env` file is present in the same directory as the script, it will be loaded automatically.
-- When running source code diff, all required paths must be provided either via flags or environment variables.
-- Use the `--verbose` flag for more detailed output during execution.

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

@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-// interfaces
-
-// libraries
-
-// contracts
-import {SpaceProxyInitializer} from "src/spaces/facets/proxy/SpaceProxyInitializer.sol";
-import {Deployer} from "scripts/common/Deployer.s.sol";
-
-contract DeploySpaceProxyInitializer is Deployer {
-    function versionName() public pure override returns (string memory) {
-        return "utils/spaceProxyInitializer";
-    }
-
-    function __deploy(address deployer) internal override returns (address) {
-        bytes32 salt = bytes32(uint256(1));
-        bytes32 initCodeHash = hashInitCode(type(SpaceProxyInitializer).creationCode);
-        address soonToBe = vm.computeCreate2Address(salt, initCodeHash);
-
-        vm.broadcast(deployer);
-        SpaceProxyInitializer initializer = new SpaceProxyInitializer{salt: salt}();
-
-        require(address(initializer) == soonToBe, "address mismatch");
-        return address(initializer);
-    }
-}