yieldnest · xhad · Sep 6, 2024 · Sep 5, 2024 · Sep 5, 2024
diff --git a/Makefile b/Makefile
@@ -8,12 +8,14 @@ local-factory :; forge script script/Deploy.s.sol:DeployVaultFactory \
 	--broadcast
 
 deploy-factory :; forge script script/Deploy.s.sol:DeployVaultFactory \
-	--account $(ACCOUNT_NAME) \
-	--rpc-url $(RPC_URL) \
-	--etherscan-api-key $(ETHERSCAN_KEY) \
+	--account ${ACCOUNT_NAME} \
+	--rpc-url ${RPC_URL} \
 	--verify \
 	--broadcast
 
-
-
-
+single-vault :;
+	cast send ${FACTORY_ADDRESS} \
+		"createSingleVault(address,string,string,address,uint256,address[],address[])" \
+		${ASSET_ADDRESS} "${VAULT_NAME}" "${VAULT_SYMBOL}" ${ADMIN_ADDRESS} ${MIN_DELAY} "[${PROPOSER_1},${PROPOSER_2}]" "[${EXECUTOR_1},${EXECUTOR_2}]" \
+		--account ${ACCOUNT_NAME} \
+		--rpc-url ${RPC_URL}
diff --git a/README.md b/README.md
@@ -9,17 +9,18 @@ This vault is the Base version used for pre-depositing assets ahead of settled D
 
 ## Test Deployment
 
-```
-anvil // --fork-url https://holesky-rpc
+See the makefile for deployment scripts. Deploy a factory first, then use it to deploy a new vault.
 
-export ACCOUNT_NAME=deployer
-make account
 
-export RPC_URL=
-export ETHERSCAN_KEY=
+## Contract Deployments
 
-make factory
-```
 
-This will deploy the factory, from which you can create a new vault.
+### BSC Testnet
+| Name | Address |
+|-----------------------|----------------------------------------------|
+| silsBNB               | [0x80815ee920bd9d856562633c36d3eb0e43cb15e2](https://testnet.bscscan.com/address/0x80815ee920bd9d856562633c36d3eb0e43cb15e2)   |
+| VaultFactory          | [0x964C6d4050e052D627b8234CAD9CdF0981E40EB3](https://testnet.bscscan.com/address/0x964C6d4050e052D627b8234CAD9CdF0981E40EB3)   |
+| SingleVault           | [0xa2aE2b28c578Fbd7C18B554E7aA388Bf6694a42c](https://testnet.bscscan.com/address/0xa2aE2b28c578Fbd7C18B554E7aA388Bf6694a42c)   |
+| ynBNB                 | [0x7e87787C22117374Fad2E3E2E8C6159f0875F92e](https://testnet.bscscan.com/address/0x7e87787c22117374fad2e3e2e8c6159f0875f92e)   |
+
 
diff --git a/broadcast/Deploy.s.sol/97/run-latest.json b/broadcast/Deploy.s.sol/97/run-latest.json
diff --git a/script/Actors.sol b/script/Actors.sol
@@ -1,70 +1,55 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity ^0.8.24;
-pragma solidity ^0.8.24;
 
 interface IActors {
     function ADMIN() external view returns (address);
-    function OPERATOR() external view returns (address);
     function UNAUTHORIZED() external view returns (address);
     function PROPOSER_1() external view returns (address);
     function PROPOSER_2() external view returns (address);
     function EXECUTOR_1() external view returns (address);
     function EXECUTOR_2() external view returns (address);
-    function KERNEL_VAULT() external view returns (address);
 }
 
 contract LocalActors is IActors {
     address public constant ADMIN = address(1);
-    address public constant OPERATOR = address(2);
     address public constant UNAUTHORIZED = address(3);
 
     address public constant PROPOSER_1 = address(1);
     address public constant PROPOSER_2 = address(2);
 
     address public constant EXECUTOR_1 = address(3);
     address public constant EXECUTOR_2 = address(4);
-
-    address public constant KERNEL_VAULT = address(420);
 }
 
 contract AnvilActors is IActors {
     address public constant ADMIN = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
-    address public constant OPERATOR = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8;
     address public constant UNAUTHORIZED = address(0);
 
     address public constant PROPOSER_1 = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
     address public constant PROPOSER_2 = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8;
 
     address public constant EXECUTOR_1 = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
     address public constant EXECUTOR_2 = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8;
-
-    address public constant KERNEL_VAULT = address(420);
 }
 
 contract HoleskyActors is IActors {
     address public constant ADMIN = 0x743b91CDB1C694D4F51bCDA3a4A59DcC0d02b913;
-    address public constant OPERATOR = 0x9Dd8F69b62ddFd990241530F47dcEd0Dad7f7d39;
     address public constant UNAUTHORIZED = address(0);
 
     address public constant PROPOSER_1 = 0x743b91CDB1C694D4F51bCDA3a4A59DcC0d02b913;
     address public constant PROPOSER_2 = 0x9Dd8F69b62ddFd990241530F47dcEd0Dad7f7d39;
 
     address public constant EXECUTOR_1 = 0x743b91CDB1C694D4F51bCDA3a4A59DcC0d02b913;
     address public constant EXECUTOR_2 = 0x9Dd8F69b62ddFd990241530F47dcEd0Dad7f7d39;
-
-    address public constant KERNEL_VAULT = address(420);
 }
 
 contract ChapelActors is IActors {
     address public constant ADMIN = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5;
-    address public constant OPERATOR = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5;
     address public constant UNAUTHORIZED = address(0);
 
-    address public constant PROPOSER_1 = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5;
-    address public constant PROPOSER_2 = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5;
-
-    address public constant EXECUTOR_1 = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5;
-    address public constant EXECUTOR_2 = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5;
+    address public constant PROPOSER_1 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404;
+    address public constant PROPOSER_2 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404;
 
-    address public constant KERNEL_VAULT = address(420);
+    address public constant EXECUTOR_1 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404;
+    address public constant EXECUTOR_2 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404;
 }
diff --git a/script/Contracts.sol b/script/Contracts.sol
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity ^0.8.24;
+
+interface IContracts {
+    function DEPLOY_FACTORY() external view returns (address);
+    function KERNEL_VAULT() external view returns (address);
+    function KARAK_VAULT() external view returns (address);
+}
+
+contract ChapelContracts {
+    address public constant DEPLOY_FACTORY = 0x964C6d4050e052D627b8234CAD9CdF0981E40EB3;
+    address public constant KERNEL_VAULT = 0x0000000000000000000000000000000000000000;
+    address public constant KARAK_VAULT = 0x0000000000000000000000000000000000000000;
+}
diff --git a/script/Deploy.s.sol b/script/Deploy.s.sol
@@ -6,6 +6,7 @@ import "lib/forge-std/src/Script.sol";
 import {VaultFactory} from "src/VaultFactory.sol";
 import {AnvilActors, HoleskyActors, ChapelActors, IActors} from "script/Actors.sol";
 import {SingleVault} from "src/SingleVault.sol";
+import {TransparentUpgradeableProxy} from "src/Common.sol";
 
 contract DeployVaultFactory is Script {
     function run() public {

diff --git a/src/VaultFactory.sol b/src/VaultFactory.sol
@@ -19,7 +19,6 @@ contract VaultFactory is AccessControlUpgradeable {
     address public multiVaultImpl;
 
     struct Vault {
-        address vault;
         address timelock;
         string name;
         string symbol;
@@ -31,12 +30,11 @@ contract VaultFactory is AccessControlUpgradeable {
         MultiAsset
     }
 
-    mapping(string => Vault) public vaults;
+    mapping(address => Vault) public vaults;
 
     event NewVault(address indexed vault, string name, string symbol, VaultType vaultType);
     event SetVersion(address indexed implementation, VaultType vaultType);
 
-    error SymbolUsed();
     error ZeroAddress();
 
     /**
@@ -82,16 +80,14 @@ contract VaultFactory is AccessControlUpgradeable {
         address[] memory proposers_,
         address[] memory executors_
     ) public onlyRole(DEFAULT_ADMIN_ROLE) returns (address) {
-        if (vaults[symbol_].vault != address(0)) revert SymbolUsed();
-
         string memory funcSig = "initialize(address,string,string,address,uint256,address[],address[])";
 
         TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(
             singleVaultImpl,
             address(timelock),
             abi.encodeWithSignature(funcSig, asset_, name_, symbol_, admin_, minDelay_, proposers_, executors_)
         );
-        vaults[symbol_] = Vault(address(proxy), address(timelock), name_, symbol_, VaultType.SingleAsset);
+        vaults[address(proxy)] = Vault(address(timelock), name_, symbol_, VaultType.SingleAsset);
 
         // bootstrap 1 ether of underlying to prevent donation attacks
         IERC20(asset_).approve(address(proxy), 1 ether);

diff --git a/test/factory/create.t.sol b/test/factory/create.t.sol
@@ -31,8 +31,8 @@ contract CreateTest is Test, LocalActors, TestConstants {
         asset.transfer(address(factory), 1 ether);
         address vault =
             factory.createSingleVault(asset, VAULT_NAME, VAULT_SYMBOL, ADMIN, minDelay, proposers, executors);
-        (address vaultAddress,,,,) = factory.vaults(VAULT_SYMBOL);
-        assertEq(vaultAddress, vault, "Vault address should match the expected address");
+        (,, string memory symbol,) = factory.vaults(vault);
+        assertEq(symbol, VAULT_SYMBOL, "Vault timelock should match the expected address");
     }
 
     function testVaultFactoryAdmin() public view {

diff --git a/test/mocks/DeployMockERC20.s.sol b/test/mocks/DeployMockERC20.s.sol
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity ^0.8.24;
+
+import {Script} from "forge-std/Script.sol";
+import {MockERC20} from "test/mocks/MockERC20.sol";
+
+contract DeployMockERC20 is Script {
+    function run() external {
+        string memory name = "Mock slisBNB";
+        string memory symbol = "slisBNB";
+
+        vm.startBroadcast();
+        new MockERC20(name, symbol);
+        vm.stopBroadcast();
+    }
+}
diff --git a/test/single/access.t.sol b/test/single/access.t.sol
@@ -39,8 +39,8 @@ contract AccessControlTest is Test, LocalActors, TestConstants {
 
     function testAdminCanGrantRole() public {
         vm.startPrank(ADMIN);
-        vault.grantRole(vault.DEFAULT_ADMIN_ROLE(), OPERATOR);
-        assertEq(vault.hasRole(vault.DEFAULT_ADMIN_ROLE(), OPERATOR), true);
+        vault.grantRole(vault.DEFAULT_ADMIN_ROLE(), address(1));
+        assertEq(vault.hasRole(vault.DEFAULT_ADMIN_ROLE(), address(1)), true);
     }
 
     function skip_testNonAdminCannotGrantRole() public {
@@ -55,8 +55,8 @@ contract AccessControlTest is Test, LocalActors, TestConstants {
 
     function testAdminCanRevokeRole() public {
         vm.startPrank(ADMIN);
-        vault.revokeRole(vault.DEFAULT_ADMIN_ROLE(), OPERATOR);
-        assertFalse(vault.hasRole(vault.DEFAULT_ADMIN_ROLE(), OPERATOR));
+        vault.revokeRole(vault.DEFAULT_ADMIN_ROLE(), address(1));
+        assertFalse(vault.hasRole(vault.DEFAULT_ADMIN_ROLE(), address(1)));
     }
 
     function skip_testNonAdminCannotRevokeRole() public {
@@ -66,6 +66,6 @@ contract AccessControlTest is Test, LocalActors, TestConstants {
                 IAccessControl.AccessControlUnauthorizedAccount.selector, UNAUTHORIZED, vault.DEFAULT_ADMIN_ROLE()
             )
         );
-        vault.revokeRole(vault.DEFAULT_ADMIN_ROLE(), OPERATOR);
+        vault.revokeRole(vault.DEFAULT_ADMIN_ROLE(), address(1));
     }
 }
diff --git a/test/single/admin.t.sol b/test/single/admin.t.sol
@@ -6,11 +6,12 @@ import {SingleVault} from "src/SingleVault.sol";
 import {IERC20, TimelockControllerUpgradeable} from "src/Common.sol";
 import {MockERC20} from "test/mocks/MockERC20.sol";
 import {LocalActors} from "script/Actors.sol";
+import {ChapelContracts} from "script/Contracts.sol";
 import {TestConstants} from "test/helpers/Constants.sol";
 import {DeployFactory, VaultFactory} from "test/helpers/DeployFactory.sol";
 import {SingleVault, ISingleVault} from "src/SingleVault.sol";
 
-contract TimelockTest is Test, LocalActors, TestConstants {
+contract TimelockTest is Test, LocalActors, TestConstants, ChapelContracts {
     SingleVault public vault;
     IERC20 public asset;
 
@@ -43,7 +44,8 @@ contract TimelockTest is Test, LocalActors, TestConstants {
         // schedule a transaction
         address target = address(asset);
         uint256 value = 0;
-        bytes memory data = abi.encodeWithSelector(IERC20.transfer.selector, KERNEL_VAULT, shares);
+        address kernelVault = address(3);
+        bytes memory data = abi.encodeWithSelector(IERC20.transfer.selector, kernelVault, shares);
         bytes32 predecessor = bytes32(0);
         bytes32 salt = keccak256("chad");
         uint256 delay = 1;
@@ -62,14 +64,14 @@ contract TimelockTest is Test, LocalActors, TestConstants {
         assertEq(vault.isOperationDone(id), false);
         assertEq(vault.isOperation(id), true);
 
-        uint256 previousBalance = asset.balanceOf(KERNEL_VAULT);
+        uint256 previousBalance = asset.balanceOf(kernelVault);
 
         //execute the transaction
         vm.warp(10);
         vm.startPrank(EXECUTOR_1);
         vault.execute(target, value, data, predecessor, salt);
 
-        uint256 currentBalance = asset.balanceOf(KERNEL_VAULT);
+        uint256 currentBalance = asset.balanceOf(kernelVault);
         uint256 expectedBalance = currentBalance - previousBalance;
 
         // // Verify the transaction was executed successfully