Allow funds to be sent directly to domains

Author: area

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetwork.sol:ColonyNetwork.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetwork.sol:ColonyNetwork",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetworkAuction.sol:ColonyNetworkAuction.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetworkAuction.sol:ColonyNetworkAuction",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetworkDeployer.sol:ColonyNetworkDeployer.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetworkDeployer.sol:ColonyNetworkDeployer",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetworkENS.sol:ColonyNetworkENS.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetworkENS.sol:ColonyNetworkENS",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetworkExtensions.sol:ColonyNetworkExtensions.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetworkExtensions.sol:ColonyNetworkExtensions",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetworkMining.sol:ColonyNetworkMining.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetworkMining.sol:ColonyNetworkMining",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetworkSkills.sol:ColonyNetworkSkills.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetworkSkills.sol:ColonyNetworkSkills",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/colonyNetwork/ColonyNetworkStorage.sol:ColonyNetworkStorage.json

@@ -1132,6 +1132,17 @@
           }
         }
       }
+    },
+    {
+      "contract": "contracts/colonyNetwork/ColonyNetworkStorage.sol:ColonyNetworkStorage",
+      "label": "domainReceiverResolverAddress",
+      "offset": 0,
+      "slot": "50",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
     }
   ]
 }

.storage-layouts-normalized/contracts/common/DomainTokenReceiver.sol:DomainTokenReceiver.json

@@ -0,0 +1,48 @@
+{
+  "storage": [
+    {
+      "contract": "contracts/common/DomainTokenReceiver.sol:DomainTokenReceiver",
+      "label": "authority",
+      "offset": 0,
+      "slot": "0",
+      "type": {
+        "encoding": "inplace",
+        "label": "contract DSAuthority",
+        "numberOfBytes": "20"
+      }
+    },
+    {
+      "contract": "contracts/common/DomainTokenReceiver.sol:DomainTokenReceiver",
+      "label": "owner",
+      "offset": 0,
+      "slot": "1",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
+    },
+    {
+      "contract": "contracts/common/DomainTokenReceiver.sol:DomainTokenReceiver",
+      "label": "resolver",
+      "offset": 0,
+      "slot": "2",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
+    },
+    {
+      "contract": "contracts/common/DomainTokenReceiver.sol:DomainTokenReceiver",
+      "label": "colony",
+      "offset": 0,
+      "slot": "3",
+      "type": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      }
+    }
+  ]
+}

contracts/colony/ColonyFunding.sol

@@ -23,6 +23,7 @@ import { ITokenLocking } from "./../tokenLocking/ITokenLocking.sol";
 import { ColonyStorage } from "./ColonyStorage.sol";
 import { ERC20Extended } from "./../common/ERC20Extended.sol";
 import { IColonyNetwork } from "./../colonyNetwork/IColonyNetwork.sol";
+import { DomainTokenReceiver } from "./../common/DomainTokenReceiver.sol";
 
 contract ColonyFunding is
   ColonyStorage // ignore-swc-123
@@ -106,6 +107,47 @@ contract ColonyFunding is
     emit ColonyFundsClaimed(msgSender(), _token, feeToPay, remainder);
   }
 
+  function claimDomainFunds(address _token, uint256 _domainId) public stoppable {
+    require(domainExists(_domainId), "colony-funding-domain-does-not-exist");
+    address domainTokenReceiverAddress = IColonyNetwork(colonyNetworkAddress)
+      .checkDomainTokenReceiverDeployed(_domainId);
+    uint256 fundingPotId = domains[_domainId].fundingPotId;
+    // It's deployed, so check current balance of pot
+    uint256 balanceBefore = getFundingPotBalance(fundingPotId, _token);
+
+    uint256 claimAmount;
+    uint256 thisBalanceBefore;
+
+    if (_token == address(0x0)) {
+      claimAmount = address(domainTokenReceiverAddress).balance;
+      thisBalanceBefore = address(this).balance;
+    } else {
+      claimAmount = ERC20Extended(_token).balanceOf(address(domainTokenReceiverAddress));
+      thisBalanceBefore = ERC20Extended(_token).balanceOf(address(this));
+    }
+
+    fundingPots[fundingPotId].balance[_token] += claimAmount;
+
+    // Claim funds
+
+    DomainTokenReceiver(domainTokenReceiverAddress).transferToColony(_token);
+
+    // Add to funding pot
+
+    uint256 balanceAfter = getFundingPotBalance(fundingPotId, _token);
+
+    assert(balanceAfter - balanceBefore == claimAmount);
+
+    uint256 thisBalanceAfter;
+    if (_token == address(0x0)) {
+      thisBalanceAfter = address(this).balance;
+    } else {
+      thisBalanceAfter = ERC20Extended(_token).balanceOf(address(this));
+    }
+
+    assert(thisBalanceAfter - thisBalanceBefore == claimAmount);
+  }
+
   function getNonRewardPotsTotal(address _token) public view returns (uint256) {
     return nonRewardPotsTotal[_token];
   }

contracts/colony/IColony.sol

@@ -830,6 +830,12 @@ interface IColony is ColonyDataTypes, IRecovery, IBasicMetaTransaction, IMultica
   /// @param _token Address of the token, `0x0` value indicates Ether
   function claimColonyFunds(address _token) external;
 
+  /// @notice Move any funds received by the colony for a specific domain to that domain's pot
+  /// Currently no fees are taken
+  /// @param _token Address of the token, `0x0` value indicates Ether
+  /// @param _domainId Id of the domain
+  function claimDomainFunds(address _token, uint256 _domainId) external;
+
   /// @notice Get the total amount of tokens `_token` minus amount reserved to be paid to the reputation and token holders as rewards.
   /// @param _token Address of the token, `0x0` value indicates Ether
   /// @return amount Total amount of tokens in funding pots other than the rewards pot (id 0)

contracts/colonyNetwork/ColonyNetworkDeployer.sol

@@ -19,6 +19,7 @@
 pragma solidity 0.8.25;
 pragma experimental "ABIEncoderV2";
 import { EtherRouter } from "./../common/EtherRouter.sol";
+import { Resolver } from "./../common/Resolver.sol";
 import { ColonyAuthority } from "./../colony/ColonyAuthority.sol";
 import { IColony } from "./../colony/IColony.sol";
 import { ColonyNetworkStorage } from "./ColonyNetworkStorage.sol";
@@ -27,6 +28,8 @@ import { MetaTxToken } from "./../metaTxToken/MetaTxToken.sol";
 import { DSAuth, DSAuthority } from "./../../lib/dappsys/auth.sol";
 import { ICreateX } from "./../../lib/createx/src/ICreateX.sol";
 import { EtherRouterCreate3 } from "./../common/EtherRouterCreate3.sol";
+import { IColonyBridge } from "./../bridging/IColonyBridge.sol";
+import { DomainTokenReceiver } from "./../common/DomainTokenReceiver.sol";
 
 contract ColonyNetworkDeployer is ColonyNetworkStorage {
   address constant CREATEX_ADDRESS = 0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed;
@@ -175,6 +178,94 @@ contract ColonyNetworkDeployer is ColonyNetworkStorage {
     // This is intentional, as we want to allow the same Colony to be deployed on different chains
   }
 
+  function setDomainTokenReceiverResolver(address _resolver) public stoppable auth {
+    domainReceiverResolverAddress = _resolver;
+  }
+
+  function getDomainTokenReceiverResolver() public view returns (address) {
+    return domainReceiverResolverAddress;
+  }
+
+  function checkDomainTokenReceiverDeployed(
+    uint256 _domainId
+  ) public stoppable calledByColony returns (address domainTokenReceiverAddress) {
+    // Calculate the address the domain should be receiving funds at
+    domainTokenReceiverAddress = getDomainTokenReceiverAddress(msgSender(), _domainId);
+
+    if (!isContract(domainTokenReceiverAddress)) {
+      // Then deploy the contract
+      bytes32 salt = getDomainTokenReceiverDeploySalt(msgSender(), _domainId);
+      address deployedAddress = ICreateX(CREATEX_ADDRESS).deployCreate3AndInit(
+        salt,
+        type(EtherRouterCreate3).creationCode,
+        abi.encodeWithSignature("setOwner(address)", (address(this))),
+        ICreateX.Values(0, 0)
+      );
+      require(
+        deployedAddress == domainTokenReceiverAddress,
+        "colony-network-domain-receiver-deploy-wrong-address"
+      );
+    }
+
+    // Check it's got the right resolver
+    try EtherRouter(payable(domainTokenReceiverAddress)).resolver() returns (Resolver resolver) {
+      if (address(resolver) != domainReceiverResolverAddress) {
+        EtherRouter(payable(domainTokenReceiverAddress)).setResolver(domainReceiverResolverAddress);
+      }
+    } catch {
+      revert("colony-network-domain-receiver-not-etherrouter");
+    }
+
+    // Check it's set up correctly
+
+    if (DomainTokenReceiver(domainTokenReceiverAddress).getColonyAddress() != msgSender()) {
+      DomainTokenReceiver(domainTokenReceiverAddress).setColonyAddress(msgSender());
+    }
+
+    return domainTokenReceiverAddress;
+  }
+
+  function isContract(address addr) internal view returns (bool) {
+    uint256 size;
+    assembly {
+      size := extcodesize(addr)
+    }
+    return size > 0;
+  }
+
+  function getDomainTokenReceiverAddress(
+    address _colony,
+    uint256 _domainId
+  ) public view returns (address) {
+    bytes32 salt = getDomainTokenReceiverDeploySalt(_colony, _domainId);
+
+    // To get the correct address, we have to mimic the _guard functionality of CreateX
+    bytes32 guardedSalt = keccak256(abi.encode(bytes32(uint256(uint160(address(this)))), salt));
+    return ICreateX(CREATEX_ADDRESS).computeCreate3Address(guardedSalt);
+  }
+
+  function getDomainTokenReceiverDeploySalt(
+    address _colony,
+    uint256 _domainId
+  ) internal view returns (bytes32) {
+    // Calculate the address the domain should be receiving funds at
+    // We only want Colony Networks to be able to deploy to the same address,
+    // so we use the permissioned deploy protection feature of CreateX, and set
+    // the first 160 bits of the salt to the address of this contract.
+
+    bytes32 salt = bytes32(uint256(uint160(address(this)))) << 96;
+
+    bytes32 additionalSalt = keccak256(abi.encode(_colony, _domainId));
+    // We use the first 88 bits of the additional salt, which is a function of the colony and domainId,
+    // to add entropy in the last 88 bits of the salt
+    salt = salt | (additionalSalt >> 168);
+    // We have set the first 160 bits, and the last 88 bits of the salt
+    // Note that this leaves byte 21 of the salt as zero (0x00), which disables cross-chain
+    // redeployment protection in createX.
+    // This is intentional, as we want to allow the same receiver to be deployed on different chains
+    return salt;
+  }
+
   function deployColony(address _tokenAddress, uint256 _version) internal returns (address) {
     require(_tokenAddress != address(0x0), "colony-token-invalid-address");
     require(colonyVersionResolver[_version] != address(0x00), "colony-network-invalid-version");

contracts/colonyNetwork/ColonyNetworkStorage.sol

@@ -129,6 +129,7 @@ contract ColonyNetworkStorage is ColonyNetworkDataTypes, DSMath, CommonStorage,
   // networkId -> colonyAddress -> updateCount -> update
   mapping(uint256 => mapping(address => mapping(uint256 => PendingReputationUpdate))) pendingReputationUpdates; // Storage slot 49
 
+  address domainReceiverResolverAddress; // Storage slot 50
   // Modifiers
 
   modifier calledByColony() {