feat: factory enhancements

.env.example

@@ -1,11 +1,2 @@
-export API_KEY_ALCHEMY="YOUR_API_KEY_ALCHEMY"
-export API_KEY_ARBISCAN="YOUR_API_KEY_ARBISCAN"
-export API_KEY_BSCSCAN="YOUR_API_KEY_BSCSCAN"
-export API_KEY_ETHERSCAN="YOUR_API_KEY_ETHERSCAN"
-export API_KEY_GNOSISSCAN="YOUR_API_KEY_GNOSISSCAN"
-export API_KEY_INFURA="YOUR_API_KEY_INFURA"
-export API_KEY_OPTIMISTIC_ETHERSCAN="YOUR_API_KEY_OPTIMISTIC_ETHERSCAN"
-export API_KEY_POLYGONSCAN="YOUR_API_KEY_POLYGONSCAN"
-export API_KEY_SNOWTRACE="YOUR_API_KEY_SNOWTRACE"
-export MNEMONIC="YOUR_MNEMONIC"
-export FOUNDRY_PROFILE="default"
+export TESTNET=true
+export HEX_PRIV_KEY="HEX_PRIV_KEY"

.gitignore

@@ -3,6 +3,7 @@ cache
 coverage
 node_modules
 out
+broadcast/**/dry-run/
 
 # files
 *.env
@@ -11,9 +12,4 @@ out
 .pnp.*
 lcov.info
 package-lock.json
-pnpm-lock.yaml
-
-# broadcasts
-!broadcast
-broadcast/*
-broadcast/*/31337/
+pnpm-lock.yaml

.solhint.json

@@ -1,7 +1,7 @@
 {
   "extends": "solhint:recommended",
   "rules": {
-    "code-complexity": ["error", 10],
+    "code-complexity": ["error", 12],
     "compiler-version": ["error", ">=0.8.25"],
     "func-name-mixedcase": "off",
     "func-visibility": ["error", { "ignoreConstructors": true }],

README.md

@@ -333,19 +333,27 @@ Get a test coverage report:
 $ forge coverage
 ```
 
-### Deploy
+### Deploy to Testnet
 
-Deploy to Anvil:
+Deploy to Base Testnet:
 
 ```sh
-$ forge script script/Deploy.s.sol --broadcast --fork-url http://localhost:8545
+$ forge script ./script/Testnet.s.sol -vvv --rpc-url basesepolia --broadcast
 ```
 
-For this script to work, you need to have a `MNEMONIC` environment variable set to a valid
-[BIP39 mnemonic](https://iancoleman.io/bip39/).
+Before deploying make sure you configure the neccessary variables in `.env` file. To just test the scripts with just a
+dry run remove the `--broadcast` flag.
 
-For instructions on how to deploy to a testnet or mainnet, check out the
-[Solidity Scripting](https://book.getfoundry.sh/tutorials/solidity-scripting.html) tutorial.
+### Verifying Contracts on Testnet Explorer
+
+Here is an example on how to verify a contract on base sepolia:
+
+```sh
+$ forge verify-contract <contract-address> <contract-name> --watch --etherscan-api-key <basescan-api-key>  --chain-id 84532 --constructor-args <encoded-constructor-args>
+```
+
+You can find the contract name and constructor args in the broadcast directory. To encode the constructor args you can
+use: https://abi.hashex.org/
 
 ### Format
 

broadcast/testnet.json

@@ -0,0 +1,8 @@
+{
+  "Factory": "0xe9d56BCB586055ceFCF4b6F2c2c1d6609FaF2220",
+  "LPTokenBeacon": "0xBee14A59a6320517C10CE1CEdC155A91D14d4707",
+  "StableAssetBeacon": "0xA3c7eD546862d36a05A54fC17698C77153A1a8CE",
+  "USDC": "0xA0a69B70015288515316D5DEd2e4D4f84bd11854",
+  "USDT": "0xA0AC882fD07D63C7e660a54729fDEF62a908Ac8D",
+  "WLPTokenBeacon": "0x1D7AdEBAd4b28C0BfD8A62cc4E66EE8D6b33e5BF"
+}

foundry.toml

@@ -20,23 +20,12 @@
     "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
     "forge-std/=node_modules/forge-std/src/",
   ]
+  fs_permissions = [{ access = "read-write", path = "./"}]
 
 [profile.ci]
   fuzz = { runs = 10_000 }
   verbosity = 4
 
-[etherscan]
-  arbitrum = { key = "${API_KEY_ARBISCAN}" }
-  avalanche = { key = "${API_KEY_SNOWTRACE}" }
-  base = { key = "${API_KEY_BASESCAN}" }
-  bnb_smart_chain = { key = "${API_KEY_BSCSCAN}" }
-  gnosis_chain = { key = "${API_KEY_GNOSISSCAN}" }
-  goerli = { key = "${API_KEY_ETHERSCAN}" }
-  mainnet = { key = "${API_KEY_ETHERSCAN}" }
-  optimism = { key = "${API_KEY_OPTIMISTIC_ETHERSCAN}" }
-  polygon = { key = "${API_KEY_POLYGONSCAN}" }
-  sepolia = { key = "${API_KEY_ETHERSCAN}" }
-
 [fmt]
   bracket_spacing = true
   int_types = "long"
@@ -59,3 +48,4 @@
   optimism = "https://optimism-mainnet.infura.io/v3/${API_KEY_INFURA}"
   polygon = "https://polygon-mainnet.infura.io/v3/${API_KEY_INFURA}"
   sepolia = "https://sepolia.infura.io/v3/${API_KEY_INFURA}"
+  basesepolia = "https://sepolia.base.org"

script/Config.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import { Script } from "forge-std/Script.sol";
+import { console } from "forge-std/console.sol";
+import { StableAssetFactory } from "../src/StableAssetFactory.sol";
+
+contract Config is Script {
+    bool testnet = vm.envBool("TESTNET");
+
+    uint256 deployerPrivateKey;
+    uint256 initialMinterPrivateKey;
+
+    address GOVERNANCE;
+    address DEPLOYER;
+    address INITIAL_MINTER;
+
+    address usdc;
+    address usdt;
+
+    StableAssetFactory factory;
+    address stableAssetBeacon;
+    address lpTokenBeacon;
+    address wlpTokenBeacon;
+
+    struct JSONData {
+        address Factory;
+        address LPTokenBeacon;
+        address StableAssetBeacon;
+        address USDC;
+        address USDT;
+        address WLPTokenBeacon;
+    }
+
+    function loadConfig() internal {
+        if (!testnet) {
+            usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
+            usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
+        }
+    }
+}

script/CreatePool.s.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import { stdJson } from "forge-std/StdJson.sol";
+import { console } from "forge-std/console.sol";
+
+import { Deploy } from "script/Deploy.sol";
+import { Setup } from "script/Setup.sol";
+import { Pool } from "script/Pool.sol";
+import { StableAssetFactory } from "../src/StableAssetFactory.sol";
+import { StableAsset } from "../src/StableAsset.sol";
+import { MockToken } from "../src/mock/MockToken.sol";
+
+contract Testnet is Deploy, Setup, Pool {
+    function init() internal {
+        if (vm.envUint("HEX_PRIV_KEY") == 0) revert("No private key found");
+        initialMinterPrivateKey = vm.envUint("HEX_PRIV_KEY");
+        INITIAL_MINTER = vm.addr(initialMinterPrivateKey);
+    }
+
+    function run() public payable {
+        init();
+        loadConfig();
+
+        vm.startBroadcast(initialMinterPrivateKey);
+
+        string memory root = vm.projectRoot();
+        string memory path;
+        if (testnet) {
+            path = string.concat(root, "/broadcast/testnet.json");
+        } else {
+            path = string.concat(root, "/broadcast/mainnet.json");
+        }
+
+        string memory json = vm.readFile(path);
+        bytes memory data = vm.parseJson(json);
+
+        JSONData memory jsonData = abi.decode(data, (JSONData));
+
+        factory = StableAssetFactory(jsonData.Factory);
+        stableAssetBeacon = jsonData.StableAssetBeacon;
+        lpTokenBeacon = jsonData.LPTokenBeacon;
+        wlpTokenBeacon = jsonData.WLPTokenBeacon;
+        usdc = jsonData.USDC;
+        usdt = jsonData.USDT;
+
+        (, address stableAsset,) = createStandardPool();
+
+        MockToken(usdc).mint(INITIAL_MINTER, 100e18);
+        MockToken(usdt).mint(INITIAL_MINTER, 100e18);
+
+        initialMintAndUnpause(100e18, 100e18, StableAsset(stableAsset));
+
+        vm.stopBroadcast();
+    }
+}

script/Deploy.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
+import { stdJson } from "forge-std/StdJson.sol";
+import { console } from "forge-std/console.sol";
+import { StableAsset } from "../src/StableAsset.sol";
+import { LPToken } from "../src/LPToken.sol";
+import { WLPToken } from "../src/WLPToken.sol";
+import { StableAssetFactory } from "../src/StableAssetFactory.sol";
+import { Config } from "script/Config.sol";
+import "../src/misc/ConstantExchangeRateProvider.sol";
+
+contract Deploy is Config {
+    function deployBeacons() internal {
+        console.log("---------------");
+        console.log("deploy-beacon-logs");
+        console.log("---------------");
+
+        address stableAssetImplentation = address(new StableAsset());
+        address lpTokenImplentation = address(new LPToken());
+        address wlpTokenImplentation = address(new WLPToken());
+
+        UpgradeableBeacon beacon = new UpgradeableBeacon(stableAssetImplentation);
+        beacon.transferOwnership(GOVERNANCE);
+        stableAssetBeacon = address(beacon);
+
+        beacon = new UpgradeableBeacon(lpTokenImplentation);
+        beacon.transferOwnership(GOVERNANCE);
+        lpTokenBeacon = address(beacon);
+
+        beacon = new UpgradeableBeacon(wlpTokenImplentation);
+        beacon.transferOwnership(GOVERNANCE);
+        wlpTokenBeacon = address(beacon);
+    }
+
+    function deployFactory() internal {
+        console.log("---------------");
+        console.log("deploy-factory-logs");
+        console.log("---------------");
+
+        factory = new StableAssetFactory();
+
+        factory.initialize(
+            GOVERNANCE,
+            0,
+            0,
+            0,
+            100,
+            stableAssetBeacon,
+            lpTokenBeacon,
+            wlpTokenBeacon,
+            new ConstantExchangeRateProvider()
+        );
+    }
+}

script/Pool.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import { Vm } from "forge-std/Vm.sol";
+import { stdJson } from "forge-std/StdJson.sol";
+import { console } from "forge-std/console.sol";
+import { Config } from "script/Config.sol";
+import { StableAssetFactory } from "../src/StableAssetFactory.sol";
+import { StableAsset } from "../src/StableAsset.sol";
+import { MockToken } from "../src/mock/MockToken.sol";
+
+contract Pool is Config {
+    function createStandardPool() internal returns (address, address, address) {
+        console.log("---------------");
+        console.log("create-pool-logs");
+        console.log("---------------");
+
+        StableAssetFactory.CreatePoolArgument memory arg = StableAssetFactory.CreatePoolArgument({
+            tokenA: usdc,
+            tokenB: usdt,
+            initialMinter: INITIAL_MINTER,
+            tokenBType: StableAssetFactory.TokenBType.Standard,
+            tokenBOracle: address(0),
+            tokenBFunctionSig: ""
+        });
+
+        vm.recordLogs();
+        factory.createPool(arg);
+        Vm.Log[] memory entries = vm.getRecordedLogs();
+        bytes32 eventSig = keccak256("PoolCreated(address,address,address)");
+
+        address decodedPoolToken;
+        address decodedStableAsset;
+        address decodedWrappedPoolToken;
+
+        for (uint256 i = 0; i < entries.length; i++) {
+            Vm.Log memory log = entries[i];
+
+            if (log.topics[0] == eventSig) {
+                (decodedPoolToken, decodedStableAsset, decodedWrappedPoolToken) =
+                    abi.decode(log.data, (address, address, address));
+            }
+        }
+
+        return (decodedPoolToken, decodedStableAsset, decodedWrappedPoolToken);
+    }
+
+    function initialMintAndUnpause(uint256 usdcAmount, uint256 usdtAmount, StableAsset stableAsset) internal {
+        console.log("---------------");
+        console.log("initial-mint-logs");
+        console.log("---------------");
+
+        MockToken(usdc).approve(address(factory), usdcAmount);
+        MockToken(usdt).approve(address(factory), usdtAmount);
+
+        uint256[] memory amounts = new uint256[](2);
+        amounts[0] = usdcAmount;
+        amounts[1] = usdtAmount;
+
+        stableAsset.mint(amounts, 0);
+        stableAsset.unpause();
+    }
+}