Add scripts for ClaimableAirdrop

Author: ilitteri

claim_contracts/script/claimable_airdrop/ClaimableAirdropCreate2.s.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../src/ClaimableAirdropV1.sol";
+import "../../src/ClaimableAirdropV2Example.sol";
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract ClaimableAirdropCreate2 is Script {
+    function run(uint256 _version, bytes32 _salt, address _deployer) public {
+        address _create2Address;
+        if (_version == 1) {
+            _create2Address = vm.computeCreate2Address(
+                _salt,
+                keccak256(type(ClaimableAirdropV1).creationCode),
+                _deployer
+            );
+        } else if (_version == 2) {
+            _create2Address = vm.computeCreate2Address(
+                _salt,
+                keccak256(type(ClaimableAirdropV2Example).creationCode),
+                _deployer
+            );
+        } else {
+            revert("Unsupported version");
+        }
+
+        console.logAddress(_create2Address);
+
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/claimable_airdrop_v",
+                vm.toString(_version),
+                "_create2_address.hex"
+            ),
+            vm.toString(_create2Address)
+        );
+    }
+}

claim_contracts/script/claimable_airdrop/ClaimableAirdropInitData.s.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract AlignedTokenInitData is Script {
+    function run(
+        address _implementation,
+        uint256 _version,
+        address _safe,
+        address _tokenContractAddress,
+        address _tokenOwnerAddress,
+        uint256 _limitTimestampToClaim,
+        bytes32 _claimMerkleRoot
+    ) public {
+        bytes memory data = Utils.claimableAirdropInitData(
+            _implementation,
+            _version,
+            _safe,
+            _tokenContractAddress,
+            _tokenOwnerAddress,
+            _limitTimestampToClaim,
+            _claimMerkleRoot
+        );
+
+        console.logBytes(data);
+
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/claimable_airdrop_init_data.hex"
+            ),
+            vm.toString(data)
+        );
+    }
+}

claim_contracts/script/claimable_airdrop/ClaimableAirdropProxyCreate2.s.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract ClaimableAirdropnProxyCreate2 is Script {
+    function run(
+        bytes32 _salt,
+        address _deployer,
+        address _implementation,
+        uint256 _version,
+        address _safe,
+        address _tokenContractAddress,
+        address _tokenOwnerAddress,
+        uint256 _limitTimestampToClaim,
+        bytes32 _claimMerkleRoot
+    ) public {
+        address _create2Address = vm.computeCreate2Address(
+            _salt,
+            keccak256(
+                Utils.claimableAirdropProxyDeploymentData(
+                    _implementation,
+                    _version,
+                    _safe,
+                    _tokenContractAddress,
+                    _tokenOwnerAddress,
+                    _limitTimestampToClaim,
+                    _claimMerkleRoot
+                )
+            ),
+            _deployer
+        );
+        console.logAddress(_create2Address);
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/claimable_airdrop_proxy_create2_address.hex"
+            ),
+            vm.toString(_create2Address)
+        );
+    }
+}

claim_contracts/script/claimable_airdrop/ClaimableAirdropProxyDeploymentData.s.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract AlignedTokenProxyDeploymentData is Script {
+    function run(
+        address _implementation,
+        uint256 _version,
+        address _safe,
+        address _tokenContractAddress,
+        address _tokenOwnerAddress,
+        uint256 _limitTimestampToClaim,
+        bytes32 _claimMerkleRoot
+    ) public {
+        bytes memory data = Utils.claimableAirdropProxyDeploymentData(
+            _implementation,
+            _version,
+            _safe,
+            _tokenContractAddress,
+            _tokenOwnerAddress,
+            _limitTimestampToClaim,
+            _claimMerkleRoot
+        );
+        console.logBytes(data);
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/claimable_airdrop_proxy_deployment_data.hex"
+            ),
+            vm.toString(data)
+        );
+    }
+}

claim_contracts/script/claimable_airdrop/ClaimableAirdropUpgradeData.s.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract AlignedTokenUpgradeData is Script {
+    function run(
+        address _newImplementation,
+        uint256 _version,
+        address _safe,
+        address _beneficiary1,
+        address _beneficiary2,
+        address _beneficiary3,
+        uint256 _mintAmount
+    ) public {
+        bytes memory _upgradeData = Utils.alignedTokenUpgradeData(
+            _newImplementation,
+            _version,
+            _safe,
+            _beneficiary1,
+            _beneficiary2,
+            _beneficiary3,
+            _mintAmount
+        );
+        console.logBytes(_upgradeData);
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/aligned_token_upgrade_data.hex"
+            ),
+            vm.toString(_upgradeData)
+        );
+    }
+}

claim_contracts/script/claimable_airdrop/DeployClaimableAirdropImplementation.s.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../src/ClaimableAirdropV1.sol";
+import "../../src/ClaimableAirdropV2Example.sol";
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract DeployTokenImplementation is Script {
+    function run(uint256 _version) public {
+        address _implementation_address = Utils
+            .deployClaimableAirdropImplementation(_version);
+
+        console.log(
+            string.concat(
+                "Claimable Airdrop Implementation v",
+                vm.toString(_version),
+                "Address:"
+            ),
+            _implementation_address
+        );
+
+        vm.serializeAddress(
+            "implementation",
+            "address",
+            _implementation_address
+        );
+
+        string memory out;
+        if (_version == 1) {
+            out = vm.serializeBytes(
+                "implementation",
+                "deploymentData",
+                type(ClaimableAirdropV1).creationCode
+            );
+        } else if (_version == 2) {
+            out = vm.serializeBytes(
+                "implementation",
+                "deploymentData",
+                type(ClaimableAirdropV2Example).creationCode
+            );
+        } else {
+            revert("Unsupported version");
+        }
+
+        string memory path = string.concat(
+            vm.projectRoot(),
+            "/script-out/claimable_airdrop_implementation_v",
+            vm.toString(_version),
+            ".json"
+        );
+
+        vm.writeJson(out, path);
+    }
+}

claim_contracts/script/claimable_airdrop/DeployClaimableAirdropProxy.s.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract DeployAlignedTokenProxy is Script {
+    function run(
+        address _implementation,
+        uint256 _version,
+        address _safe,
+        address _tokenContractAddress,
+        address _tokenOwnerAddress,
+        uint256 _limitTimestampToClaim,
+        bytes32 _claimMerkleRoot
+    ) public {
+        bytes memory _proxyDeploymentData = Utils.claimableAirdropInitData(
+            _implementation,
+            _version,
+            _safe,
+            _tokenContractAddress,
+            _tokenOwnerAddress,
+            _limitTimestampToClaim,
+            _claimMerkleRoot
+        );
+        vm.broadcast();
+        ERC1967Proxy _proxy = new ERC1967Proxy(
+            _implementation,
+            _proxyDeploymentData
+        );
+        console.log("Claimable Airdrop Proxy Address:", address(_proxy));
+
+        vm.serializeAddress("proxy", "address", address(_proxy));
+        string memory _out = vm.serializeBytes(
+            "proxy",
+            "deploymentData",
+            Utils.claimableAirdropProxyDeploymentData(
+                _implementation,
+                _version,
+                _safe,
+                _tokenContractAddress,
+                _tokenOwnerAddress,
+                _limitTimestampToClaim,
+                _claimMerkleRoot
+            )
+        );
+        string memory _path = string.concat(
+            vm.projectRoot(),
+            "/script-out/claimable_airdrop_proxy.json"
+        );
+        vm.writeJson(_out, _path);
+    }
+}