Add scripts for AlignedToken

Author: ilitteri

claim_contracts/script/aligned_token/AlignedTokenCreate2.s.sol

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

claim_contracts/script/aligned_token/AlignedTokenInitData.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 AlignedTokenInitData is Script {
+    function run(
+        address _implementation,
+        uint256 _version,
+        address _safe,
+        address _beneficiary1,
+        address _beneficiary2,
+        address _beneficiary3,
+        uint256 _mintAmount
+    ) public {
+        bytes memory data = Utils.alignedTokenInitData(
+            _implementation,
+            _version,
+            _safe,
+            _beneficiary1,
+            _beneficiary2,
+            _beneficiary3,
+            _mintAmount
+        );
+        console.logBytes(data);
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/aligned_token_init_data.hex"
+            ),
+            vm.toString(data)
+        );
+    }
+}

claim_contracts/script/aligned_token/AlignedTokenProxyCreate2.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 AlignedTokenProxyCreate2 is Script {
+    function run(
+        bytes32 _salt,
+        address _deployer,
+        address _implementation,
+        uint256 _version,
+        address _safe,
+        address _beneficiary1,
+        address _beneficiary2,
+        address _beneficiary3,
+        uint256 _mintAmount
+    ) public {
+        address _create2Address = vm.computeCreate2Address(
+            _salt,
+            keccak256(
+                Utils.alignedTokenProxyDeploymentData(
+                    _implementation,
+                    _version,
+                    _safe,
+                    _beneficiary1,
+                    _beneficiary2,
+                    _beneficiary3,
+                    _mintAmount
+                )
+            ),
+            _deployer
+        );
+        console.logAddress(_create2Address);
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/aligned_token_proxy_create2_address.hex"
+            ),
+            vm.toString(_create2Address)
+        );
+    }
+}

claim_contracts/script/aligned_token/AlignedTokenProxyDeploymentData.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 _beneficiary1,
+        address _beneficiary2,
+        address _beneficiary3,
+        uint256 _mintAmount
+    ) public {
+        bytes memory data = Utils.alignedTokenProxyDeploymentData(
+            _implementation,
+            _version,
+            _safe,
+            _beneficiary1,
+            _beneficiary2,
+            _beneficiary3,
+            _mintAmount
+        );
+        console.logBytes(data);
+        vm.writeFile(
+            string.concat(
+                vm.projectRoot(),
+                "/script-out/aligned_token_proxy_deployment_data.hex"
+            ),
+            vm.toString(data)
+        );
+    }
+}

claim_contracts/script/aligned_token/AlignedTokenUpgradeData.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/aligned_token/DeployAlignedTokenImplementation.s.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../src/AlignedTokenV1.sol";
+import "../../src/AlignedTokenV2Example.sol";
+import "forge-std/Script.sol";
+import {Utils} from "../Utils.sol";
+
+contract DeployTokenImplementation is Script {
+    function run(uint256 _version) public {
+        address _implementation_address = Utils
+            .deployAlignedTokenImplementation(_version);
+
+        console.log(
+            string.concat(
+                "Token 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(AlignedTokenV1).creationCode
+            );
+        } else if (_version == 2) {
+            out = vm.serializeBytes(
+                "implementation",
+                "deploymentData",
+                type(AlignedTokenV2Example).creationCode
+            );
+        } else {
+            revert("Unsupported version");
+        }
+
+        string memory path = string.concat(
+            vm.projectRoot(),
+            "/script-out/aligned_token_implementation_v",
+            vm.toString(_version),
+            ".json"
+        );
+
+        vm.writeJson(out, path);
+    }
+}

claim_contracts/script/aligned_token/DeployAlignedTokenProxy.s.sol

@@ -0,0 +1,55 @@
+// 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 _beneficiary1,
+        address _beneficiary2,
+        address _beneficiary3,
+        uint256 _mintAmount
+    ) public {
+        bytes memory _deploymentData = Utils.alignedTokenInitData(
+            _implementation,
+            _version,
+            _safe,
+            _beneficiary1,
+            _beneficiary2,
+            _beneficiary3,
+            _mintAmount
+        );
+        vm.broadcast();
+        ERC1967Proxy _proxy = new ERC1967Proxy(
+            _implementation,
+            _deploymentData
+        );
+
+        console.log("Aligned Token Proxy Address:", address(_proxy));
+
+        vm.serializeAddress("proxy", "address", address(_proxy));
+        string memory _out = vm.serializeBytes(
+            "proxy",
+            "deploymentData",
+            Utils.alignedTokenProxyDeploymentData(
+                _implementation,
+                _version,
+                _safe,
+                _beneficiary1,
+                _beneficiary2,
+                _beneficiary3,
+                _mintAmount
+            )
+        );
+        string memory _path = string.concat(
+            vm.projectRoot(),
+            "/script-out/aligned_token_proxy.json"
+        );
+        vm.writeJson(_out, _path);
+    }
+}

claim_contracts/script/aligned_token/UpgradeAlignedTokenImplementation.s.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../src/AlignedTokenV1.sol";
+import "../src/AlignedTokenV2Example.sol";
+import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import "forge-std/Script.sol";
+import {Utils} from "./Utils.sol";
+
+contract UpgradeAlignedTokenImplementation is Script {
+    function run(
+        address _proxy,
+        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
+        );
+
+        vm.broadcast();
+        _proxy.call(_upgradeData);
+    }
+}