Add base sepolia and deploy latest to testnets

.gitignore

@@ -6,6 +6,8 @@ out/
 !/broadcast
 /broadcast/*/31337/
 /broadcast/**/dry-run/
+**/broadcast/**
+
 
 # Docs
 docs/

.gitmodules

@@ -1,8 +1,8 @@
 [submodule "lib/openzeppelin-contracts"]
-	branch = v4.8.2
+	branch = v5.0.1
 	path = lib/openzeppelin-contracts
 	url = https://github.com/openzeppelin/openzeppelin-contracts
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
-	branch = v1.5.2
+	branch = v1.7.6

foundry.toml

@@ -5,5 +5,6 @@ out = 'out'
 test = 'test'
 cache_path = 'cache'
 script = 'script'
+solc_version = '0.8.23'
 
 # See more config options https://github.com/foundry-rs/foundry/tree/master/config

management/.env.example

@@ -0,0 +1,14 @@
+# .env file
+PRIVATE_KEY=your_private_key_here
+BASE_RPC_URL=your_base_network_rpc_url
+BASE_PATCHWORK_OWNER=base_patchwork_owner_address
+BASE_PATCHWORK_ADDRESS=base_patchwork_address
+BASE_CHAIN_ID=8453
+SEPOLIA_RPC_URL=your_sepolia_network_rpc_url
+SEPOLIA_PATCHWORK_OWNER=sepolia_patchwork_owner_address
+SEPOLIA_CHAIN_ID=11155111
+SEPOLIA_PATCHWORK_ADDRESS=0xeAB0ceC50d344c1256fB983fee6f87D6A040d329
+BASE_SEPOLIA_RPC_URL=https://base-sepolia.g.alchemy.com/v2/6p1q3ciiOzYUwMaNdysskDHdLLV56sGx
+BASE_SEPOLIA_PATCHWORK_OWNER=0x435498Afe7E9b01f92D673fADA429fAeA08870aA
+BASE_SEPOLIA_CHAIN_ID=11155111
+BASE_SEPOLIA_PATCHWORK_ADDRESS=0xeAB0ceC50d344c1256fB983fee6f87D6A040d329

management/README.md

@@ -0,0 +1,23 @@
+Create a .env file in the format of .env.example
+
+To deoploy on sepolia:
+./deploy.sh sepolia
+
+To deploy on base:
+./deploy.sh base
+
+Include --broadcast when you are ready to deploy
+
+To verify on ether scan:
+
+./verify.sh base
+
+ or
+
+ ./verify.sh sepolia
+
+manual verification:
+
+forge verify-contract 0x635BDfB811Ef377a759231Ac3A2746814A93a7B8 src/PatchworkProtocol.sol:PatchworkProtocol --optimizer-runs 200 --constructor-args "0x0000000000000000000000007239aec2fa59303ba68bece386be2a9ddc72e63b" --show-standard-json-input > etherscan.json
+patch manually etherscan.json : "optimizer":{"enabled":true,"runs":100} -> "optimizer":{"enabled":true,"runs":100},"viaIR":true (or something of that sort)
+upload json to etherscan manually

management/constructor-args.txt

@@ -0,0 +1 @@
+0x7239aEc2fA59303BA68BEcE386BE2A9dDC72e63B

management/deploy.s.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import { Script } from "forge-std/Script.sol";
+import "forge-std/console.sol";
+import { PatchworkProtocol } from "../src/PatchworkProtocol.sol";
+import { PatchworkProtocolAssigner } from "../src/PatchworkProtocolAssigner.sol";
+
+contract DeterministicPatchworkDeploy is Script {
+
+    address internal constant _DETERMINISTIC_CREATE2_FACTORY = 0x7A0D94F55792C434d74a40883C6ed8545E406D12;
+
+    function run() public {
+        address patchworkOwner = vm.envAddress("PATCHWORK_OWNER");
+        vm.startBroadcast();
+
+        bytes memory creationCode = type(PatchworkProtocolAssigner).creationCode;
+        bytes memory creationBytecode = abi.encodePacked(creationCode, abi.encode(patchworkOwner));
+        (bool success, bytes memory returnData) = _DETERMINISTIC_CREATE2_FACTORY.call(creationBytecode);
+        require(success, "Failed to deploy Assigner Module");
+        address assignerAddress = address(uint160(bytes20(returnData)));
+        console.log("Deployed Assigner module contract at: ", assignerAddress);
+
+        creationCode = type(PatchworkProtocol).creationCode;
+        creationBytecode = abi.encodePacked(creationCode, abi.encode(patchworkOwner), abi.encode(assignerAddress));
+        (success, returnData) = _DETERMINISTIC_CREATE2_FACTORY.call(creationBytecode);
+        require(success, "Failed to deploy Patchwork");
+        address patchworkAddress = address(uint160(bytes20(returnData)));
+        console.log("Deployed Patchwork contract at: ", patchworkAddress);
+
+        vm.stopBroadcast();
+    }
+}

management/deploy.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+# deploy.sh
+
+# Usage instructions
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 <network> [--broadcast]"
+  echo "Supported networks: base, sepolia"
+  exit 1
+fi
+
+# Load the .env file
+if [ -f .env ]; then
+  export $(grep -v '^#' .env | xargs)
+else 
+  echo ".env file not found"
+  exit 1
+fi
+
+NETWORK=$1
+PATCHWORK_OWNER=""
+RPC_URL=""
+
+case $NETWORK in
+  "base")
+    PATCHWORK_OWNER=$BASE_PATCHWORK_OWNER
+    RPC_URL=$BASE_RPC_URL
+    ;;
+  "sepolia")
+    PATCHWORK_OWNER=$SEPOLIA_PATCHWORK_OWNER
+    RPC_URL=$SEPOLIA_RPC_URL
+    ;;
+  "base-sepolia")
+    PATCHWORK_OWNER=$BASE_SEPOLIA_PATCHWORK_OWNER
+    RPC_URL=$BASE_SEPOLIA_RPC_URL
+    ;;
+  *)
+    echo "Network not supported"
+    exit 1
+    ;;
+esac
+
+# Check for broadcast flag
+if [[ " $* " =~ " --broadcast " ]]; then
+  echo "Broadcasting is enabled"
+  forge_options="$forge_options --broadcast"
+fi
+
+# Export the owner address as an environment variable
+export PATCHWORK_OWNER
+
+# Execute the Solidity script with the environment variable
+forge script $forge_options --optimize --optimizer-runs 200 ./deploy.s.sol:DeterministicPatchworkDeploy \
+  --rpc-url $RPC_URL \
+  --private-key $PRIVATE_KEY

management/encodeConstructorArgs.s.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import { PatchworkProtocol } from "src/PatchworkProtocol.sol";
+
+contract EncodeConstructorArgs is Script {
+    function run() public {
+        address patchworkOwner = 0x7239aEc2fA59303BA68BEcE386BE2A9dDC72e63B;
+        bytes memory encodedArgs = abi.encode(patchworkOwner);
+        console.log("Encoded Constructor Args:", vm.toString(encodedArgs));
+    }
+}

management/verify.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+# verify.sh
+
+# Usage instructions
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 <network>"
+  echo "Supported networks: base, sepolia"
+  exit 1
+fi
+
+NETWORK=$1
+
+# Load the .env file
+if [ -f .env ]; then
+  export $(grep -v '^#' .env | xargs)
+else 
+  echo ".env file not found"
+  exit 1
+fi
+
+# Set the network-specific contract address and chain ID
+CONTRACT_ADDRESS=""
+ASSIGNER_CONTRACT_ADDRESS=""
+CHAIN_ID=""
+
+case $NETWORK in
+  "base")
+    CONTRACT_ADDRESS=$BASE_PATCHWORK_ADDRESS
+    ASSIGNER_CONTRACT_ADDRESS=$BASE_PATCHWORK_ASSIGNER_ADDRESS
+    CHAIN_ID=$BASE_CHAIN_ID
+    ;;
+  "sepolia")
+    CONTRACT_ADDRESS=$SEPOLIA_PATCHWORK_ADDRESS
+    ASSIGNER_CONTRACT_ADDRESS=$SEPOLIA_PATCHWORK_ASSIGNER_ADDRESS
+    CHAIN_ID=$SEPOLIA_CHAIN_ID
+    ;;
+  *)
+    echo "Network not supported"
+    exit 1
+    ;;
+esac
+
+
+COMPILER_VERSION="0.8.23+commit.f704f362"
+OPTIMIZER_RUNS=200
+
+forge verify-contract $ASSIGNER_CONTRACT_ADDRESS src/PatchworkProtocolAssigner.sol:PatchworkProtocolAssigner \
+                      --constructor-args "0x0000000000000000000000007239aec2fa59303ba68bece386be2a9ddc72e63b" \
+                      --chain-id $CHAIN_ID \
+                      --compiler-version $COMPILER_VERSION \
+                      --optimizer-runs $OPTIMIZER_RUNS \
+                      --etherscan-api-key $ETHERSCAN_API_KEY \
+                      --watch
+
+CLEANED_ASSIGNER_CONTRACT_ADDRESS=$(echo "$ASSIGNER_CONTRACT_ADDRESS" | sed 's/^0x//')
+
+forge verify-contract $CONTRACT_ADDRESS src/PatchworkProtocol.sol:PatchworkProtocol \
+                      --constructor-args "0x0000000000000000000000007239aec2fa59303ba68bece386be2a9ddc72e63b000000000000000000000000$CLEANED_ASSIGNER_CONTRACT_ADDRESS"\
+                      --chain-id $CHAIN_ID \
+                      --compiler-version $COMPILER_VERSION \
+                      --optimizer-runs $OPTIMIZER_RUNS \
+                      --etherscan-api-key $ETHERSCAN_API_KEY \
+                      --watch
+

remappings.txt

@@ -1,3 +1,2 @@
 @openzeppelin/=lib/openzeppelin-contracts/
-@patchwork/=src/
 forge-std/=lib/forge-std/src/

src/Patchwork1155Patch.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import "./Patchwork721.sol";
+import "./interfaces/IPatchwork1155Patch.sol";
+
+/**
+@title Patchwork1155Patch
+@dev Base implementation of IPatchwork1155Patch
+@dev It extends the functionalities of Patchwork721 and implements the IPatchwork1155Patch interface.
+*/
+abstract contract Patchwork1155Patch is Patchwork721, IPatchwork1155Patch {
+
+    /// @dev Mapping from token ID to the canonical address of the NFT that this patch is applied to.
+    mapping(uint256 => PatchTarget) internal _targetsById;
+
+    /**
+    @dev See {IERC165-supportsInterface}
+    */
+    function supportsInterface(bytes4 interfaceID) public view virtual override returns (bool) {
+        return interfaceID == type(IPatchwork1155Patch).interfaceId ||
+        super.supportsInterface(interfaceID); 
+    }
+
+    /**
+    @notice stores a patch
+    @param tokenId the tokenId of the patch
+    @param target the patch target
+    */
+    function _storePatch(uint256 tokenId, PatchTarget memory target) internal virtual {
+        _targetsById[tokenId] = target;
+    }
+
+    /**
+    @dev See {ERC721-_burn}
+    */ 
+    function _burnPatch(uint256 tokenId) internal virtual {
+        PatchTarget storage target = _targetsById[tokenId];
+        address originalAddress = target.addr;
+        uint256 originalTokenId = target.tokenId;
+        address account = target.account;
+        IPatchworkProtocol(_manager).patchBurned1155(originalAddress, originalTokenId, account, address(this));
+        delete _targetsById[tokenId];
+        _burn(tokenId);
+    }
+}
+
+/**
+@title PatchworkReversible1155Patch
+@dev Patchwork1155Patch with reverse lookup function
+*/
+abstract contract PatchworkReversible1155Patch is Patchwork1155Patch, IPatchworkReversible1155Patch {
+    /// @dev Mapping of hash of original address + token ID + account for reverse lookups
+    mapping(bytes32 => uint256) internal _idsByTargetHash; // hash of patched addr+tokenid+account to tokenId
+
+    /**
+    @dev See {IERC165-supportsInterface}
+    */
+    function supportsInterface(bytes4 interfaceID) public view virtual override returns (bool) {
+        return interfaceID == type(IPatchworkReversible1155Patch).interfaceId ||
+        super.supportsInterface(interfaceID); 
+    }
+
+    /**
+    @dev See {IPatchwork1155Patch-getTokenIdByTarget}
+    */
+    function getTokenIdByTarget(PatchTarget memory target) public view virtual returns (uint256 tokenId) {
+        return _idsByTargetHash[keccak256(abi.encode(target))];
+    }
+
+    /**
+    @notice stores a patch
+    @param tokenId the tokenId of the patch
+    @param target the patch target
+    */
+    function _storePatch(uint256 tokenId, PatchTarget memory target) internal virtual override {
+        _targetsById[tokenId] = target;
+        _idsByTargetHash[keccak256(abi.encode(target))] = tokenId;
+    }
+
+    /**
+    @dev See {ERC721-_burn}
+    */ 
+    function _burnPatch(uint256 tokenId) internal virtual override {
+        PatchTarget storage target = _targetsById[tokenId];
+        delete _idsByTargetHash[keccak256(abi.encode(target))];
+        super._burnPatch(tokenId);
+    }
+}