@towns-protocol/contracts 0.0.302

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

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+
+//libraries
+
+//contracts
+import {EntryPoint} from "account-abstraction/core/EntryPoint.sol";
+import {Deployer} from "scripts/common/Deployer.s.sol";
+
+contract DeployEntrypoint is Deployer {
+    function versionName() public pure override returns (string memory) {
+        return "utils/entrypoint";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        if (!isAnvil()) revert("not supported");
+
+        bytes32 salt = bytes32(uint256(1));
+        bytes32 initCodeHash = hashInitCode(type(EntryPoint).creationCode);
+        address soonToBe = computeCreate2Address(salt, initCodeHash);
+        vm.broadcast(deployer);
+        EntryPoint entrypoint = new EntryPoint{salt: salt}();
+        require(address(entrypoint) == soonToBe, "address mismatch");
+        return address(entrypoint);
+    }
+}

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

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+//interfaces
+
+//libraries
+import {MerkleTree} from "test/utils/MerkleTree.sol";
+
+//contracts
+import {Deployer} from "scripts/common/Deployer.s.sol";
+import {Member} from "src/tokens/Member.sol";
+
+contract DeployMember is Deployer {
+    Member private member;
+    MerkleTree private merkle;
+
+    function versionName() public pure override returns (string memory) {
+        return "utils/member";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        vm.startBroadcast(deployer);
+        member = new Member(
+            "Council Member",
+            "MEMBER",
+            "https://bafybeihuygd5wm43kmxl4pocbv5uchdrkimhfwk75qgbmtlrqsy2bwwijq.ipfs.nftstorage.link/metadata/",
+            ""
+        );
+        member.startWaitlistMint();
+        member.startPublicMint();
+        vm.stopBroadcast();
+        return address(member);
+    }
+
+    function deployWithProof(address deployer) public returns (address) {
+        address[] memory accounts = new address[](5);
+        accounts[0] = address(0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
+        accounts[1] = address(0x70997970C51812dc3A010C7d01b50e0d17dc79C8);
+        accounts[2] = address(0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC);
+        accounts[3] = address(0x90F79bf6EB2c4f870365E785982E1f101E93b906);
+        accounts[4] = address(0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65);
+
+        uint256[] memory allowances = new uint256[](5);
+        allowances[0] = 1;
+        allowances[1] = 1;
+        allowances[2] = 1;
+        allowances[3] = 1;
+        allowances[4] = 1;
+
+        uint256[] memory points = new uint256[](5);
+        points[0] = 1;
+        points[1] = 1;
+        points[2] = 1;
+        points[3] = 1;
+        points[4] = 1;
+
+        merkle = new MerkleTree();
+        (bytes32 root, bytes32[][] memory tree) = merkle.constructTree(
+            accounts,
+            allowances,
+            points
+        );
+
+        vm.startBroadcast(deployer);
+        member = new Member(
+            "Council Member",
+            "MEMBER",
+            "https://bafybeihuygd5wm43kmxl4pocbv5uchdrkimhfwk75qgbmtlrqsy2bwwijq.ipfs.nftstorage.link/metadata/",
+            root
+        );
+
+        member.privateMint{value: member.MINT_PRICE()}(
+            accounts[0],
+            allowances[0],
+            merkle.getProof(tree, 0)
+        );
+
+        member.privateMint{value: member.MINT_PRICE()}(
+            accounts[1],
+            allowances[1],
+            merkle.getProof(tree, 1)
+        );
+
+        member.privateMint{value: member.MINT_PRICE()}(
+            accounts[2],
+            allowances[2],
+            merkle.getProof(tree, 2)
+        );
+
+        member.startWaitlistMint();
+        member.startPublicMint();
+        vm.stopBroadcast();
+        return address(member);
+    }
+}

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

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.23;
+
+// deployments
+import {DeployDiamond} from "@towns-protocol/diamond/scripts/deployments/diamonds/DeployDiamond.s.sol";
+
+contract DeployMockDiamond is DeployDiamond {}

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

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {Deployer} from "scripts/common/Deployer.s.sol";
+import {MockERC20} from "test/mocks/MockERC20.sol";
+
+contract DeployMockERC20 is Deployer {
+    function versionName() public pure override returns (string memory) {
+        return "utils/mockERC20";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        // bytes32 salt = bytes32(uint256(uint160(deployer))); // create a salt from address
+
+        // bytes32 initCodeHash = hashInitCode(type(MockERC20).creationCode);
+        // address predeterminedAddress = vm.computeCreate2Address(salt, initCodeHash);
+
+        vm.startBroadcast(deployer);
+        MockERC20 deployment = new MockERC20("TownsTest", "TToken");
+        vm.stopBroadcast();
+
+        return address(deployment);
+    }
+}

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

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+import {DeployERC721A} from "../facets/DeployERC721A.s.sol";
+
+// contracts
+import {MockERC721A} from "../../../test/mocks/MockERC721A.sol";
+
+library DeployMockERC721A {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(16);
+        arr.p(MockERC721A.mintTo.selector);
+        arr.p(MockERC721A.mint.selector);
+        arr.p(MockERC721A.burn.selector);
+        {
+            bytes4[] memory selectors_ = DeployERC721A.selectors();
+            for (uint256 i; i < selectors_.length; ++i) {
+                arr.p(selectors_[i]);
+            }
+        }
+        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 deploy() internal returns (address) {
+        return LibDeploy.deployCode("MockERC721A.sol", "");
+    }
+}

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

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+import {MockLegacyMembership} from "test/mocks/legacy/membership/MockLegacyMembership.sol";
+
+library DeployMockLegacyMembership {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](1);
+        res[0] = MockLegacyMembership.joinSpaceLegacy.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MockLegacyMembership.sol", "");
+    }
+}

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

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+
+//libraries
+
+//contracts
+import {Deployer} from "scripts/common/Deployer.s.sol";
+import {MockMessenger} from "test/mocks/MockMessenger.sol";
+
+contract DeployMockMessenger is Deployer {
+    function versionName() public pure override returns (string memory) {
+        return "facets/mockMessengerFacet";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        if (isAnvil() || isTesting()) {
+            vm.startBroadcast(deployer);
+            MockMessenger messenger = new MockMessenger();
+            vm.stopBroadcast();
+            return address(messenger);
+        } else {
+            return _getMessenger();
+        }
+    }
+
+    function _getMessenger() internal view returns (address) {
+        // Base or Base (Sepolia)
+        if (block.chainid == 8453 || block.chainid == 84_532) {
+            return 0x4200000000000000000000000000000000000007;
+        } else if (block.chainid == 1) {
+            // Mainnet
+            return 0x866E82a600A1414e583f7F13623F1aC5d58b0Afa;
+        } else if (block.chainid == 11_155_111) {
+            // Sepolia
+            return 0xC34855F4De64F1840e5686e64278da901e261f20;
+        } else {
+            revert("DeployMockMessenger: Invalid network");
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {DeployDiamondCut} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondCut.sol";
+import {DeployDiamondLoupe} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondLoupe.sol";
+import {DeployIntrospection} from "@towns-protocol/diamond/scripts/deployments/facets/DeployIntrospection.sol";
+import {DeployMockERC721A} from "../../deployments/utils/DeployMockERC721A.s.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+// contracts
+import {DiamondHelper} from "@towns-protocol/diamond/scripts/common/helpers/DiamondHelper.s.sol";
+import {Diamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {MultiInit} from "@towns-protocol/diamond/src/initializers/MultiInit.sol";
+
+// deployers
+import {DeployFacet} from "../../common/DeployFacet.s.sol";
+import {Deployer} from "../../common/Deployer.s.sol";
+
+contract DeployMockNFT is DiamondHelper, Deployer {
+    using LibString for string;
+
+    DeployFacet private facetHelper = new DeployFacet();
+
+    function versionName() public pure override returns (string memory) {
+        return "utils/mockNFT";
+    }
+
+    function diamondInitParams(address deployer) public returns (Diamond.InitParams memory) {
+        // Queue up all facets for batch deployment
+        facetHelper.add("MultiInit");
+        facetHelper.add("DiamondCutFacet");
+        facetHelper.add("DiamondLoupeFacet");
+        facetHelper.add("IntrospectionFacet");
+        facetHelper.add("MockERC721A");
+
+        // Deploy all facets in a single batch transaction
+        facetHelper.deployBatch(deployer);
+
+        // Get deployed addresses
+        address facet = facetHelper.getDeployedAddress("DiamondCutFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondCut.selectors()),
+            facet,
+            DeployDiamondCut.makeInitData()
+        );
+
+        facet = facetHelper.getDeployedAddress("DiamondLoupeFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondLoupe.selectors()),
+            facet,
+            DeployDiamondLoupe.makeInitData()
+        );
+
+        facet = facetHelper.getDeployedAddress("IntrospectionFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployIntrospection.selectors()),
+            facet,
+            DeployIntrospection.makeInitData()
+        );
+
+        // Add ERC721A mock
+        facet = facetHelper.getDeployedAddress("MockERC721A");
+        addCut(makeCut(facet, FacetCutAction.Add, DeployMockERC721A.selectors()));
+
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        return
+            Diamond.InitParams({
+                baseFacets: baseFacets(),
+                init: multiInit,
+                initData: abi.encodeCall(MultiInit.multiInit, (_initAddresses, _initDatas))
+            });
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        Diamond.InitParams memory initDiamondCut = diamondInitParams(deployer);
+
+        vm.broadcast(deployer);
+        Diamond diamond = new Diamond(initDiamondCut);
+
+        return address(diamond);
+    }
+}

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

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {Deployer} from "scripts/common/Deployer.s.sol";
+import {PoapEntitlement} from "src/spaces/entitlements/poap/PoapEntitlement.sol";
+
+contract DeployPoapEntitlement is Deployer {
+    function versionName() public pure override returns (string memory) {
+        return "utils/poapEntitlement";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        vm.broadcast(deployer);
+        return address(new PoapEntitlement(0x22C1f6050E56d2876009903609a2cC3fEf83B415));
+    }
+}

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

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {Deployer} from "../../common/Deployer.s.sol";
+import {ProxyBatchDelegation} from "src/tokens/mainnet/delegation/ProxyBatchDelegation.sol";
+import {MockMessenger} from "test/mocks/MockMessenger.sol";
+
+// deployments
+import {DeployTownsMainnet} from "./DeployTownsMainnet.s.sol";
+
+contract DeployProxyBatchDelegation is Deployer {
+    address internal constant CLAIMERS = 0x0bEe55b52d01C4D5d4D0cfcE1d6e0baE6722db05;
+    address internal constant BASE_REGISTRY = 0x7c0422b31401C936172C897802CF0373B35B7698;
+    address internal constant BASE_REGISTRY_SEPOLIA = 0x08cC41b782F27d62995056a4EF2fCBAe0d3c266F;
+    address internal constant MESSENGER = 0x866E82a600A1414e583f7F13623F1aC5d58b0Afa;
+    address internal constant MESSENGER_SEPOLIA = 0xC34855F4De64F1840e5686e64278da901e261f20;
+
+    // Mainnet
+    DeployTownsMainnet internal townsHelper = new DeployTownsMainnet();
+
+    address public townsToken;
+    address public claimers;
+    address public mainnetDelegation;
+    address public messenger;
+    address public vault;
+
+    function versionName() public pure override returns (string memory) {
+        return "utils/proxyBatchDelegation";
+    }
+
+    function setDependencies(address mainnetDelegation_, address messenger_) external {
+        mainnetDelegation = mainnetDelegation_;
+        messenger = messenger_;
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        townsToken = townsHelper.deploy(deployer);
+        debug("DeployProxyBatchDelegation: townsToken: %s", townsToken);
+
+        vault = townsHelper.vault();
+
+        claimers = _getClaimers(deployer);
+        debug("DeployProxyBatchDelegation: claimers: %s", claimers);
+
+        if (messenger == address(0)) {
+            if (isAnvil() || isTesting()) {
+                vm.broadcast(deployer);
+                messenger = address(new MockMessenger());
+            } else {
+                messenger = getMessenger();
+            }
+        }
+        debug("DeployProxyBatchDelegation: messenger: %s", messenger);
+
+        if (mainnetDelegation == address(0)) {
+            mainnetDelegation = _getMainnetDelegation();
+        }
+
+        if (townsToken == address(0)) {
+            revert("DeployProxyBatchDelegation: Towns token not deployed");
+        }
+
+        if (claimers == address(0)) {
+            revert("DeployProxyBatchDelegation: Claimers not deployed");
+        }
+
+        vm.broadcast(deployer);
+        return
+            address(new ProxyBatchDelegation(townsToken, claimers, messenger, mainnetDelegation));
+    }
+
+    function _getClaimers(address deployer) internal returns (address) {
+        if (block.chainid == 1) {
+            return CLAIMERS;
+        }
+
+        vm.broadcast(deployer);
+        return deployCode("AuthorizedClaimers", "");
+    }
+
+    function _getMainnetDelegation() internal returns (address) {
+        if (block.chainid == 84_532 || block.chainid == 11_155_111) {
+            // base registry on base sepolia
+            return BASE_REGISTRY_SEPOLIA;
+        }
+
+        if (block.chainid == 1) {
+            // Base Registry contract on Base
+            return BASE_REGISTRY;
+        }
+
+        return getDeployment("baseRegistry");
+    }
+
+    function getMessenger() public view returns (address) {
+        // Base or Base (Sepolia)
+        if (block.chainid == 8453 || block.chainid == 84_532) {
+            return 0x4200000000000000000000000000000000000007;
+        } else if (block.chainid == 1) {
+            return MESSENGER;
+        } else if (block.chainid == 11_155_111) {
+            return MESSENGER_SEPOLIA;
+        } else {
+            revert("DeployProxyDelegation: Invalid network");
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+// 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);
+    }
+}

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

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+
+//libraries
+
+//contracts
+import {TieredLogPricing} from "scripts/deployments/utils/pricing/TieredLogPricing.s.sol";
+import {TieredLogPricingOracleV2} from "src/spaces/facets/membership/pricing/tiered/TieredLogPricingOracleV2.sol";
+
+contract DeployTieredLogPricingV2 is TieredLogPricing {
+    function versionName() public pure override returns (string memory) {
+        return "utils/tieredLogPricingV2";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        address oracle = isAnvil() ? _setupLocalOracle(deployer) : _getOracleAddress();
+
+        vm.broadcast(deployer);
+        return address(new TieredLogPricingOracleV2(oracle));
+    }
+}

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

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+
+//libraries
+
+//contracts
+import {TieredLogPricing} from "scripts/deployments/utils/pricing/TieredLogPricing.s.sol";
+import {TieredLogPricingOracleV3} from "src/spaces/facets/membership/pricing/tiered/TieredLogPricingOracleV3.sol";
+
+contract DeployTieredLogPricingV3 is TieredLogPricing {
+    function versionName() public pure override returns (string memory) {
+        return "utils/tieredLogPricingV3";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        address oracle = isAnvil() ? _setupLocalOracle(deployer) : _getOracleAddress();
+
+        vm.broadcast(deployer);
+        return address(new TieredLogPricingOracleV3(oracle));
+    }
+}

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

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+//interfaces
+
+//libraries
+import {Create2Utils} from "../../../src/utils/libraries/Create2Utils.sol";
+
+//contracts
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {Deployer} from "scripts/common/Deployer.s.sol";
+import {Towns} from "src/tokens/towns/base/Towns.sol";
+import {TownsDeployer} from "src/tokens/towns/base/TownsDeployer.sol";
+import {TownsDeployer} from "src/tokens/towns/base/TownsDeployer.sol";
+import {MockTowns} from "test/mocks/MockTowns.sol";
+import {MockTownsDeployer} from "test/mocks/MockTownsDeployer.sol";
+
+contract DeployTownsBase is Deployer {
+    address public l1Token = 0x000000Fa00b200406de700041CFc6b19BbFB4d13;
+    bytes32 public implSalt;
+    bytes32 public proxySalt;
+
+    function versionName() public pure override returns (string memory) {
+        return "utils/towns";
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        (implSalt, proxySalt) = _getSalts();
+
+        address vault = _getVault(deployer);
+        address proxy = _proxyAddress(_implAddress(implSalt), proxySalt, l1Token, vault);
+
+        vm.startBroadcast(deployer);
+        if (isAnvil()) {
+            new MockTownsDeployer(l1Token, vault, implSalt, proxySalt);
+        } else {
+            new TownsDeployer(l1Token, vault, implSalt, proxySalt);
+        }
+        vm.stopBroadcast();
+
+        return proxy;
+    }
+
+    function _implAddress(bytes32 salt) internal view returns (address impl) {
+        if (isAnvil()) {
+            impl = Create2Utils.computeCreate2Address(salt, type(MockTowns).creationCode);
+        } else {
+            impl = Create2Utils.computeCreate2Address(salt, type(Towns).creationCode);
+        }
+    }
+
+    function _proxyAddress(
+        address impl,
+        bytes32 salt,
+        address remoteToken,
+        address owner
+    ) internal pure returns (address proxy) {
+        bytes memory byteCode = abi.encodePacked(
+            type(ERC1967Proxy).creationCode,
+            abi.encode(
+                impl,
+                abi.encodePacked(Towns.initialize.selector, abi.encode(remoteToken, owner))
+            )
+        );
+
+        proxy = Create2Utils.computeCreate2Address(salt, byteCode);
+    }
+
+    function setSalts(bytes32 impl, bytes32 proxy) public {
+        implSalt = impl;
+        proxySalt = proxy;
+    }
+
+    function _getVault(address deployer) internal view returns (address) {
+        if (isAnvil()) {
+            return deployer;
+        } else {
+            return 0x63217D4c321CC02Ed306cB3843309184D347667B; // DAO
+        }
+    }
+
+    function _getSalts() internal view returns (bytes32 impl, bytes32 proxy) {
+        if (implSalt != bytes32(0) && proxySalt != bytes32(0)) {
+            return (implSalt, proxySalt);
+        }
+
+        if (isAnvil()) {
+            impl = 0x4e59b44847b379578588920ca78fbf26c0b4956c346fdfc0a289d4a53c0000c0;
+            proxy = 0x4e59b44847b379578588920ca78fbf26c0b4956c83c2f2967966f90700000000;
+        } else {
+            impl = 0x4e59b44847b379578588920ca78fbf26c0b4956c8ea716a80f934b1756000020;
+            proxy = 0x4e59b44847b379578588920ca78fbf26c0b4956c1594db1b919831030e120040;
+        }
+    }
+}