@towns-protocol/contracts 0.0.455 → 1.0.2

package/scripts/deployments/facets/DeployCreateSpace.s.sol

@@ -12,7 +12,7 @@ import {CreateSpaceFacet} from "src/factory/facets/create/CreateSpace.sol";
 
 library DeployCreateSpace {
     function selectors() internal pure returns (bytes4[] memory _selectors) {
-        _selectors = new bytes4[](5);
+        _selectors = new bytes4[](6);
         // createSpace(SpaceInfo) - Basic space creation with SpaceInfo struct
         _selectors[0] = 0xf822028d;
         // createSpaceWithPrepay(CreateSpace) - Space creation with prepay (new format)
@@ -23,6 +23,7 @@ library DeployCreateSpace {
         _selectors[3] = CreateSpaceFacet.createSpaceV2.selector;
         // createSpace(Action, bytes) - Unified entry point with action dispatch
         _selectors[4] = bytes4(keccak256("createSpace(uint8,bytes)"));
+        _selectors[5] = CreateSpaceFacet.getProxyInitializer.selector;
     }
 
     function makeCut(

package/scripts/deployments/facets/{DeploySpaceFactoryInit.s.sol → DeployExtendedResolverFacet.s.sol}

@@ -1,5 +1,5 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
 
 // interfaces
 import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
@@ -8,12 +8,12 @@ import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
 import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
 
 // contracts
-import {SpaceFactoryInit} from "src/factory/SpaceFactoryInit.sol";
+import {ExtendedResolverFacet} from "src/domains/facets/l2/ExtendedResolverFacet.sol";
 
-library DeploySpaceFactoryInit {
-    function selectors() internal pure returns (bytes4[] memory _selectors) {
-        _selectors = new bytes4[](1);
-        _selectors[0] = SpaceFactoryInit.initialize.selector;
+library DeployExtendedResolverFacet {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](1);
+        res[0] = ExtendedResolverFacet.resolve.selector;
     }
 
     function makeCut(
@@ -23,11 +23,11 @@ library DeploySpaceFactoryInit {
         return IDiamond.FacetCut(facetAddress, action, selectors());
     }
 
-    function makeInitData(address _proxyInitializer) internal pure returns (bytes memory) {
-        return abi.encodeCall(SpaceFactoryInit.initialize, (_proxyInitializer));
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(ExtendedResolverFacet.__ExtendedResolverFacet_init, ());
     }
 
     function deploy() internal returns (address) {
-        return LibDeploy.deployCode("SpaceFactoryInit.sol", "");
+        return LibDeploy.deployCode("ExtendedResolverFacet.sol", "");
     }
 }

package/scripts/deployments/facets/DeployL1ResolverFacet.s.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+// contracts
+import {L1ResolverFacet} from "src/domains/facets/l1/L1ResolverFacet.sol";
+
+library DeployL1ResolverFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(8);
+
+        // IExtendedResolver
+        arr.p(L1ResolverFacet.resolve.selector);
+
+        // CCIP-Read callback
+        arr.p(L1ResolverFacet.resolveWithProof.selector);
+
+        // Registry management
+        arr.p(L1ResolverFacet.setL2Registry.selector);
+        arr.p(L1ResolverFacet.getL2Registry.selector);
+
+        // Gateway URL configuration
+        arr.p(L1ResolverFacet.setGatewayURL.selector);
+        arr.p(L1ResolverFacet.getGatewayURL.selector);
+
+        // Gateway signer configuration
+        arr.p(L1ResolverFacet.setGatewaySigner.selector);
+        arr.p(L1ResolverFacet.getGatewaySigner.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(
+        string memory gatewayUrl,
+        address gatewaySigner
+    ) internal pure returns (bytes memory) {
+        return abi.encodeCall(L1ResolverFacet.__L1Resolver_init, (gatewayUrl, gatewaySigner));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("L1ResolverFacet.sol", "");
+    }
+}

package/scripts/deployments/facets/DeployL2RegistrarFacet.s.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+// contracts
+import {L2RegistrarFacet} from "src/domains/facets/registrar/L2RegistrarFacet.sol";
+
+library DeployL2RegistrarFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(10);
+
+        arr.p(L2RegistrarFacet.register.selector);
+        arr.p(L2RegistrarFacet.isAvailable.selector);
+        arr.p(L2RegistrarFacet.isValidLabel.selector);
+        arr.p(L2RegistrarFacet.getRegistry.selector);
+        arr.p(L2RegistrarFacet.getCoinType.selector);
+        arr.p(L2RegistrarFacet.getSpaceFactory.selector);
+        arr.p(L2RegistrarFacet.setSpaceFactory.selector);
+        arr.p(L2RegistrarFacet.setRegistry.selector);
+        arr.p(L2RegistrarFacet.setCurrency.selector);
+        arr.p(L2RegistrarFacet.getCurrency.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(
+        address registry,
+        address spaceFactory,
+        address currency
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encodeCall(L2RegistrarFacet.__L2Registrar_init, (registry, spaceFactory, currency));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("L2RegistrarFacet.sol", "");
+    }
+}

package/scripts/deployments/facets/DeployL2RegistryFacet.s.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+// contracts
+import {L2RegistryFacet} from "src/domains/facets/l2/L2RegistryFacet.sol";
+
+library DeployL2RegistryFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(24);
+
+        // Registry functions
+        arr.p(L2RegistryFacet.createSubdomain.selector);
+        arr.p(L2RegistryFacet.addRegistrar.selector);
+        arr.p(L2RegistryFacet.removeRegistrar.selector);
+        arr.p(L2RegistryFacet.setMetadata.selector);
+        arr.p(L2RegistryFacet.getMetadata.selector);
+        arr.p(L2RegistryFacet.domainOwner.selector);
+        arr.p(L2RegistryFacet.subdomainOwner.selector);
+        arr.p(L2RegistryFacet.baseDomainHash.selector);
+        arr.p(L2RegistryFacet.namehash.selector);
+        arr.p(L2RegistryFacet.decodeName.selector);
+        arr.p(L2RegistryFacet.encodeSubdomain.selector);
+
+        // ERC721 functions
+        arr.p(L2RegistryFacet.totalSupply.selector);
+        arr.p(L2RegistryFacet.balanceOf.selector);
+        arr.p(L2RegistryFacet.ownerOf.selector);
+        arr.p(L2RegistryFacet.transferFrom.selector);
+        arr.p(bytes4(keccak256("safeTransferFrom(address,address,uint256)")));
+        arr.p(bytes4(keccak256("safeTransferFrom(address,address,uint256,bytes)")));
+        arr.p(L2RegistryFacet.approve.selector);
+        arr.p(L2RegistryFacet.setApprovalForAll.selector);
+        arr.p(L2RegistryFacet.getApproved.selector);
+        arr.p(L2RegistryFacet.isApprovedForAll.selector);
+        arr.p(L2RegistryFacet.name.selector);
+        arr.p(L2RegistryFacet.symbol.selector);
+        arr.p(L2RegistryFacet.tokenURI.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(
+        string memory domain,
+        address admin
+    ) internal pure returns (bytes memory) {
+        return abi.encodeCall(L2RegistryFacet.__L2RegistryFacet_init, (domain, admin));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("L2RegistryFacet.sol", "");
+    }
+}

package/scripts/deployments/facets/DeployNodeRegistry.s.sol

@@ -12,7 +12,7 @@ import {NodeRegistry} from "src/river/registry/facets/node/NodeRegistry.sol";
 
 library DeployNodeRegistry {
     function selectors() internal pure returns (bytes4[] memory res) {
-        res = new bytes4[](9);
+        res = new bytes4[](12);
         res[0] = NodeRegistry.isNode.selector;
         res[1] = NodeRegistry.registerNode.selector;
         res[2] = NodeRegistry.removeNode.selector;
@@ -22,6 +22,9 @@ library DeployNodeRegistry {
         res[6] = NodeRegistry.getNodeCount.selector;
         res[7] = NodeRegistry.getAllNodeAddresses.selector;
         res[8] = NodeRegistry.getAllNodes.selector;
+        res[9] = NodeRegistry.backfillPermanentIndices.selector;
+        res[10] = NodeRegistry.setNodeCometBftPubKey.selector;
+        res[11] = NodeRegistry.getLastNodeIndex.selector;
     }
 
     function makeCut(

package/scripts/deployments/facets/DeployTextResolverFacet.s.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+// contracts
+import {TextResolverFacet} from "src/domains/facets/l2/TextResolverFacet.sol";
+
+library DeployTextResolverFacet {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](2);
+        res[0] = TextResolverFacet.setText.selector;
+        res[1] = TextResolverFacet.text.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(TextResolverFacet.__TextResolverFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("TextResolverFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {Deployer} from "../../common/Deployer.s.sol";
+import {DomainFeeHook} from "src/domains/hooks/DomainFeeHook.sol";
+
+contract DeployDomainFeeHook is Deployer {
+    /// @dev Default price for domain registration (5 USDC with 6 decimals)
+    uint256 internal constant DEFAULT_PRICE = 5e6;
+
+    address internal owner;
+    address internal feeManager;
+    uint256 internal defaultPrice;
+
+    function versionName() public pure override returns (string memory) {
+        return "utils/domainFeeHook";
+    }
+
+    /// @notice Set the owner address
+    /// @param owner_ The owner address for the DomainFeeHook
+    function setOwner(address owner_) external {
+        owner = owner_;
+    }
+
+    /// @notice Set the fee manager address
+    /// @param feeManager_ The fee manager address authorized to call onChargeFee
+    function setFeeManager(address feeManager_) external {
+        feeManager = feeManager_;
+    }
+
+    /// @notice Set the default price for registrations
+    /// @param defaultPrice_ The default price in USDC (6 decimals)
+    function setDefaultPrice(uint256 defaultPrice_) external {
+        defaultPrice = defaultPrice_;
+    }
+
+    /// @notice Set all deployment parameters at once
+    /// @param owner_ The owner address
+    /// @param feeManager_ The fee manager address
+    /// @param defaultPrice_ The default price for registrations
+    function setParams(address owner_, address feeManager_, uint256 defaultPrice_) external {
+        owner = owner_;
+        feeManager = feeManager_;
+        defaultPrice = defaultPrice_;
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        address ownerAddr = _getOwner(deployer);
+        address feeManagerAddr = _getFeeManager();
+        uint256 price = _getDefaultPrice();
+
+        require(ownerAddr != address(0), "DeployDomainFeeHook: owner not set");
+        require(feeManagerAddr != address(0), "DeployDomainFeeHook: feeManager not set");
+
+        vm.broadcast(deployer);
+        return address(new DomainFeeHook(ownerAddr, feeManagerAddr, price));
+    }
+
+    function _getOwner(address deployer) internal view returns (address) {
+        return owner == address(0) ? deployer : owner;
+    }
+
+    function _getFeeManager() internal returns (address) {
+        if (feeManager != address(0)) return feeManager;
+
+        // Try to get from existing deployments (spaceFactory acts as fee manager)
+        return getDeployment("spaceFactory");
+    }
+
+    function _getDefaultPrice() internal view returns (uint256) {
+        return defaultPrice == 0 ? DEFAULT_PRICE : defaultPrice;
+    }
+}

package/scripts/interactions/InteractAlphaPost.s.sol

@@ -2,10 +2,7 @@
 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";
@@ -19,13 +16,9 @@ contract InteractAlphaPost is Interaction {
     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/InteractBaseAlpha.s.sol

@@ -37,20 +37,7 @@ contract InteractBaseAlpha is AlphaHelper {
 
         executeDiamondCutsWithLogging(deployer, space, "Space", deploySpace);
         executeDiamondCutsWithLogging(deployer, spaceOwner, "SpaceOwner", deploySpaceOwner);
-
-        deploySpaceFactory.diamondInitParams(deployer);
-        address spaceFactoryInit = deploySpaceFactory.spaceFactoryInit();
-        bytes memory initData = deploySpaceFactory.spaceFactoryInitData();
-        deploySpaceFactory.clearCuts();
-
-        executeDiamondCutsWithLogging(
-            deployer,
-            spaceFactory,
-            "SpaceFactory",
-            deploySpaceFactory,
-            spaceFactoryInit,
-            initData
-        );
+        executeDiamondCutsWithLogging(deployer, spaceFactory, "SpaceFactory", deploySpaceFactory);
 
         executeDiamondCutsWithLogging(deployer, baseRegistry, "BaseRegistry", deployBaseRegistry);
         executeDiamondCutsWithLogging(deployer, riverAirdrop, "RiverAirdrop", deployRiverAirdrop);

package/scripts/interactions/InteractDomainFee.s.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IFeeManager} from "src/factory/facets/fee/IFeeManager.sol";
+import {IPlatformRequirements} from "src/factory/facets/platform/requirements/IPlatformRequirements.sol";
+
+// libraries
+import {FeeTypesLib} from "src/factory/facets/fee/FeeTypesLib.sol";
+import {FeeCalculationMethod} from "src/factory/facets/fee/FeeManagerStorage.sol";
+import {console} from "forge-std/console.sol";
+
+// contracts
+import {Interaction} from "../common/Interaction.s.sol";
+
+/// @title InteractDomainFee
+/// @notice Interaction script to configure domain registration fee and hook
+contract InteractDomainFee is Interaction {
+    function __interact(address deployer) internal override {
+        address spaceFactory = getDeployment("spaceFactory");
+        address domainFeeHook = getDeployment("utils/domainFeeHook");
+
+        console.log("SpaceFactory Diamond:", spaceFactory);
+        console.log("Domain Fee Hook:", domainFeeHook);
+
+        // Get fee recipient from PlatformRequirementsFacet
+        address feeRecipient = IPlatformRequirements(spaceFactory).getFeeRecipient();
+        console.log("Fee Recipient:", feeRecipient);
+
+        // Set fee configuration for domain registration
+        // The hook will override the fee calculation, so we use FIXED with 0 values
+        console.log("\n=== Setting Fee Config for Domain Registration ===");
+        vm.broadcast(deployer);
+        IFeeManager(spaceFactory).setFeeConfig(
+            FeeTypesLib.DOMAIN_REGISTRATION,
+            feeRecipient, // recipient from PlatformRequirements
+            FeeCalculationMethod.FIXED, // method (hook overrides the calculation)
+            0, // bps (not used for FIXED)
+            0, // fixedFee (hook overrides)
+            true // enabled
+        );
+        console.log("Fee config set for DOMAIN_REGISTRATION");
+        console.log("  Recipient:", feeRecipient);
+        console.log("  Method: FIXED (hook overrides)");
+        console.log("  Enabled: true");
+
+        // Set the domain fee hook
+        console.log("\n=== Setting Domain Fee Hook ===");
+        vm.broadcast(deployer);
+        IFeeManager(spaceFactory).setFeeHook(FeeTypesLib.DOMAIN_REGISTRATION, domainFeeHook);
+        console.log("Fee hook set for DOMAIN_REGISTRATION:", domainFeeHook);
+
+        // Verify configuration
+        console.log("\n=== Verifying Configuration ===");
+        address configuredHook = IFeeManager(spaceFactory).getFeeHook(
+            FeeTypesLib.DOMAIN_REGISTRATION
+        );
+        console.log("Configured hook:", configuredHook);
+
+        console.log("\n=== Domain Fee Configuration Complete ===");
+    }
+}

package/scripts/interactions/InteractSetStreamDistributionBalancingAdvantage.s.sol

@@ -0,0 +1,42 @@
+// 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";
+
+/// @notice Sets the min and max balancing advantage for required operator node selection.
+/// @dev Values are in basis points (e.g., 500 = 5%, 750 = 7.5%).
+/// These settings control load balancing when selecting among required operator nodes:
+/// - MinBalancingAdvantage: Minimum advantage for less-loaded nodes (default: 500 = 5%)
+/// - MaxBalancingAdvantage: Maximum advantage for less-loaded nodes (default: 750 = 7.5%)
+contract InteractSetStreamDistributionBalancingAdvantage is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        // Values in basis points (100 = 1%, 500 = 5%, 750 = 7.5%)
+        uint64 minBalancingAdvantage = 500; // 5%
+        uint64 maxBalancingAdvantage = 750; // 7.5%
+
+        vm.startBroadcast(deployer);
+
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_DISTRIBUTION_MIN_BALANCING_ADVANTAGE,
+            0, // blockNumber: 0 means effective immediately
+            abi.encode(minBalancingAdvantage)
+        );
+
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_DISTRIBUTION_MAX_BALANCING_ADVANTAGE,
+            0, // blockNumber: 0 means effective immediately
+            abi.encode(maxBalancingAdvantage)
+        );
+
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractSetStreamDistributionRequiredOperators.s.sol

@@ -0,0 +1,32 @@
+// 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";
+
+/// @notice Sets the required operators for stream placement.
+/// @dev When placing a stream, at least one node from a required operator must be selected
+/// if any required operator has operational nodes available.
+contract InteractSetStreamDistributionRequiredOperators is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        // Configure the required operator addresses here
+        address[] memory requiredOperators = new address[](1);
+        requiredOperators[0] = address(0); // Replace with actual operator address
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_DISTRIBUTION_REQUIRED_OPERATORS,
+            0, // blockNumber: 0 means effective immediately
+            abi.encode(requiredOperators)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/helpers/RiverConfigValues.sol

@@ -24,4 +24,10 @@ library RiverConfigValues {
     bytes32 public constant STREAM_TRIM_ACTIVATION_FACTOR =
         keccak256("stream.trimactivationfactor");
     bytes32 public constant STREAM_TRIM_BY_STREAM_ID = keccak256("stream.trimbystreamid");
+    bytes32 public constant STREAM_DISTRIBUTION_REQUIRED_OPERATORS =
+        keccak256("stream.distribution.requiredoperators");
+    bytes32 public constant STREAM_DISTRIBUTION_MIN_BALANCING_ADVANTAGE =
+        keccak256("stream.distribution.minbalancingadvantage");
+    bytes32 public constant STREAM_DISTRIBUTION_MAX_BALANCING_ADVANTAGE =
+        keccak256("stream.distribution.maxbalancingadvantage");
 }

package/src/domains/facets/l1/IL1ResolverService.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+/// @notice Interface for the resolver service
+interface IL1ResolverService {
+    /// @notice Resolves a name on the L1 registry
+    /// @param name The name to resolve
+    /// @param data The data to resolve
+    /// @param targetChainId The chain ID of the target registry
+    /// @param targetRegistryAddress The address of the target registry
+    /// @return result The result of the resolve
+    /// @return expires The expiration time of the resolve
+    /// @return sig The signature of the resolve
+    function stuffedResolveCall(
+        bytes calldata name,
+        bytes calldata data,
+        uint64 targetChainId,
+        address targetRegistryAddress
+    ) external view returns (bytes memory result, uint64 expires, bytes memory sig);
+}