Subnet registry to deploy upgradeable subnet actors

contracts/Makefile

@@ -20,7 +20,7 @@ upgrade-gw-diamond:
 	./ops/upgrade-gw-diamond.sh $(NETWORK)
 
 upgrade-sa-diamond:
-	./ops/upgrade-sa-diamond.sh $(NETWORK)
+	./ops/upgrade-sa-diamond.sh $(NETWORK) $(SUBNET_ACTOR_ADDRESS)
 
 upgrade-sr-diamond:
 	./ops/upgrade-sr-diamond.sh $(NETWORK)

contracts/hardhat.config.ts

@@ -291,14 +291,24 @@ task(
     async (args, hre: HardhatRuntimeEnvironment) => {
         await hre.run('compile')
         const network = hre.network.name
-        const deployments = await getSubnetActor(network)
+        if (!args.address) {
+            console.error(
+                'No address provided. Usage: npx hardhat upgrade-sa-diamond --address 0x80afa...',
+            )
+            process.exit(1)
+        }
+        const subnetRegistry = await getSubnetRegistry(network)
+        console.log(subnetRegistry)
+        const deployments = { SubnetActorDiamond: args.address , Facets: subnetRegistry.SubnetActorFacets }
+        console.log(deployments);
+
         const { upgradeDiamond } = await lazyImport(
             './scripts/upgrade-sa-diamond',
         )
         const updatedFacets = await upgradeDiamond(deployments)
         await saveDeploymentsFacets('subnet.actor.json', network, updatedFacets)
     },
-)
+).addParam('address', 'The address to upgrade', undefined, types.string, false)
 
 /** @type import('hardhat/config').HardhatUserConfig */
 const config: HardhatUserConfig = {

contracts/ops/upgrade-gw-diamond.sh

@@ -9,12 +9,12 @@ then
     exit 1
 fi
 
-NETWORK=$1
+NETWORK="$1"
 
 if [ "$NETWORK" = "auto" ]; then
   echo "[*] Automatically getting chainID for network"
   source ops/chain-id.sh
 fi
 
 
-npx hardhat upgrade-gw-diamond --network ${NETWORK}
+npx hardhat upgrade-gw-diamond --network "${NETWORK}"

contracts/ops/upgrade-sa-diamond.sh

@@ -3,18 +3,19 @@
 set -eu
 set -o pipefail
 
-if [ $# -ne 1 ]
+if [ $# -ne 2 ]
 then
-    echo "Expected a single argument with the name of the network to deploy (localnet, calibrationnet, mainnet)"
+    echo "Expected an argument with the name of the network to deploy (localnet, calibrationnet, mainnet) followed by an argument for the Subnet actor address to upgrade"
     exit 1
 fi
 
-NETWORK=$1
+NETWORK="$1"
+SUBNET_ACTOR_ADDRESS="$2"
 
 if [ "$NETWORK" = "auto" ]; then
   echo "[*] Automatically getting chainID for network"
   source ops/chain-id.sh
 fi
 
 
-npx hardhat upgrade-sa-diamond --network ${NETWORK}
+npx hardhat upgrade-sa-diamond --network "${NETWORK}" --address "$SUBNET_ACTOR_ADDRESS"

contracts/ops/upgrade-sr-diamond.sh

@@ -9,12 +9,12 @@ then
     exit 1
 fi
 
-NETWORK=$1
+NETWORK="$1"
 
 if [ "$NETWORK" = "auto" ]; then
   echo "[*] Automatically getting chainID for network"
   source ops/chain-id.sh
 fi
 
 
-npx hardhat upgrade-sr-diamond --network ${NETWORK}
+npx hardhat upgrade-sr-diamond --network "${NETWORK}"

contracts/scripts/deploy-registry.template.ts

@@ -16,6 +16,8 @@ export async function deploy() {
     const gatewayAddress = GATEWAY.Gateway
     const txArgs = await getTransactionFees()
 
+    const subnetActorDeployFacets = []
+
     // deploy
     const getterFacet = await deployContractWithDeployer(
         deployer,
@@ -27,6 +29,14 @@ export async function deploy() {
     )
     const getterSelectors = getSelectors(getterFacet)
 
+    subnetActorDeployFacets.push({
+        name: 'SubnetActorGetterFacet',
+        libs: {
+            SubnetIDHelper: LIBMAP['SubnetIDHelper'],
+        },
+        address: getterFacet.address,
+    })
+
     const managerFacet = await deployContractWithDeployer(
         deployer,
         'SubnetActorManagerFacet',
@@ -35,6 +45,15 @@ export async function deploy() {
     )
     const managerSelectors = getSelectors(managerFacet)
 
+    subnetActorDeployFacets.push({
+        name: "SubnetActorManagerFacet",
+        libs:{},
+        address: managerFacet.address
+    });
+
+
+
+
     const pauserFacet = await deployContractWithDeployer(
         deployer,
         'SubnetActorPauseFacet',
@@ -43,13 +62,26 @@ export async function deploy() {
     )
     const pauserSelectors = getSelectors(pauserFacet)
 
+    subnetActorDeployFacets.push({
+        name: "SubnetActorPauseFacet",
+        libs:{},
+        address: pauserFacet.address
+    });
+
+
     const rewarderFacet = await deployContractWithDeployer(
         deployer,
         'SubnetActorRewardFacet',
         {},
         txArgs,
     )
     const rewarderSelectors = getSelectors(rewarderFacet)
+    subnetActorDeployFacets.push({
+        name: "SubnetActorRewardFacet",
+        libs:{},
+        address: rewarderFacet.address
+    });
+
 
     const checkpointerFacet = await deployContractWithDeployer(
         deployer,
@@ -58,6 +90,39 @@ export async function deploy() {
         txArgs,
     )
     const checkpointerSelectors = getSelectors(checkpointerFacet)
+    subnetActorDeployFacets.push({
+        name: "SubnetActorCheckpointingFacet",
+        libs:{},
+        address: checkpointerFacet.address
+    });
+
+
+    const diamondCutFacet = await deployContractWithDeployer(
+        deployer,
+        'DiamondCutFacet',
+        {},
+        txArgs,
+    )
+    const diamondCutSelectors = getSelectors(diamondCutFacet)
+    subnetActorDeployFacets.push({
+        name: "DiamondCutFacet",
+        libs:{},
+        address: diamondCutFacet.address
+    });
+
+
+    const diamondLoupeFacet = await deployContractWithDeployer(
+        deployer,
+        'DiamondLoupeFacet',
+        {},
+        txArgs,
+    )
+    const diamondLoupeSelectors = getSelectors(diamondLoupeFacet)
+    subnetActorDeployFacets.push({
+        name: "DiamondLoupeFacet",
+        libs:{},
+        address: diamondLoupeFacet.address
+    });
 
     //deploy subnet registry diamond
     const registry = await ethers.getContractFactory('SubnetRegistryDiamond', {
@@ -71,11 +136,15 @@ export async function deploy() {
         rewarderFacet: rewarderFacet.address,
         checkpointerFacet: checkpointerFacet.address,
         pauserFacet: pauserFacet.address,
+        diamondCutFacet: diamondCutFacet.address,
+        diamondLoupeFacet: diamondLoupeFacet.address,
         subnetActorGetterSelectors: getterSelectors,
         subnetActorManagerSelectors: managerSelectors,
         subnetActorRewarderSelectors: rewarderSelectors,
         subnetActorCheckpointerSelectors: checkpointerSelectors,
         subnetActorPauserSelectors: pauserSelectors,
+        subnetActorDiamondCutSelectors: diamondCutSelectors,
+        subnetActorDiamondLoupeSelectors: diamondLoupeSelectors,
     }
 
     const facetCuts = [] //TODO
@@ -127,5 +196,6 @@ export async function deploy() {
     return {
         SubnetRegistry: subnetRegistryAddress,
         Facets: facets,
+        SubnetActorFacets: subnetActorDeployFacets,
     }
 }

contracts/scripts/upgrade-sa-diamond.ts

@@ -14,19 +14,24 @@ import {
  * @returns An object of updated facets.
  */
 async function upgradeSubnetActorDiamond(deployments) {
-    const gatewayDiamondAddress = deployments.SubnetActorDiamond
+    const subnetActorDiamondAddress = deployments.SubnetActorDiamond
+    console.log("subnetActorDiamondAddress", subnetActorDiamondAddress)
 
-    const onChainFacets = await getFacets(gatewayDiamondAddress)
+    const onChainFacets = await getFacets(subnetActorDiamondAddress)
+    console.log('onChainFacets',onChainFacets)
+
     const updatedFacets = {}
     const onChainFacetBytecodes = await getOnChainBytecodeFromFacets(
         onChainFacets,
     )
+    console.log("onChainFacetBytecodes", onChainFacetBytecodes)
 
     for (const facet of deployments.Facets) {
+        console.log("Facet", facet);
         await upgradeFacet(
             facet,
             onChainFacets,
-            gatewayDiamondAddress,
+            subnetActorDiamondAddress,
             updatedFacets,
             onChainFacetBytecodes,
             deployments,

contracts/scripts/util.ts

@@ -71,6 +71,7 @@ export async function getFacets(diamondAddress: string): Promise<FacetMap> {
     ]
 
     const provider = ethers.provider
+    console.log("diamondAddress",diamondAddress)
     const diamond = new Contract(diamondAddress, diamondLoupeABI, provider)
     const facetsData = await diamond.facets()
 

contracts/src/SubnetRegistryDiamond.sol

@@ -21,11 +21,15 @@ contract SubnetRegistryDiamond {
         address rewarderFacet;
         address checkpointerFacet;
         address pauserFacet;
+        address diamondCutFacet;
+        address diamondLoupeFacet;
         bytes4[] subnetActorGetterSelectors;
         bytes4[] subnetActorManagerSelectors;
         bytes4[] subnetActorRewarderSelectors;
         bytes4[] subnetActorCheckpointerSelectors;
         bytes4[] subnetActorPauserSelectors;
+        bytes4[] subnetActorDiamondCutSelectors;
+        bytes4[] subnetActorDiamondLoupeSelectors;
     }
 
     constructor(IDiamond.FacetCut[] memory _diamondCut, ConstructorParams memory params) {
@@ -47,6 +51,12 @@ contract SubnetRegistryDiamond {
         if (params.pauserFacet == address(0)) {
             revert FacetCannotBeZero();
         }
+        if (params.diamondCutFacet == address(0)) {
+            revert FacetCannotBeZero();
+        }
+        if (params.diamondLoupeFacet == address(0)) {
+            revert FacetCannotBeZero();
+        }
 
         LibDiamond.setContractOwner(msg.sender);
         LibDiamond.diamondCut({_diamondCut: _diamondCut, _init: address(0), _calldata: new bytes(0)});
@@ -63,12 +73,16 @@ contract SubnetRegistryDiamond {
         s.SUBNET_ACTOR_REWARD_FACET = params.rewarderFacet;
         s.SUBNET_ACTOR_CHECKPOINTING_FACET = params.checkpointerFacet;
         s.SUBNET_ACTOR_PAUSE_FACET = params.pauserFacet;
+        s.SUBNET_ACTOR_DIAMOND_CUT_FACET = params.diamondCutFacet;
+        s.SUBNET_ACTOR_LOUPE_FACET =   params.diamondLoupeFacet;
 
         s.subnetActorGetterSelectors = params.subnetActorGetterSelectors;
         s.subnetActorManagerSelectors = params.subnetActorManagerSelectors;
         s.subnetActorRewarderSelectors = params.subnetActorRewarderSelectors;
         s.subnetActorCheckpointerSelectors = params.subnetActorCheckpointerSelectors;
         s.subnetActorPauserSelectors = params.subnetActorPauserSelectors;
+        s.subnetActorDiamondCutSelectors = params.subnetActorDiamondCutSelectors;
+        s.subnetActorDiamondLoupeSelectors = params.subnetActorDiamondLoupeSelectors;
     }
 
     function _fallback() internal {

contracts/src/lib/LibSubnetRegistryStorage.sol

@@ -15,6 +15,10 @@ struct SubnetRegistryActorStorage {
     address SUBNET_ACTOR_CHECKPOINTING_FACET;
     // solhint-disable-next-line var-name-mixedcase
     address SUBNET_ACTOR_PAUSE_FACET;
+    // solhint-disable-next-line var-name-mixedcase
+    address SUBNET_ACTOR_DIAMOND_CUT_FACET;
+    // solhint-disable-next-line var-name-mixedcase
+    address SUBNET_ACTOR_LOUPE_FACET;
     /// The subnet actor getter facet functions selectors
     bytes4[] subnetActorGetterSelectors;
     /// The subnet actor manager facet functions selectors
@@ -25,6 +29,10 @@ struct SubnetRegistryActorStorage {
     bytes4[] subnetActorCheckpointerSelectors;
     /// The subnet actor pause facet functions selectors
     bytes4[] subnetActorPauserSelectors;
+    /// The subnet actor diamond cut facet functions selectors
+    bytes4[] subnetActorDiamondCutSelectors;
+    /// The subnet actor loupe facet functions selectors
+    bytes4[] subnetActorDiamondLoupeSelectors;
     /// @notice Mapping that tracks the deployed subnet actors per user.
     /// Key is the hash of Subnet ID, values are addresses.
     /// mapping owner => nonce => subnet

contracts/src/subnetregistry/RegisterSubnetFacet.sol

@@ -23,7 +23,7 @@ contract RegisterSubnetFacet is ReentrancyGuard {
             revert WrongGateway();
         }
 
-        IDiamond.FacetCut[] memory diamondCut = new IDiamond.FacetCut[](5);
+        IDiamond.FacetCut[] memory diamondCut = new IDiamond.FacetCut[](7);
 
         // set the diamond cut for subnet getter
         diamondCut[0] = IDiamond.FacetCut({
@@ -57,6 +57,18 @@ contract RegisterSubnetFacet is ReentrancyGuard {
             functionSelectors: s.subnetActorPauserSelectors
         });
 
+        diamondCut[5] = IDiamond.FacetCut({
+            facetAddress: s.SUBNET_ACTOR_DIAMOND_CUT_FACET,
+            action: IDiamond.FacetCutAction.Add,
+            functionSelectors: s.subnetActorDiamondCutSelectors
+        });
+
+        diamondCut[6] = IDiamond.FacetCut({
+            facetAddress: s.SUBNET_ACTOR_LOUPE_FACET,
+            action: IDiamond.FacetCutAction.Add,
+            functionSelectors: s.subnetActorDiamondLoupeSelectors
+        });
+
         // slither-disable-next-line reentrancy-benign
         subnetAddr = address(new SubnetActorDiamond(diamondCut, _params, msg.sender));