From 77df862c3eb503e3ad08941954815f0b2e5923ea Mon Sep 17 00:00:00 2001 From: fxp3 Date: Sat, 13 Jul 2024 23:04:01 +0300 Subject: [PATCH] chore: remove gate logic and unused imports --- .vscode/snippets-sol.code-snippets | 108 +------- .../arbitrum-fork/params-arbitrum-fork.json | 4 +- .../params-arbitrum-sepolia.json | 4 +- .../deploy/arbitrum/params-arbitrum.json | 4 +- .../deploy/localhost/params-localhost.json | 8 +- .../deploy/test/params-test-audit.json | 8 +- .../foundry/deploy/test/params-test-base.json | 8 +- .../deploy/test/params-test-clean.json | 8 +- configs/hardhat/deploy/arbitrumSepolia.ts | 16 +- configs/hardhat/deploy/index.ts | 8 +- lib/kresko-lib | 2 +- src/contracts/core/common/Auth.sol | 1 - src/contracts/core/common/Errors.sol | 3 - src/contracts/core/common/Modifiers.sol | 11 +- src/contracts/core/common/Types.sol | 1 - .../core/common/facets/CommonConfigFacet.sol | 6 - .../core/common/facets/CommonStateFacet.sol | 5 - .../common/interfaces/ICommonConfigFacet.sol | 6 - .../common/interfaces/ICommonStateFacet.sol | 3 - .../facets/MinterDepositWithdrawFacet.sol | 2 +- .../core/minter/facets/MinterMintFacet.sol | 10 +- .../core/periphery/GatingManager.sol | 120 --------- .../core/periphery/IErrorsEvents.sol | 3 - src/contracts/core/periphery/ViewData.sol | 18 -- .../core/periphery/facets/ViewDataFacet.sol | 4 - .../periphery/interfaces/IViewDataFacet.sol | 2 - src/contracts/core/scdp/facets/SCDPFacet.sol | 13 +- .../core/test/AggregatorV3Normalizer.sol | 52 ---- src/contracts/core/test/mocks/MockERC1155.sol | 29 --- src/contracts/core/test/mocks/MockERC20.sol | 115 --------- .../{ => core/test}/mocks/MockLogic.sol | 0 .../test}/mocks/MockMarketStatus.sol | 0 src/contracts/core/test/mocks/MockOracle.sol | 49 ---- .../test/mocks/MockSequencerUptimeFeed.sol | 38 --- src/contracts/core/test/mocks/Mocks.sol | 8 + src/contracts/scripts/SafeExample.s.sol | 3 +- src/contracts/scripts/deploy/CONST.s.sol | 1 - src/contracts/scripts/deploy/Deploy.s.sol | 89 ++----- src/contracts/scripts/deploy/DeployBase.s.sol | 63 ++--- .../scripts/deploy/DeployFuncs.s.sol | 54 ---- src/contracts/scripts/deploy/JSON.s.sol | 26 +- .../scripts/deploy/libs/Deployed.s.sol | 3 +- .../scripts/deploy/libs/LibDeploy.s.sol | 38 +-- .../scripts/deploy/libs/LibDeployUtils.s.sol | 3 +- .../scripts/deploy/libs/LibJSON.s.sol | 3 +- .../scripts/deploy/libs/LibMocks.s.sol | 5 +- .../scripts/tasks/DeployPeriphery.s.sol | 3 +- src/contracts/scripts/tasks/DiamondCuts.s.sol | 6 +- src/contracts/scripts/utils/ArbScript.s.sol | 10 +- src/contracts/scripts/utils/AssetAdder.s.sol | 3 +- src/contracts/scripts/utils/DiamondBomb.sol | 1 + src/contracts/test/AddKrAsset.t.sol | 11 +- src/contracts/test/BatchTest.t.sol | 14 +- src/contracts/test/Complex.t.sol | 54 ++-- src/contracts/test/DeploymentFactory.t.sol | 2 +- src/contracts/test/ICDP.t.sol | 20 +- src/contracts/test/Meta.t.sol | 5 +- src/contracts/test/Multicall.t.sol | 38 ++- src/contracts/test/Pyth.t.sol | 7 +- src/contracts/test/SCDP.t.sol | 46 ++-- src/contracts/test/Vault.t.sol | 5 +- src/contracts/test/forked/GateTest.t.sol | 232 ------------------ .../test/forked/MarketStatusTest.t.sol | 6 +- .../test/forked/MulticallUpdate.t.sol | 7 +- src/deploy/local/02-add-facets.ts | 10 +- src/test/diamond/03-protocol.ts | 3 +- src/test/minter/06-gating.ts | 148 ----------- src/types/index.ts | 210 ++++++++-------- 68 files changed, 330 insertions(+), 1476 deletions(-) delete mode 100644 src/contracts/core/periphery/GatingManager.sol delete mode 100644 src/contracts/core/test/AggregatorV3Normalizer.sol delete mode 100644 src/contracts/core/test/mocks/MockERC1155.sol delete mode 100644 src/contracts/core/test/mocks/MockERC20.sol rename src/contracts/{ => core/test}/mocks/MockLogic.sol (100%) rename src/contracts/{ => core/test}/mocks/MockMarketStatus.sol (100%) delete mode 100644 src/contracts/core/test/mocks/MockOracle.sol delete mode 100644 src/contracts/core/test/mocks/MockSequencerUptimeFeed.sol create mode 100644 src/contracts/core/test/mocks/Mocks.sol delete mode 100644 src/contracts/scripts/deploy/DeployFuncs.s.sol delete mode 100644 src/contracts/test/forked/GateTest.t.sol delete mode 100644 src/test/minter/06-gating.ts diff --git a/.vscode/snippets-sol.code-snippets b/.vscode/snippets-sol.code-snippets index 0546e3d8..8be7da77 100644 --- a/.vscode/snippets-sol.code-snippets +++ b/.vscode/snippets-sol.code-snippets @@ -35,13 +35,13 @@ "pragma solidity ^0.8.0;", "", "import {Deployed} from \"scripts/deploy/libs/Deployed.s.sol\";", - "import {Log, Help} from \"kresko-lib/utils/s/LibVm.s.sol\";", + "import {Log, Utils} from \"kresko-lib/utils/s/LibVm.s.sol\";", "import {ShortAssert} from \"kresko-lib/utils/s/ShortAssert.t.sol\";", "import {Tested} from \"kresko-lib/utils/s/Tested.t.sol\";", "", "contract TestSnip is Tested {", " using Log for *;", - " using Help for *;", + " using Utils for *;", " using Deployed for *;", " using ShortAssert for *;", "", @@ -57,109 +57,5 @@ "}" ], "description": "Base for a new forge test using workspace utils" - }, - "kresko: forge test template with protocol deployment": { - "isFileTemplate": true, - "prefix": "kresko_forge_test_protocol_template", - "scope": "solidity", - "body": [ - "// solhint-disable state-visibility, max-states-count, no-empty-blocks, no-console", - "// SPDX-License-Identifier: MIT", - "pragma solidity ^0.8.0;", - "", - "import {Deployed} from \"scripts/deploy/libs/Deployed.s.sol\";", - "import {Deploy} from \"scripts/deploy/Deploy.s.sol\";", - "import {Log, Help} from \"kresko-lib/utils/Libs.s.sol\";", - "import {ShortAssert} from \"kresko-lib/utils/ShortAssert.t.sol\";", - "import {IKrMulticall} from \"periphery/IKrMulticall.sol\";", - "import {Tested} from \"kresko-lib/utils/Tested.t.sol\";", - "", - "contract TestSnip is Tested, Deploy {", - " using Log for *;", - " using Help for *;", - " using Deployed for *;", - " using ShortAssert for *;", - "", - "", - " address krETH;", - " address admin;", - "", - " function setUp() public {", - " admin = Deploy.deployTest(\"MNEMONIC_DEVNET\", \"test-base\", 0).params.common.admin;", - " krETH = (\"krETH\").addr();", - " }", - "", - " function testTheThing() public {", - " prank(admin);", - "", - " weth.approve(krETH, type(uint256).max);", - "", - " admin.notEq(address(0), \"admin-address-0\");", - " admin.clg(\"admin-address\");", - " }", - "}" - ], - "description": "Base for a new forge test using minimal protocol deployment" - }, - "kresko: forge script template": { - "isFileTemplate": true, - "prefix": "kresko_script_template", - "scope": "solidity", - "body": [ - "// solhint-disable state-visibility", - "// SPDX-License-Identifier: MIT", - "pragma solidity ^0.8.0;", - "", - "import {Scripted} from \"kresko-lib/utils/Scripted.s.sol\";", - "import {Help, Log} from \"kresko-lib/utils/Libs.s.sol\";", - "import {IDataV1} from \"periphery/interfaces/IDataV1.sol\";", - "import {Deployed} from \"scripts/deploy/libs/Deployed.s.sol\";", - "import {IDeploymentFactory} from \"factory/IDeploymentFactory.sol\";", - "import {IKreskoAssetAnchor} from \"kresko-asset/IKreskoAssetAnchor.sol\";", - "import {MockERC20} from \"mocks/MockERC20.sol\";", - "import {IKreskoAsset} from \"kresko-asset/IKreskoAsset.sol\";", - "import {IExtendedDiamondCutFacet} from \"diamond/interfaces/IDiamondCutFacet.sol\";", - "import {IKresko} from \"periphery/IKresko.sol\";", - "import {IKISS} from \"kiss/interfaces/IKISS.sol\";", - "import {IVault} from \"vault/interfaces/IVault.sol\";", - "import {IKrMulticall} from \"periphery/IKrMulticall.sol\";", - "", - "contract ScriptSnip is Scripted {", - " using Log for *;", - " using Help for *;", - " using Deployed for *;", - " IDeploymentFactory factory;", - " IKresko kresko;", - " IExtendedDiamondCutFacet diamond;", - " IKreskoAsset krETH;", - " IKreskoAssetAnchor akrETH;", - " IDataV1 datav1;", - " IVault vault;", - " IKISS kiss;", - " IKrMulticall multicall;", - " MockERC20 token;", - "", - " function init() private {", - " vm.createSelectFork(\"arbitrumSepolia\");", - "", - " useMnemonic(\"MNEMONIC_DEVNET\");", - "", - " kresko = IKresko(Deployed.addr(\"Kresko\"));", - "", - " multicall = IKrMulticall(Deployed.addr(\"Multicall\"));", - " diamond = IExtendedDiamondCutFacet(address(kresko));", - " vault = IVault(Deployed.addr(\"Vault\"));", - " datav1 = IDataV1(Deployed.addr(\"DataV1\"));", - " krETH = IKreskoAsset(Deployed.addr(\"krETH\"));", - " akrETH = IKreskoAssetAnchor(Deployed.addr(\"akrETH\"));", - " }", - "", - " function run() public {", - " init();", - " // do the thing", - " }", - "}" - ], - "description": "Base for a new forge script using live protocol" } } diff --git a/configs/foundry/deploy/arbitrum-fork/params-arbitrum-fork.json b/configs/foundry/deploy/arbitrum-fork/params-arbitrum-fork.json index 6f7a72c9..8fbe37e9 100644 --- a/configs/foundry/deploy/arbitrum-fork/params-arbitrum-fork.json +++ b/configs/foundry/deploy/arbitrum-fork/params-arbitrum-fork.json @@ -9,7 +9,6 @@ "04_oracleDecimals": 8, "05_sequencerGracePeriodTime": 3600, "06_sequencerUptimeFeed": "0xFdB631F5EE196F0ed6FAa767959853A9F217697D", - "07_gatingManager": "0x0000000000000000000000000000000000000000", "08_pythEndpoint": "0xff1a0f4744e8582DF1aE09D5611b887B6a12925C", "09_marketStatusProvider": "0x0000000000000000000000000000000000000000" }, @@ -29,6 +28,5 @@ "01_questForKreskNFT": "0x1C04925779805f2dF7BbD0433ABE92Ea74829bF6", "02_V3SwapRouter02": "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", "03_UniswapQuoterV2": "0x61fFE014bA17989E743c5F6cB21bF9697530B21e" - }, - "06_gatingPhase": 0 + } } \ No newline at end of file diff --git a/configs/foundry/deploy/arbitrum-sepolia/params-arbitrum-sepolia.json b/configs/foundry/deploy/arbitrum-sepolia/params-arbitrum-sepolia.json index 362ad748..2a1a507a 100644 --- a/configs/foundry/deploy/arbitrum-sepolia/params-arbitrum-sepolia.json +++ b/configs/foundry/deploy/arbitrum-sepolia/params-arbitrum-sepolia.json @@ -9,7 +9,6 @@ "04_oracleDecimals": 8, "05_sequencerGracePeriodTime": 3600, "06_sequencerUptimeFeed": "0x23ab08d87BBAe90e8BDe56F87ad6e53683E08279", - "07_gatingManager": "0x0000000000000000000000000000000000000000", "08_pythEndpoint": "0x4374e5a8b9C22271E9EB878A2AA31DE97DF15DAF", "09_marketStatusProvider": "0x0000000000000000000000000000000000000000" }, @@ -29,6 +28,5 @@ "01_questForKreskNFT": "0x200945e331Af88e1D854Cb9D3503F257B33Fe19F", "02_V3SwapRouter02": "0x021dAc9a7652A2C010AD4B4f412E2DEbBE76481a", "03_UniswapQuoterV2": "0x2779a0CC1c3e0E44D2542EC3e79e3864Ae93Ef0B" - }, - "06_gatingPhase": 1 + } } \ No newline at end of file diff --git a/configs/foundry/deploy/arbitrum/params-arbitrum.json b/configs/foundry/deploy/arbitrum/params-arbitrum.json index 12659f07..7690c385 100644 --- a/configs/foundry/deploy/arbitrum/params-arbitrum.json +++ b/configs/foundry/deploy/arbitrum/params-arbitrum.json @@ -9,7 +9,6 @@ "04_oracleDecimals": 8, "05_sequencerGracePeriodTime": 3600, "06_sequencerUptimeFeed": "0xFdB631F5EE196F0ed6FAa767959853A9F217697D", - "07_gatingManager": "0x00000000685B935476005E6A7ed5E1Bf3C000B12", "08_pythEndpoint": "0xff1a0f4744e8582DF1aE09D5611b887B6a12925C", "09_marketStatusProvider": "0xf6188e085ebEB716a730F8ecd342513e72C8AD04" }, @@ -29,6 +28,5 @@ "01_questForKreskNFT": "0x1C04925779805f2dF7BbD0433ABE92Ea74829bF6", "02_V3SwapRouter02": "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", "03_UniswapQuoterV2": "0x61fFE014bA17989E743c5F6cB21bF9697530B21e" - }, - "06_gatingPhase": 4 + } } \ No newline at end of file diff --git a/configs/foundry/deploy/localhost/params-localhost.json b/configs/foundry/deploy/localhost/params-localhost.json index dc4bd073..90f09ff4 100644 --- a/configs/foundry/deploy/localhost/params-localhost.json +++ b/configs/foundry/deploy/localhost/params-localhost.json @@ -9,9 +9,8 @@ "04_oracleDecimals": 8, "05_sequencerGracePeriodTime": 3600, "06_sequencerUptimeFeed": "0x0000000000000000000000000000000000000000", - "07_gatingManager": "0x0000000000000000000000000000000000000000", - "08_pythEndpoint": "0x0000000000000000000000000000000000000000", - "09_marketStatusProvider": "0x0000000000000000000000000000000000000000" + "07_pythEndpoint": "0x0000000000000000000000000000000000000000", + "08_marketStatusProvider": "0x0000000000000000000000000000000000000000" }, "03_scdp": { "00_minCollateralRatio": 250e2, @@ -29,6 +28,5 @@ "01_questForKreskNFT": "0xDF01B2D0cBd99DbeECd1fE3f7F42C8307A0c3B5a", "02_V3SwapRouter02": "0x0000000000000000000000000000000000000000", "03_UniswapQuoterV2": "0x0000000000000000000000000000000000000000" - }, - "06_gatingPhase": 0 + } } \ No newline at end of file diff --git a/configs/foundry/deploy/test/params-test-audit.json b/configs/foundry/deploy/test/params-test-audit.json index d06e3433..44ca5c33 100644 --- a/configs/foundry/deploy/test/params-test-audit.json +++ b/configs/foundry/deploy/test/params-test-audit.json @@ -9,9 +9,8 @@ "04_oracleDecimals": 8, "05_sequencerGracePeriodTime": 3600, "06_sequencerUptimeFeed": "0x0000000000000000000000000000000000000000", - "07_gatingManager": "0x0000000000000000000000000000000000000000", - "08_pythEndpoint": "0x0000000000000000000000000000000000000000", - "09_marketStatusProvider": "0x0000000000000000000000000000000000000000" + "07_pythEndpoint": "0x0000000000000000000000000000000000000000", + "08_marketStatusProvider": "0x0000000000000000000000000000000000000000" }, "03_scdp": { "00_minCollateralRatio": 250e2, @@ -29,6 +28,5 @@ "01_questForKreskNFT": "0x0000000000000000000000000000000000000000", "02_V3SwapRouter02": "0x0000000000000000000000000000000000000000", "03_UniswapQuoterV2": "0x0000000000000000000000000000000000000000" - }, - "06_gatingPhase": 0 + } } \ No newline at end of file diff --git a/configs/foundry/deploy/test/params-test-base.json b/configs/foundry/deploy/test/params-test-base.json index 487952aa..f21e4ae5 100644 --- a/configs/foundry/deploy/test/params-test-base.json +++ b/configs/foundry/deploy/test/params-test-base.json @@ -9,9 +9,8 @@ "04_oracleDecimals": 8, "05_sequencerGracePeriodTime": 3600, "06_sequencerUptimeFeed": "0x0000000000000000000000000000000000000000", - "07_gatingManager": "0x0000000000000000000000000000000000000000", - "08_pythEndpoint": "0x0000000000000000000000000000000000000000", - "09_marketStatusProvider": "0x0000000000000000000000000000000000000000" + "07_pythEndpoint": "0x0000000000000000000000000000000000000000", + "08_marketStatusProvider": "0x0000000000000000000000000000000000000000" }, "03_scdp": { "00_minCollateralRatio": 250e2, @@ -29,6 +28,5 @@ "01_questForKreskNFT": "0x0000000000000000000000000000000000000000", "02_V3SwapRouter02": "0x0000000000000000000000000000000000000000", "03_UniswapQuoterV2": "0x0000000000000000000000000000000000000000" - }, - "06_gatingPhase": 0 + } } \ No newline at end of file diff --git a/configs/foundry/deploy/test/params-test-clean.json b/configs/foundry/deploy/test/params-test-clean.json index 1e9334fd..bd080579 100644 --- a/configs/foundry/deploy/test/params-test-clean.json +++ b/configs/foundry/deploy/test/params-test-clean.json @@ -9,9 +9,8 @@ "04_oracleDecimals": 8, "05_sequencerGracePeriodTime": 3600, "06_sequencerUptimeFeed": "0x0000000000000000000000000000000000000000", - "07_gatingManager": "0x0000000000000000000000000000000000000000", - "08_pythEndpoint": "0x0000000000000000000000000000000000000000", - "09_marketStatusProvider": "0x0000000000000000000000000000000000000000" + "07_pythEndpoint": "0x0000000000000000000000000000000000000000", + "08_marketStatusProvider": "0x0000000000000000000000000000000000000000" }, "03_scdp": { "00_minCollateralRatio": 250e2, @@ -29,6 +28,5 @@ "01_questForKreskNFT": "0x0000000000000000000000000000000000000000", "02_V3SwapRouter02": "0x0000000000000000000000000000000000000000", "03_UniswapQuoterV2": "0x0000000000000000000000000000000000000000" - }, - "06_gatingPhase": 0 + } } \ No newline at end of file diff --git a/configs/hardhat/deploy/arbitrumSepolia.ts b/configs/hardhat/deploy/arbitrumSepolia.ts index 152ebd62..d71683ca 100644 --- a/configs/hardhat/deploy/arbitrumSepolia.ts +++ b/configs/hardhat/deploy/arbitrumSepolia.ts @@ -238,18 +238,14 @@ const gnosisSafeDeployments: GnosisSafeDeployment[] = [ SignMessageLib, SimulateTxAccessor, ] -const commonInitAgs = ( - gatingManager: string, -): Omit => ({ +const commonInitArgs = { oracleDecimals: 8, - gatingManager, maxPriceDeviationPct: 0.1e4, sequencerGracePeriodTime: 3600, sequencerUptimeFeed: '0x23ab08d87BBAe90e8BDe56F87ad6e53683E08279', pythEp: '0x4374e5a8b9C22271E9EB878A2AA31DE97DF15DAF', marketStatusProvider: '0xf6188e085ebEB716a730F8ecd342513e72C8AD04', -}) - +} export const minterInitArgs: MinterInitArgsStruct = { minCollateralRatio: 1.5e4, liquidationThreshold: 1.4e4, @@ -263,28 +259,28 @@ export const scdpInitArgs: SCDPInitArgsStruct = { } export const testnetConfigs: NetworkConfig = { all: { - commonInitAgs: commonInitAgs(zeroAddress), + commonInitArgs, minterInitArgs, scdpInitArgs, assets: [assets.DAI, assets.KISS, assets.WETH, assets.krBTC, assets.krETH], gnosisSafeDeployments, }, hardhat: { - commonInitAgs: commonInitAgs(zeroAddress), + commonInitArgs, minterInitArgs, scdpInitArgs, assets: [assets.KISS, assets.krETH], gnosisSafeDeployments, }, localhost: { - commonInitAgs: commonInitAgs(zeroAddress), + commonInitArgs, minterInitArgs, scdpInitArgs, assets: [assets.DAI, assets.KISS, assets.krBTC, assets.krETH], gnosisSafeDeployments, }, arbitrumGoerli: { - commonInitAgs: commonInitAgs(zeroAddress), + commonInitArgs, minterInitArgs, scdpInitArgs, assets: [assets.DAI, assets.KISS, assets.krBTC, assets.krETH], diff --git a/configs/hardhat/deploy/index.ts b/configs/hardhat/deploy/index.ts index df39e6eb..5eeda4d4 100644 --- a/configs/hardhat/deploy/index.ts +++ b/configs/hardhat/deploy/index.ts @@ -48,13 +48,10 @@ export const getMinterInitializer = async (hre: HardhatRuntimeEnvironment): Prom args: testnetConfigs[hre.network.name].minterInitArgs, } } -export const getCommonInitializer = async ( - hre: HardhatRuntimeEnvironment, - gatingManager: string, -): Promise => { +export const getCommonInitializer = async (hre: HardhatRuntimeEnvironment): Promise => { const { treasury, admin, multisig } = await getDeploymentUsers(hre) - const config = testnetConfigs[hre.network.name].commonInitAgs + const config = testnetConfigs[hre.network.name].commonInitArgs return { name: 'CommonConfigFacet', @@ -63,7 +60,6 @@ export const getCommonInitializer = async ( admin, treasury, council: multisig, - gatingManager, pythEp: hre.network.live ? config.pythEp : (await hre.deployments.get('MockPyth')).address, sequencerUptimeFeed: hre.network.live ? config.sequencerUptimeFeed diff --git a/lib/kresko-lib b/lib/kresko-lib index a65a6c26..9f893acb 160000 --- a/lib/kresko-lib +++ b/lib/kresko-lib @@ -1 +1 @@ -Subproject commit a65a6c26fb25800deefc9659f06562f0d9ebe1bb +Subproject commit 9f893acb9b893f4c17bbddc81f17e99a2519e868 diff --git a/src/contracts/core/common/Auth.sol b/src/contracts/core/common/Auth.sol index dcd616cb..c632a197 100644 --- a/src/contracts/core/common/Auth.sol +++ b/src/contracts/core/common/Auth.sol @@ -4,7 +4,6 @@ pragma solidity 0.8.23; import {EnumerableSet} from "@oz/utils/structs/EnumerableSet.sol"; import {Strings} from "libs/Strings.sol"; import {Meta} from "libs/Meta.sol"; -import {ds} from "diamond/DState.sol"; import {Errors} from "common/Errors.sol"; import {Role} from "common/Constants.sol"; diff --git a/src/contracts/core/common/Errors.sol b/src/contracts/core/common/Errors.sol index 6239efe7..894f33b4 100644 --- a/src/contracts/core/common/Errors.sol +++ b/src/contracts/core/common/Errors.sol @@ -130,9 +130,6 @@ library Errors { error NO_COLLATERALS_DEPOSITED(address who); error ONLY_WHITELISTED(); error BLACKLISTED(); - error MISSING_PHASE_3_NFT(); - error MISSING_PHASE_2_NFT(); - error MISSING_PHASE_1_NFT(); error CANNOT_RE_ENTER(); error PYTH_ID_ZERO(string ticker); error ARRAY_LENGTH_MISMATCH(string ticker, uint256 arr1, uint256 arr2); diff --git a/src/contracts/core/common/Modifiers.sol b/src/contracts/core/common/Modifiers.sol index 34f8a843..8a13db75 100644 --- a/src/contracts/core/common/Modifiers.sol +++ b/src/contracts/core/common/Modifiers.sol @@ -6,10 +6,9 @@ import {Errors} from "common/Errors.sol"; import {Auth} from "common/Auth.sol"; import {Role, Constants, Enums} from "common/Constants.sol"; import {Asset} from "common/Types.sol"; -import {cs, gm, CommonState} from "common/State.sol"; +import {cs, CommonState} from "common/State.sol"; import {WadRay} from "libs/WadRay.sol"; import {scdp} from "scdp/SState.sol"; -import {IPyth} from "kresko-lib/vendor/Pyth.sol"; import {handlePythUpdate} from "common/funcs/Utils.sol"; library LibModifiers { @@ -250,14 +249,6 @@ contract Modifiers { cs().entered = Constants.NOT_ENTERED; } - /// @notice Reverts if the caller does not have the required NFT's for the gated phase - modifier gate(address _account) { - if (address(gm().manager) != address(0)) { - gm().manager.check(_account); - } - _; - } - modifier usePyth(bytes[] calldata _updateData) { handlePythUpdate(_updateData); _; diff --git a/src/contracts/core/common/Types.sol b/src/contracts/core/common/Types.sol index 2bf7a9e1..6cc316e6 100644 --- a/src/contracts/core/common/Types.sol +++ b/src/contracts/core/common/Types.sol @@ -168,7 +168,6 @@ struct CommonInitArgs { uint8 oracleDecimals; uint32 sequencerGracePeriodTime; address sequencerUptimeFeed; - address gatingManager; address pythEp; address marketStatusProvider; } diff --git a/src/contracts/core/common/facets/CommonConfigFacet.sol b/src/contracts/core/common/facets/CommonConfigFacet.sol index 69a7cab2..3211de8c 100644 --- a/src/contracts/core/common/facets/CommonConfigFacet.sol +++ b/src/contracts/core/common/facets/CommonConfigFacet.sol @@ -17,7 +17,6 @@ import {Errors} from "common/Errors.sol"; import {cs, gm} from "common/State.sol"; import {Auth} from "common/Auth.sol"; import {Validations} from "common/Validations.sol"; -import {IGatingManager} from "periphery/IGatingManager.sol"; contract CommonConfigFacet is ICommonConfigFacet, Modifiers, DSModifiers { using Strings for bytes32; @@ -34,7 +33,6 @@ contract CommonConfigFacet is ICommonConfigFacet, Modifiers, DSModifiers { setSequencerUptimeFeed(args.sequencerUptimeFeed); setMaxPriceDeviationPct(args.maxPriceDeviationPct); setSequencerGracePeriod(args.sequencerGracePeriodTime); - setGatingManager(args.gatingManager); setPythEndpoint(args.pythEp); ds().supportedInterfaces[type(IAuthorizationFacet).interfaceId] = true; // Revoke admin role from deployer @@ -62,10 +60,6 @@ contract CommonConfigFacet is ICommonConfigFacet, Modifiers, DSModifiers { cs().pythEp = _pythEp; } - function setGatingManager(address _newManager) public override onlyRole(Role.ADMIN) { - gm().manager = IGatingManager(_newManager); - } - /// @inheritdoc ICommonConfigFacet function setDefaultOraclePrecision(uint8 _decimals) public onlyRole(Role.ADMIN) { Validations.validateOraclePrecision(_decimals); diff --git a/src/contracts/core/common/facets/CommonStateFacet.sol b/src/contracts/core/common/facets/CommonStateFacet.sol index fa0e61c3..19299af1 100644 --- a/src/contracts/core/common/facets/CommonStateFacet.sol +++ b/src/contracts/core/common/facets/CommonStateFacet.sol @@ -25,11 +25,6 @@ contract CommonStateFacet is ICommonStateFacet { return cs().oracleDecimals; } - /// @inheritdoc ICommonStateFacet - function getGatingManager() external view returns (address) { - return address(gm().manager); - } - /// @inheritdoc ICommonStateFacet function getMarketStatusProvider() external view returns (address) { return cs().marketStatusProvider; diff --git a/src/contracts/core/common/interfaces/ICommonConfigFacet.sol b/src/contracts/core/common/interfaces/ICommonConfigFacet.sol index f5e2c92c..5171afe4 100644 --- a/src/contracts/core/common/interfaces/ICommonConfigFacet.sol +++ b/src/contracts/core/common/interfaces/ICommonConfigFacet.sol @@ -113,12 +113,6 @@ interface ICommonConfigFacet { */ function setAPI3Feed(bytes32 _ticker, address _feedAddr, uint256 _staleTime, bool _isClosable) external; - /** - * @notice Sets gating manager - * @param _newManager _newManager address - */ - function setGatingManager(address _newManager) external; - /** * @notice Sets market status provider * @param _provider market status provider address diff --git a/src/contracts/core/common/interfaces/ICommonStateFacet.sol b/src/contracts/core/common/interfaces/ICommonStateFacet.sol index 52eca5b6..7df6c94f 100644 --- a/src/contracts/core/common/interfaces/ICommonStateFacet.sol +++ b/src/contracts/core/common/interfaces/ICommonStateFacet.sol @@ -16,9 +16,6 @@ interface ICommonStateFacet { /// @notice max deviation between main oracle and fallback oracle function getOracleDeviationPct() external view returns (uint16); - /// @notice gating manager contract address - function getGatingManager() external view returns (address); - /// @notice Get the market status provider address. function getMarketStatusProvider() external view returns (address); diff --git a/src/contracts/core/minter/facets/MinterDepositWithdrawFacet.sol b/src/contracts/core/minter/facets/MinterDepositWithdrawFacet.sol index a609e119..562f1d25 100644 --- a/src/contracts/core/minter/facets/MinterDepositWithdrawFacet.sol +++ b/src/contracts/core/minter/facets/MinterDepositWithdrawFacet.sol @@ -30,7 +30,7 @@ contract MinterDepositWithdrawFacet is Modifiers, IMinterDepositWithdrawFacet { address _account, address _collateralAsset, uint256 _depositAmount - ) external payable nonReentrant gate(_account) { + ) external payable nonReentrant { Asset storage asset = cs().onlyMinterCollateral(_collateralAsset, Enums.Action.Deposit); // Transfer tokens into this contract prior to any state changes as an extra measure against re-entrancy. IERC20(_collateralAsset).safeTransferFrom(msg.sender, address(this), _depositAmount); diff --git a/src/contracts/core/minter/facets/MinterMintFacet.sol b/src/contracts/core/minter/facets/MinterMintFacet.sol index b8eb7866..39f90d0a 100644 --- a/src/contracts/core/minter/facets/MinterMintFacet.sol +++ b/src/contracts/core/minter/facets/MinterMintFacet.sol @@ -9,7 +9,6 @@ import {cs} from "common/State.sol"; import {Asset} from "common/Types.sol"; import {Strings} from "libs/Strings.sol"; -import {IKreskoAsset} from "kresko-asset/IKreskoAsset.sol"; import {IMinterMintFacet} from "minter/interfaces/IMinterMintFacet.sol"; import {MEvent} from "minter/MEvent.sol"; @@ -31,14 +30,7 @@ contract MinterMintFacet is IMinterMintFacet, Modifiers { function mintKreskoAsset( MintArgs memory _args, bytes[] calldata _updateData - ) - external - payable - onlyRoleIf(_args.account != msg.sender, Role.MANAGER) - nonReentrant - usePyth(_updateData) - gate(_args.account) - { + ) external payable onlyRoleIf(_args.account != msg.sender, Role.MANAGER) nonReentrant usePyth(_updateData) { if (_args.amount == 0) revert Errors.ZERO_MINT(Errors.id(_args.krAsset)); Asset storage asset = cs().onlyMinterMintable(_args.krAsset, Enums.Action.Borrow); diff --git a/src/contracts/core/periphery/GatingManager.sol b/src/contracts/core/periphery/GatingManager.sol deleted file mode 100644 index fd1cb856..00000000 --- a/src/contracts/core/periphery/GatingManager.sol +++ /dev/null @@ -1,120 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.19; - -import {IERC1155} from "common/interfaces/IERC1155.sol"; -import {Ownable} from "@oz/access/Ownable.sol"; -import {Errors} from "common/Errors.sol"; -import {IGatingManager} from "periphery/IGatingManager.sol"; - -// solhint-disable code-complexity - -contract GatingManager is IGatingManager, Ownable { - IERC1155 public kreskian; - IERC1155 public questForKresk; - uint8 public phase; - uint256[] internal _qfkNFTs; - - mapping(address => bool) internal whitelisted; - - constructor(address _admin, address _kreskian, address _questForKresk, uint8 _phase) Ownable(_admin) { - kreskian = IERC1155(_kreskian); - questForKresk = IERC1155(_questForKresk); - phase = _phase; - - _qfkNFTs.push(0); - _qfkNFTs.push(1); - _qfkNFTs.push(2); - _qfkNFTs.push(3); - _qfkNFTs.push(4); - _qfkNFTs.push(5); - _qfkNFTs.push(6); - _qfkNFTs.push(7); - } - - function transferOwnership(address newOwner) public override(IGatingManager, Ownable) onlyOwner { - Ownable.transferOwnership(newOwner); - } - - function qfkNFTs() external view returns (uint256[] memory) { - return _qfkNFTs; - } - - function isWhiteListed(address _account) external view returns (bool) { - return whitelisted[_account]; - } - - function whitelist(address _account, bool _whitelisted) external onlyOwner { - whitelisted[_account] = _whitelisted; - } - - function setPhase(uint8 newPhase) external onlyOwner { - phase = newPhase; - } - - function isEligible(address _account) external view returns (bool) { - uint256 currentPhase = phase; - if (currentPhase == 0) return true; - - bool hasKreskian = kreskian.balanceOf(_account, 0) != 0; - - if (currentPhase == 3) { - return hasKreskian || whitelisted[_account]; - } - - uint256[] memory qfkBals = questForKresk.balanceOfBatch(_toArray(_account), _qfkNFTs); - bool validPhaseTwo = qfkBals[0] != 0; - - if (currentPhase == 2) { - return validPhaseTwo || whitelisted[_account]; - } - - if (currentPhase == 1 && validPhaseTwo) { - for (uint256 i = 1; i < qfkBals.length; i++) { - if (qfkBals[i] != 0) return true; - } - } - - return whitelisted[_account]; - } - - function check(address _account) external view { - uint256 currentPhase = phase; - if (currentPhase == 0) return; - - bool hasKreskian = kreskian.balanceOf(_account, 0) != 0; - - if (currentPhase == 3) { - if (!hasKreskian && !whitelisted[_account]) revert Errors.MISSING_PHASE_3_NFT(); - return; - } - - uint256[] memory qfkBals = questForKresk.balanceOfBatch(_toArray(_account), _qfkNFTs); - - bool validPhaseTwo = qfkBals[0] != 0; - - if (currentPhase == 2) { - if (!validPhaseTwo && !whitelisted[_account]) revert Errors.MISSING_PHASE_2_NFT(); - return; - } - - if (currentPhase == 1 && validPhaseTwo) { - for (uint256 i = 1; i < qfkBals.length; i++) { - if (qfkBals[i] != 0) return; - } - } - - if (!whitelisted[_account]) revert Errors.MISSING_PHASE_1_NFT(); - } - - function _toArray(address _acc) internal pure returns (address[] memory array) { - array = new address[](8); - array[0] = _acc; - array[1] = _acc; - array[2] = _acc; - array[3] = _acc; - array[4] = _acc; - array[5] = _acc; - array[6] = _acc; - array[7] = _acc; - } -} diff --git a/src/contracts/core/periphery/IErrorsEvents.sol b/src/contracts/core/periphery/IErrorsEvents.sol index 5bed8c6d..e80c0c2d 100644 --- a/src/contracts/core/periphery/IErrorsEvents.sol +++ b/src/contracts/core/periphery/IErrorsEvents.sol @@ -509,9 +509,6 @@ interface IErrorsEvents { error INVALID_SEQUENCER_UPTIME_FEED(address); error NO_MINTED_ASSETS(address who); error NO_COLLATERALS_DEPOSITED(address who); - error MISSING_PHASE_3_NFT(); - error MISSING_PHASE_2_NFT(); - error MISSING_PHASE_1_NFT(); error CANNOT_RE_ENTER(); error ARRAY_LENGTH_MISMATCH(string ticker, uint256 arr1, uint256 arr2); error COLLATERAL_VALUE_GREATER_THAN_REQUIRED(uint256 collateralValue, uint256 minCollateralValue, uint32 ratio); diff --git a/src/contracts/core/periphery/ViewData.sol b/src/contracts/core/periphery/ViewData.sol index eec3ec3f..b1def423 100644 --- a/src/contracts/core/periphery/ViewData.sol +++ b/src/contracts/core/periphery/ViewData.sol @@ -91,7 +91,6 @@ library ViewFuncs { result.sequencerStartedAt = uint32(startedAt); result.timestamp = uint32(block.timestamp); result.blockNr = uint32(block.number); - result.gate = viewGate(); result.tvl = viewTVL(prices); } @@ -103,15 +102,6 @@ library ViewFuncs { } } - function viewGate() internal view returns (View.Gate memory result) { - if (address(gm().manager) == address(0)) { - return result; - } - result.kreskian = address(gm().manager.kreskian()); - result.questForKresk = address(gm().manager.questForKresk()); - result.phase = gm().manager.phase(); - } - function viewMinter() internal view returns (View.Minter memory result) { result.LT = ms().liquidationThreshold; result.MCR = ms().minCollateralRatio; @@ -495,14 +485,6 @@ library ViewFuncs { result.feeIndexCurrent = scdp().assetIndexes[_assetAddr].currFeeIndex; } - function viewPhaseEligibility(address _account) internal view returns (uint8 phase, bool isEligible) { - if (address(gm().manager) == address(0)) { - return (0, true); - } - phase = gm().manager.phase(); - isEligible = gm().manager.isEligible(_account); - } - function _symbol(address _assetAddr) internal view returns (string memory) { return _assetAddr == 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8 ? "USDC.e" : IERC20(_assetAddr).symbol(); } diff --git a/src/contracts/core/periphery/facets/ViewDataFacet.sol b/src/contracts/core/periphery/facets/ViewDataFacet.sol index 44379a67..2aa6fb30 100644 --- a/src/contracts/core/periphery/facets/ViewDataFacet.sol +++ b/src/contracts/core/periphery/facets/ViewDataFacet.sol @@ -87,8 +87,4 @@ contract ViewDataFacet is IViewDataFacet { } } } - - function viewAccountGatingPhase(address _account) external view returns (uint8 phase, bool eligibleForCurrentPhase) { - return ViewFuncs.viewPhaseEligibility(_account); - } } diff --git a/src/contracts/core/periphery/interfaces/IViewDataFacet.sol b/src/contracts/core/periphery/interfaces/IViewDataFacet.sol index 6c9e1421..ccf34db9 100644 --- a/src/contracts/core/periphery/interfaces/IViewDataFacet.sol +++ b/src/contracts/core/periphery/interfaces/IViewDataFacet.sol @@ -23,8 +23,6 @@ interface IViewDataFacet { address[] memory tokens ) external view returns (View.Balance[] memory result); - function viewAccountGatingPhase(address account) external view returns (uint8 phase, bool eligibleForCurrentPhase); - function viewSCDPAccounts( PythView calldata prices, address[] memory accounts, diff --git a/src/contracts/core/scdp/facets/SCDPFacet.sol b/src/contracts/core/scdp/facets/SCDPFacet.sol index c072eb08..4d2ca770 100644 --- a/src/contracts/core/scdp/facets/SCDPFacet.sol +++ b/src/contracts/core/scdp/facets/SCDPFacet.sol @@ -30,11 +30,7 @@ using WadRay for uint256; contract SCDPFacet is ISCDPFacet, Modifiers { /// @inheritdoc ISCDPFacet - function depositSCDP( - address _account, - address _collateralAsset, - uint256 _amount - ) external payable nonReentrant gate(_account) { + function depositSCDP(address _account, address _collateralAsset, uint256 _amount) external payable nonReentrant { // Transfer tokens into this contract prior to any state changes as an extra measure against re-entrancy. IERC20(_collateralAsset).safeTransferFrom(msg.sender, address(this), _amount); @@ -141,7 +137,7 @@ contract SCDPFacet is ISCDPFacet, Modifiers { } /// @inheritdoc ISCDPFacet - function repaySCDP(SCDPRepayArgs calldata _args) external payable nonReentrant gate(tx.origin) { + function repaySCDP(SCDPRepayArgs calldata _args) external payable nonReentrant { handlePythUpdate(_args.prices); Asset storage repayAsset = cs().onlySwapMintable(_args.repayAsset, Enums.Action.SCDPRepay); Asset storage seizeAsset = cs().onlySwapMintable(_args.seizeAsset, Enums.Action.SCDPRepay); @@ -222,11 +218,6 @@ contract SCDPFacet is ISCDPFacet, Modifiers { /// @inheritdoc ISCDPFacet function liquidateSCDP(SCDPLiquidationArgs memory _args, bytes[] calldata _updateData) external payable nonReentrant { - // inlined modifier (for stack) - if (address(gm().manager) != address(0)) { - gm().manager.check(tx.origin); - } - // inlined modifier (for stack) handlePythUpdate(_updateData); diff --git a/src/contracts/core/test/AggregatorV3Normalizer.sol b/src/contracts/core/test/AggregatorV3Normalizer.sol deleted file mode 100644 index d3a545c6..00000000 --- a/src/contracts/core/test/AggregatorV3Normalizer.sol +++ /dev/null @@ -1,52 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.19; - -import {IAggregatorV3} from "kresko-lib/vendor/IAggregatorV3.sol"; - -// solhint-disable const-name-snakecase - -/** - * @title AggregatorV3Normalizer - * @notice Wraps an AggregatorV3 feed and normalizes the answer to 8 decimal precision. - */ -contract AggregatorV3Normalizer is IAggregatorV3 { - uint8 public constant decimals = 8; - uint256 public immutable version; - - string public description; - IAggregatorV3 public immutable feed; - uint8 public immutable feedDecimals; - - constructor(address _feed) { - feed = IAggregatorV3(_feed); - description = feed.description(); - version = feed.version(); - feedDecimals = feed.decimals(); - } - - function latestAnswer() external view returns (int256) { - return normalized(feed.latestAnswer(), feedDecimals); - } - - function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) { - (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) = feed.latestRoundData(); - return (roundId, normalized(answer, feedDecimals), startedAt, updatedAt, answeredInRound); - } - - function getRoundData(uint80 _roundId) external view returns (uint80, int256, uint256, uint256, uint80) { - (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) = feed.getRoundData( - _roundId - ); - return (roundId, normalized(answer, feedDecimals), startedAt, updatedAt, answeredInRound); - } - - function normalized(int256 price, uint256 sourceDecimals) public pure returns (int256) { - if (sourceDecimals > decimals) { - return price / int256(10 ** (sourceDecimals - decimals)); - } else if (sourceDecimals < decimals) { - return price * int256(10 ** (decimals - sourceDecimals)); - } else { - return price; - } - } -} diff --git a/src/contracts/core/test/mocks/MockERC1155.sol b/src/contracts/core/test/mocks/MockERC1155.sol deleted file mode 100644 index 1b4b6b42..00000000 --- a/src/contracts/core/test/mocks/MockERC1155.sol +++ /dev/null @@ -1,29 +0,0 @@ -//SPDX-License-Identifier: AGPL-3.0-only - -pragma solidity 0.8.23; - -import {ERC1155} from "@oz/token/ERC1155/ERC1155.sol"; - -contract MockERC1155 is ERC1155 { - string public name; - string public symbol; - string internal __contractUri; - - constructor(string memory _name, string memory _symbol, string memory _contractUri, string memory _uri) ERC1155(_uri) { - name = _name; - symbol = _symbol; - __contractUri = _contractUri; - } - - function mint(address account, uint256 id, uint256 amount) external { - _mint(account, id, amount, ""); - } - - function mint(address account, uint256 id, uint256 amount, bytes memory) external { - _mint(account, id, amount, ""); - } - - function contractURI() public view returns (string memory) { - return __contractUri; - } -} diff --git a/src/contracts/core/test/mocks/MockERC20.sol b/src/contracts/core/test/mocks/MockERC20.sol deleted file mode 100644 index 87e69b24..00000000 --- a/src/contracts/core/test/mocks/MockERC20.sol +++ /dev/null @@ -1,115 +0,0 @@ -// SPDX-License-Identifier: AGPL-3.0-only -pragma solidity ^0.8.0; - -import {ERC20} from "kresko-lib/token/ERC20.sol"; - -// solhint-disable no-empty-blocks - -contract MockERC20Restricted is ERC20 { - mapping(address => bool) public minters; - address public owner; - - constructor( - string memory _name, - string memory _symbol, - uint8 _decimals, - uint256 _initialSupply - ) ERC20(_name, _symbol, _decimals) { - _mint(msg.sender, _initialSupply); - minters[msg.sender] = true; - } - - function reinitializeERC20(string memory _name, string memory _symbol) external { - require(msg.sender == owner, "!owner"); - name = _name; - symbol = _symbol; - } - - function toggleMinters(address[] calldata _minters) external { - require(minters[msg.sender], "!minter"); - for (uint256 i; i < _minters.length; i++) { - minters[_minters[i]] = !minters[_minters[i]]; - } - } - - function mint(address to, uint256 value) public virtual { - require(minters[msg.sender], "!minter"); - _mint(to, value); - } - - function burn(address from, uint256 value) public virtual { - require(minters[msg.sender], "!minter"); - _burn(from, value); - } -} - -contract MockERC20 is ERC20 { - constructor( - string memory name_, - string memory symbol_, - uint8 decimals_, - uint256 mintAmount - ) ERC20(name_, symbol_, decimals_) { - _mint(msg.sender, mintAmount); - } - - function mint(address to, uint256 amount) external { - _mint(to, amount); - } - - function burn(address from, uint256 amount) external { - _burn(from, amount); - } -} - -contract WETH is MockERC20 { - constructor() MockERC20("WETH", "WETH", 18, 0) {} - - function deposit() external payable { - _mint(msg.sender, msg.value); - } - - function withdraw(uint256 amount) external { - _burn(msg.sender, amount); - payable(msg.sender).transfer(amount); - } -} - -contract USDC is MockERC20 { - constructor() MockERC20("USDC", "USDC", 18, 0) {} - - function deposit() external payable { - _mint(msg.sender, msg.value); - } - - function withdraw(uint256 amount) external { - _burn(msg.sender, amount); - payable(msg.sender).transfer(amount); - } -} - -contract DAI is MockERC20 { - constructor() MockERC20("DAI", "DAI", 18, 0) {} - - function deposit() external payable { - _mint(msg.sender, msg.value); - } - - function withdraw(uint256 amount) external { - _burn(msg.sender, amount); - payable(msg.sender).transfer(amount); - } -} - -contract USDT is MockERC20 { - constructor() MockERC20("USDT", "USDT", 6, 0) {} - - function deposit() external payable { - _mint(msg.sender, msg.value); - } - - function withdraw(uint256 amount) external { - _burn(msg.sender, amount); - payable(msg.sender).transfer(amount); - } -} diff --git a/src/contracts/mocks/MockLogic.sol b/src/contracts/core/test/mocks/MockLogic.sol similarity index 100% rename from src/contracts/mocks/MockLogic.sol rename to src/contracts/core/test/mocks/MockLogic.sol diff --git a/src/contracts/mocks/MockMarketStatus.sol b/src/contracts/core/test/mocks/MockMarketStatus.sol similarity index 100% rename from src/contracts/mocks/MockMarketStatus.sol rename to src/contracts/core/test/mocks/MockMarketStatus.sol diff --git a/src/contracts/core/test/mocks/MockOracle.sol b/src/contracts/core/test/mocks/MockOracle.sol deleted file mode 100644 index 6abbfdf7..00000000 --- a/src/contracts/core/test/mocks/MockOracle.sol +++ /dev/null @@ -1,49 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 - -pragma solidity 0.8.23; -import {IAggregatorV3} from "kresko-lib/vendor/IAggregatorV3.sol"; - -contract MockOracle is IAggregatorV3 { - uint8 public decimals = 8; - string public override description; - uint256 public override version = 1; - int256 public initialAnswer; - - constructor(string memory _description, uint256 _initialAnswer, uint8 _decimals) { - description = _description; - initialAnswer = int256(_initialAnswer); - decimals = _decimals; - } - - function setPrice(uint256 _answer) external { - initialAnswer = int256(_answer); - } - - function price() external view returns (uint256) { - return uint256(initialAnswer); - } - - function latestAnswer() external view returns (int256) { - return initialAnswer; - } - - function getRoundData( - uint80 - ) - external - view - override - returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) - { - return (1, initialAnswer, block.timestamp, block.timestamp, roundId); - } - - function latestRoundData() - external - view - override - returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) - { - return (1, initialAnswer, block.timestamp, block.timestamp, roundId); - } -} diff --git a/src/contracts/core/test/mocks/MockSequencerUptimeFeed.sol b/src/contracts/core/test/mocks/MockSequencerUptimeFeed.sol deleted file mode 100644 index 5b0ee8b1..00000000 --- a/src/contracts/core/test/mocks/MockSequencerUptimeFeed.sol +++ /dev/null @@ -1,38 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.23; -import {MockPyth} from "kresko-lib/mocks/MockPyth.sol"; - -contract MockSequencerUptimeFeed { - uint256 internal __startedAt; - uint256 internal __updatedAt; - int256 internal __answer; - - constructor() { - __startedAt = block.timestamp; - __updatedAt = block.timestamp; - } - - function setAnswers(int256 _answer, uint256 _startedAt, uint256 _updatedAt) external { - __startedAt = _startedAt != 0 ? _startedAt : block.timestamp; - __updatedAt = _updatedAt != 0 ? _updatedAt : block.timestamp; - __answer = _answer; - } - - /// @notice 0 = up, 1 = down - function setAnswer(int256 _answer) external { - if (_answer != __answer) { - __startedAt = block.timestamp; - __answer = _answer; - } - __updatedAt = block.timestamp; - } - - function latestRoundData() - public - view - virtual - returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) - { - return (0, __answer, __startedAt, updatedAt, 0); - } -} diff --git a/src/contracts/core/test/mocks/Mocks.sol b/src/contracts/core/test/mocks/Mocks.sol new file mode 100644 index 00000000..6fa930db --- /dev/null +++ b/src/contracts/core/test/mocks/Mocks.sol @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.23; +import {MockPyth} from "kresko-lib/mocks/MockPyth.sol"; +import {MockOracle} from "kresko-lib/mocks/MockOracle.sol"; +import {MockERC1155} from "kresko-lib/mocks/MockERC1155.sol"; +import {MockERC20} from "kresko-lib/mocks/MockERC20.sol"; +import {MockSequencerUptimeFeed} from "kresko-lib/mocks/MockSequencerUptimeFeed.sol"; +import {MockMarketStatus} from "./MockMarketStatus.sol"; diff --git a/src/contracts/scripts/SafeExample.s.sol b/src/contracts/scripts/SafeExample.s.sol index 11c54a94..4db9f518 100644 --- a/src/contracts/scripts/SafeExample.s.sol +++ b/src/contracts/scripts/SafeExample.s.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.0; import {ArbScript} from "scripts/utils/ArbScript.s.sol"; -import {Help, Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {SwapRouteSetter} from "scdp/STypes.sol"; import {scdp} from "scdp/SState.sol"; import {ArbDeployAddr} from "kresko-lib/info/ArbDeployAddr.sol"; @@ -21,7 +21,6 @@ contract ExamplePayload0002 is ArbDeployAddr { contract SafeExample is ArbScript { using Log for *; - using Help for *; modifier setUp() { ArbScript.initialize("MNEMONIC_DEPLOY"); diff --git a/src/contracts/scripts/deploy/CONST.s.sol b/src/contracts/scripts/deploy/CONST.s.sol index 999d2dcc..e77ff9cf 100644 --- a/src/contracts/scripts/deploy/CONST.s.sol +++ b/src/contracts/scripts/deploy/CONST.s.sol @@ -8,7 +8,6 @@ library CONST { bytes32 constant SALT_ID = bytes32("_1"); bytes32 constant KISS_SALT = bytes32("KISS_1"); bytes32 constant VAULT_SALT = bytes32("vKISS_1"); - bytes32 constant GM_SALT = bytes32("GatingManager_1"); bytes32 constant MOCK_STATUS_SALT = bytes32("mock_market_status"); bytes32 constant PYTH_MOCK_SALT = bytes32("MockPythEP_1"); bytes32 constant MC_SALT = bytes32("Multicall_1"); diff --git a/src/contracts/scripts/deploy/Deploy.s.sol b/src/contracts/scripts/deploy/Deploy.s.sol index aa6abccb..dcf1fe08 100644 --- a/src/contracts/scripts/deploy/Deploy.s.sol +++ b/src/contracts/scripts/deploy/Deploy.s.sol @@ -8,18 +8,16 @@ import {LibJSON} from "scripts/deploy/libs/LibJSON.s.sol"; import {LibMocks} from "scripts/deploy/libs/LibMocks.s.sol"; import {LibDeploy} from "scripts/deploy/libs/LibDeploy.s.sol"; import {LibDeployUtils} from "scripts/deploy/libs/LibDeployUtils.s.sol"; -import {Help, Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {VaultAsset} from "vault/VTypes.sol"; import {SwapRouteSetter} from "scdp/STypes.sol"; import {Ownable} from "@oz/access/Ownable.sol"; import "scripts/deploy/JSON.s.sol" as JSON; -import {MockERC20} from "mocks/MockERC20.sol"; -import {IERC1155} from "common/interfaces/IERC1155.sol"; +import {MockERC20} from "mocks/Mocks.sol"; import {Enums, Role} from "common/Constants.sol"; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; import {Asset, FeedConfiguration} from "common/Types.sol"; import {IDeploymentFactory} from "factory/IDeploymentFactory.sol"; -import {IGatingManager} from "periphery/IGatingManager.sol"; import {IPyth} from "kresko-lib/vendor/Pyth.sol"; import {MintArgs} from "common/Args.sol"; @@ -29,15 +27,12 @@ contract Deploy is DeployBase { using LibDeploy for *; using Deployed for *; using LibDeployUtils for *; - using Help for *; using Log for *; using Utils for *; mapping(bytes32 => bool) tickerExists; mapping(bytes32 => bool) routeExists; SwapRouteSetter[] routeCache; - bytes[] updateData; - uint256 updateFee; function exec( JSON.Config memory json, @@ -45,32 +40,23 @@ contract Deploy is DeployBase { address deployer, bool disableLog ) private broadcasted(deployer) returns (JSON.Config memory) { - // Deploy the deployment factory first. - if (json.params.deploymentFactory == address(0)) { - json.params.deploymentFactory = super.deployDeploymentFactory(deployer); - } else { - factory = IDeploymentFactory(json.params.deploymentFactory); - LibDeploy.state().factory = factory; + if (json.params.factory == address(0)) { + json.params.factory = address(LibDeploy.createFactory(deployer)); } + + LibDeploy.state().factory = (factory = IDeploymentFactory(json.params.factory)); // Create configured mocks, updates the received config with addresses. json = json.createMocks(deployer); - pythEp = IPyth(json.params.common.pythEp); - pyth.get[block.chainid] = pythEp; + pyth.get[block.chainid] = IPyth(json.params.common.pythEp); weth = json.assets.wNative.token; // Set tokens to cache as we know them at this point. json.cacheExtTokens(); - if (json.params.common.gatingManager == address(0)) { - json.params.common.gatingManager = super.deployGatingManager(json, deployer); - } else { - gatingManager = IGatingManager(json.params.common.gatingManager); - } - // Create base contracts address diamond = super.deployDiamond(json, deployer, salts.kresko); if (json.params.common.marketStatusProvider == address(0)) { - json.params.common.marketStatusProvider = address(json.createMockMarketStatusProvider()); + json.params.common.marketStatusProvider = json.createMockMarketStatusProvider(); } kresko.setMarketStatusProvider(json.params.common.marketStatusProvider); @@ -101,15 +87,12 @@ contract Deploy is DeployBase { delete routeCache; /* ---------------------------- Periphery --------------------------- */ - multicall = json.createMulticall(diamond, address(kiss), address(pythEp), salts.multicall); - + multicall = json.createMulticall(diamond, address(kiss), address(pyth.get[block.chainid]), salts.multicall); /* ------------------------------ Users ----------------------------- */ if (json.users.accounts.length > 0) { - setupUsers(json, deployer, disableLog); + setupUsers(json, disableLog); } - gatingManager.setPhase(json.params.gatingPhase); - if (!disableLog) Log.clg(json.params.gatingPhase, "Gating phase set to: "); /* --------------------- Remove deployer access --------------------- */ address admin = json.params.common.admin; if (admin != deployer) { @@ -129,6 +112,7 @@ contract Deploy is DeployBase { Log.clg("Deployment finished!"); Log.hr(); } + return json; } @@ -197,12 +181,12 @@ contract Deploy is DeployBase { /* USER SETUPS */ /* ---------------------------------------------------------------------- */ - function setupUsers(JSON.Config memory json, address deployer, bool disableLog) private reclearCallers { + function setupUsers(JSON.Config memory json, bool disableLog) private reclearCallers { + payable(address(kresko)).transfer(0.00001 ether); updatePythLocal(json.getMockPrices()); setupBalances(json.users, json.assets); setupSCDP(json.users, json.assets); setupMinter(json.users, json.assets); - setupNFTs(json.users.nfts.nftsFrom == address(0) ? deployer : json.users.nfts.nftsFrom, json.users, json.params); if (!disableLog) { for (uint256 i; i < json.users.accounts.length; i++) { @@ -316,7 +300,10 @@ contract Deploy is DeployBase { payable(user).transfer(0.005 ether); broadcastWith(user); } - kresko.mintKreskoAsset{value: updateFee}(MintArgs(user, pos.mintSymbol.cached(), pos.mintAmount, user), updateData); + kresko.mintKreskoAsset{value: pyth.viewData.ids.length}( + MintArgs(user, pos.mintSymbol.cached(), pos.mintAmount, user), + pyth.update + ); } function setupKISSBalance( @@ -362,48 +349,6 @@ contract Deploy is DeployBase { } } - function setupNFTs(address _owner, JSON.Users memory users, JSON.Params memory params) private broadcasted(_owner) { - if (users.nfts.userCount == 0) return; - IERC1155 okNFT = IERC1155(params.periphery.okNFT); - IERC1155 qfkNFT = IERC1155(params.periphery.qfkNFT); - for (uint256 i; i < users.nfts.userCount; i++) { - address user = users.get(i); - if (users.nfts.useMocks) { - if (i < 5) { - okNFT.mint(user, 0, 3, ""); - } - if (i < 3) { - qfkNFT.mint(user, 0, 1, ""); - } - if (i < 2) { - qfkNFT.mint(user, 1, 1, ""); - qfkNFT.mint(user, 2, 1, ""); - } - if (i == 0) { - qfkNFT.mint(user, 2, 1, ""); - qfkNFT.mint(user, 3, 1, ""); - qfkNFT.mint(user, 4, 1, ""); - qfkNFT.mint(user, 5, 1, ""); - qfkNFT.mint(user, 6, 1, ""); - qfkNFT.mint(user, 7, 1, ""); - } - } else { - if (i < 3) { - okNFT.safeTransferFrom(_owner, user, 0, 1, ""); - } - if (i < 2) { - qfkNFT.safeTransferFrom(_owner, user, 1, 1, ""); - } - if (i == 0) { - qfkNFT.safeTransferFrom(_owner, user, 2, 1, ""); - qfkNFT.safeTransferFrom(_owner, user, 3, 1, ""); - qfkNFT.safeTransferFrom(_owner, user, 4, 1, ""); - qfkNFT.safeTransferFrom(_owner, user, 5, 1, ""); - } - } - } - } - function _maybeApprove(address token, address spender, uint256 amount) internal { if (MockERC20(token).allowance(peekSender(), spender) < amount) { MockERC20(token).approve(spender, type(uint256).max); diff --git a/src/contracts/scripts/deploy/DeployBase.s.sol b/src/contracts/scripts/deploy/DeployBase.s.sol index 430ecb22..d32235b7 100644 --- a/src/contracts/scripts/deploy/DeployBase.s.sol +++ b/src/contracts/scripts/deploy/DeployBase.s.sol @@ -9,25 +9,25 @@ import {Based} from "kresko-lib/utils/Based.s.sol"; import {IKresko} from "periphery/IKresko.sol"; import {IKISS} from "kiss/interfaces/IKISS.sol"; import {IVault} from "vault/interfaces/IVault.sol"; -import {InitializerMismatch, SelectorBytecodeMismatch, DiamondBomb} from "scripts/utils/DiamondBomb.sol"; +import {InitializerMismatch, DiamondBomb} from "scripts/utils/DiamondBomb.sol"; import {IDeploymentFactory} from "factory/IDeploymentFactory.sol"; import {IKrMulticall} from "periphery/IKrMulticall.sol"; -import {IGatingManager} from "periphery/IGatingManager.sol"; import {LibDeploy} from "scripts/deploy/libs/LibDeploy.s.sol"; import {IWETH9} from "kresko-lib/token/IWETH9.sol"; import {MinterConfigFacet} from "minter/facets/MinterConfigFacet.sol"; import {CommonConfigFacet} from "common/facets/CommonConfigFacet.sol"; import {SCDPConfigFacet} from "scdp/facets/SCDPConfigFacet.sol"; -import {IPyth, PythView} from "kresko-lib/vendor/Pyth.sol"; +import {PythView} from "kresko-lib/vendor/Pyth.sol"; import "scripts/deploy/JSON.s.sol" as JSON; -import {create1, getFacetsAndSelectors} from "scripts/deploy/DeployFuncs.s.sol"; +import {FacetData, getFacets, create1} from "kresko-lib/utils/ffi/ffi-facets.s.sol"; abstract contract DeployBase is Based { using LibDeploy for bytes; using LibDeploy for bytes32; using LibDeploy for JSON.Config; + string facetLoc = "./src/contracts/core/**/facets/*Facet.sol"; uint256 internal constant INITIALIZER_COUNT = 3; @@ -37,45 +37,37 @@ abstract contract DeployBase is Based { IVault vault; IDeploymentFactory factory; IKrMulticall multicall; - IGatingManager gatingManager; - IPyth pythEp; IWETH9 weth; - function deployDeploymentFactory(address _deployer) internal returns (address) { - return address(factory = LibDeploy.createFactory(_deployer)); - } - - function deployGatingManager(JSON.Config memory json, address _deployer) internal returns (address) { - return address(gatingManager = json.createGatingManager(_deployer)); + modifier saveOutput(string memory id) { + LibDeploy.JSONKey(id); + _; + LibDeploy.saveJSONKey(); } - function deployDiamond(JSON.Config memory json, address _deployer, bytes32 salt) internal returns (address) { + function deployDiamond( + JSON.Config memory json, + address _deployer, + bytes32 salt + ) internal saveOutput("Kresko") returns (address) { paramsJSON = json.params; - require(address(LibDeploy.state().factory) != address(0), "deployDiamond: No factory"); + require(address(LibDeploy.state().factory) != address(0), "No factory"); (FacetCut[] memory facets, Initializer[] memory initializers) = deployFacets(json); - LibDeploy.JSONKey("Kresko"); bytes memory initCode = type(Diamond).creationCode.ctor(abi.encode(_deployer, facets, initializers)); LibDeploy.setJsonBytes("INIT_CODE_HASH", bytes.concat(keccak256(initCode))); kresko = IKresko(initCode.d2("", salt).implementation); - LibDeploy.saveJSONKey(); return address(kresko); } - function diamondCtor(JSON.Config memory json, address _deployer) internal returns (bytes32) { - paramsJSON = json.params; - require(address(LibDeploy.state().factory) != address(0), "deployDiamond: No factory"); - (FacetCut[] memory facets, Initializer[] memory initializers) = deployFacets(json); - return keccak256(abi.encodePacked(type(Diamond).creationCode, abi.encode(_deployer, facets, initializers))); - } - function deployFacets(JSON.Config memory json) private returns (FacetCut[] memory cuts, Initializer[] memory inits) { - (, bytes[] memory facets, bytes4[][] memory selectors) = getFacetsAndSelectors(); + FacetData[] memory facets = getFacets(facetLoc); + bytes4[][] memory selectors = new bytes4[][](facets.length); + for (uint256 i; i < facets.length; i++) { + selectors[i] = facets[i].selectors; + } (uint256[] memory initIds, bytes[] memory initDatas) = getInitializers(json, selectors); - if (facets.length != selectors.length) { - revert SelectorBytecodeMismatch(selectors.length, facets.length); - } if (initIds.length != initDatas.length) { revert InitializerMismatch(initIds.length, initDatas.length); } @@ -83,8 +75,8 @@ abstract contract DeployBase is Based { inits = new Initializer[](initDatas.length); for (uint256 i; i < facets.length; ) { cuts[i].action = FacetCutAction.Add; - cuts[i].facetAddress = create1(facets[i]); - cuts[i].functionSelectors = selectors[i]; + cuts[i].facetAddress = create1(facets[i].facet); + cuts[i].functionSelectors = facets[i].selectors; unchecked { i++; } @@ -129,13 +121,22 @@ abstract contract DeployBase is Based { } function deployDiamondOneTx(JSON.Config memory json, address _deployer) internal returns (IKresko) { - (, bytes[] memory facets, bytes4[][] memory selectors) = getFacetsAndSelectors(); + FacetData[] memory facetDatas = getFacets(facetLoc); + + bytes[] memory facets = new bytes[](facetDatas.length); + bytes4[][] memory selectors = new bytes4[][](facetDatas.length); + + for (uint256 i; i < facetDatas.length; i++) { + facets[i] = facetDatas[i].facet; + selectors[i] = facetDatas[i].selectors; + } + (uint256[] memory initializers, bytes[] memory calldatas) = getInitializers(json, selectors); return (kresko = IKresko(address(new DiamondBomb().create(_deployer, facets, selectors, initializers, calldatas)))); } function updatePythLocal(PythView memory _prices) internal { getMockPayload(_prices); - updatePyth(pyth.update, pyth.cost); + updatePyth(pyth.update, 0); } } diff --git a/src/contracts/scripts/deploy/DeployFuncs.s.sol b/src/contracts/scripts/deploy/DeployFuncs.s.sol deleted file mode 100644 index 6f2803b0..00000000 --- a/src/contracts/scripts/deploy/DeployFuncs.s.sol +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.21; - -import {vmFFI} from "kresko-lib/utils/s/Base.s.sol"; - -function getFacetsAndSelectors() returns (string[] memory files, bytes[] memory facets, bytes4[][] memory selectors) { - string[] memory cmd = new string[](2); - cmd[0] = "./utils/getBytesAndSelectors.sh"; - cmd[1] = "./src/contracts/core/**/facets/*Facet.sol"; - - (files, selectors) = abi.decode(vmFFI.ffi(cmd), (string[], bytes4[][])); - facets = new bytes[](selectors.length); - - for (uint256 i; i < files.length; ) { - (, bytes memory getCodeResult) = address(vmFFI).call( - abi.encodeWithSignature("getCode(string)", string.concat(files[i], ".sol:", files[i])) - ); - facets[i] = abi.decode(getCodeResult, (bytes)); - unchecked { - i++; - } - } - require(facets.length == selectors.length, "Facets and selectors length mismatch"); - return (files, facets, selectors); -} - -function getFacetsAndSelectors( - string memory artifact -) returns (string[] memory files, bytes[] memory facets, bytes4[][] memory selectors) { - string[] memory cmd = new string[](2); - cmd[0] = "./utils/getBytesAndSelectors.sh"; - cmd[1] = string.concat("./src/contracts/core/**/facets/", artifact, ".sol"); - - (files, selectors) = abi.decode(vmFFI.ffi(cmd), (string[], bytes4[][])); - facets = new bytes[](selectors.length); - - for (uint256 i; i < files.length; ) { - (, bytes memory getCodeResult) = address(vmFFI).call( - abi.encodeWithSignature("getCode(string)", string.concat(files[i], ".sol:", files[i])) - ); - facets[i] = abi.decode(getCodeResult, (bytes)); - unchecked { - i++; - } - } - require(facets.length == selectors.length, "Facets and selectors length mismatch"); - return (files, facets, selectors); -} - -function create1(bytes memory bytecode) returns (address location) { - assembly { - location := create(0, add(bytecode, 0x20), mload(bytecode)) - } -} diff --git a/src/contracts/scripts/deploy/JSON.s.sol b/src/contracts/scripts/deploy/JSON.s.sol index dbc97b06..0a27efa9 100644 --- a/src/contracts/scripts/deploy/JSON.s.sol +++ b/src/contracts/scripts/deploy/JSON.s.sol @@ -10,6 +10,7 @@ import {Help, Utils, mAddr, mvm} from "kresko-lib/utils/s/LibVm.s.sol"; import {CONST} from "scripts/deploy/CONST.s.sol"; import {PLog} from "kresko-lib/utils/s/PLog.s.sol"; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; + struct Files { string params; string assets; @@ -20,14 +21,14 @@ using Help for string; using Utils for string; function getConfig(string memory network, string memory configId) returns (Config memory json) { - string memory dir = string.concat(CONST.CONFIG_DIR, network, "/"); + string memory dir = CONST.CONFIG_DIR.cc(network, "/"); return getConfigFrom(dir, configId); } function getSalts(string memory network, string memory configId) returns (Salts memory) { - string memory dir = string.concat(CONST.CONFIG_DIR, network, "/"); - string memory location = string.concat(dir, "salts-", configId, ".json"); + string memory dir = CONST.CONFIG_DIR.cc(network, "/"); + string memory location = dir.cc("salts-", configId, ".json"); if (!mvm.exists(location)) { return Salts({kresko: bytes32("Kresko"), multicall: bytes32("Multicall")}); } @@ -38,19 +39,19 @@ function getSalts(string memory network, string memory configId) returns (Salts function getConfigFrom(string memory dir, string memory configId) returns (Config memory json) { Files memory files; - files.params = string.concat(dir, "params-", configId, ".json"); + files.params = dir.cc("params-", configId, ".json"); if (!mvm.exists(files.params)) { - revert(string.concat("No configuration exists: ", files.params)); + revert(files.params.cc(": no configuration exists.")); } - files.assets = string.concat(dir, "assets-", configId, ".json"); + files.assets = dir.cc("assets-", configId, ".json"); if (!mvm.exists(files.assets)) { - revert(string.concat("No asset configuration exists: ", files.assets)); + revert(files.assets.cc(": no asset configuration exists.")); } json.params = abi.decode(mvm.parseJson(mvm.readFile(files.params)), (Params)); json.assets = getAssetConfigFrom(dir, configId); - files.users = string.concat(dir, "users-", configId, ".json"); + files.users = dir.cc("users-", configId, ".json"); if (mvm.exists(files.users)) { json.users = abi.decode(mvm.parseJson(mvm.readFile(files.users)), (Users)); } @@ -64,16 +65,16 @@ function getConfigFrom(string memory dir, string memory configId) returns (Confi // stacks too deep so need to split assets into separate function function getAssetConfig(string memory network, string memory configId) returns (Assets memory json) { - string memory dir = string.concat(CONST.CONFIG_DIR, network, "/"); + string memory dir = CONST.CONFIG_DIR.cc(network, "/"); return getAssetConfigFrom(dir, configId); } function getAssetConfigFrom(string memory dir, string memory configId) returns (Assets memory) { Files memory files; - files.assets = string.concat(dir, "assets-", configId, ".json"); + files.assets = dir.cc("assets-", configId, ".json"); if (!mvm.exists(files.assets)) { - revert(string.concat("No asset configuration exists: ", files.assets)); + revert(files.assets.cc(": no asset configuration exists.")); } return abi.decode(mvm.parseJson(mvm.readFile(files.assets)), (Assets)); @@ -139,12 +140,11 @@ struct Config { struct Params { string configId; - address deploymentFactory; + address factory; CommonInitArgs common; SCDPInitArgs scdp; MinterInitArgs minter; Periphery periphery; - uint8 gatingPhase; } struct Periphery { diff --git a/src/contracts/scripts/deploy/libs/Deployed.s.sol b/src/contracts/scripts/deploy/libs/Deployed.s.sol index 72c5ff04..804a0f6c 100644 --- a/src/contracts/scripts/deploy/libs/Deployed.s.sol +++ b/src/contracts/scripts/deploy/libs/Deployed.s.sol @@ -2,12 +2,11 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import {Help, Utils, mvm} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Utils, mvm} from "kresko-lib/utils/s/LibVm.s.sol"; import {Asset} from "common/Types.sol"; import {IDeploymentFactory} from "factory/IDeploymentFactory.sol"; library Deployed { - using Help for *; using Utils for *; struct Cache { diff --git a/src/contracts/scripts/deploy/libs/LibDeploy.s.sol b/src/contracts/scripts/deploy/libs/LibDeploy.s.sol index c6614f86..1e5db01a 100644 --- a/src/contracts/scripts/deploy/libs/LibDeploy.s.sol +++ b/src/contracts/scripts/deploy/libs/LibDeploy.s.sol @@ -12,14 +12,11 @@ import {KrMulticall} from "periphery/KrMulticall.sol"; import {Role} from "common/Constants.sol"; import {IKresko} from "periphery/IKresko.sol"; import {Help, Log, Utils, mvm} from "kresko-lib/utils/s/LibVm.s.sol"; -import {GatingManager} from "periphery/GatingManager.sol"; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; import {CONST} from "scripts/deploy/CONST.s.sol"; import {IDeploymentFactory} from "factory/IDeploymentFactory.sol"; -import {MockPyth} from "kresko-lib/mocks/MockPyth.sol"; -import {PythView} from "kresko-lib/vendor/Pyth.sol"; import {LibJSON, JSON} from "scripts/deploy/libs/LibJSON.s.sol"; -import {MockMarketStatus} from "mocks-misc/MockMarketStatus.sol"; +import {MockMarketStatus, MockPyth} from "mocks/Mocks.sol"; library LibDeploy { using Conversions for bytes[]; @@ -32,31 +29,20 @@ library LibDeploy { using LibDeploy for bytes32; function createFactory(address _owner) internal saveOutput("Factory") returns (DeploymentFactory result) { - result = new DeploymentFactory(_owner); + state().factory = (result = new DeploymentFactory(_owner)); setJsonAddr("address", address(result)); setJsonBytes("ctor", abi.encode(_owner)); - state().factory = result; } - function createGatingManager( - JSON.Config memory json, - address _owner - ) internal saveOutput("GatingManager") returns (GatingManager) { - bytes memory implementation = type(GatingManager).creationCode.ctor( - abi.encode(_owner, json.params.periphery.okNFT, json.params.periphery.qfkNFT, 0) - ); - return GatingManager(implementation.d3("", CONST.GM_SALT).implementation); - } - - function createMockMarketStatusProvider(JSON.Config memory) internal saveOutput("MarketStatus") returns (MockMarketStatus) { - return MockMarketStatus(type(MockMarketStatus).creationCode.d3("", CONST.MOCK_STATUS_SALT).implementation); + function createMockMarketStatusProvider(JSON.Config memory) internal saveOutput("MarketStatus") returns (address) { + return type(MockMarketStatus).creationCode.d3("", CONST.MOCK_STATUS_SALT).implementation; } - function createMockPythEP(JSON.Config memory json) internal saveOutput("MockPythEP") returns (MockPyth) { - bytes[] memory ctor = new bytes[](1); - ctor[0] = abi.encode(json.getMockPrices()); - bytes memory implementation = type(MockPyth).creationCode.ctor(abi.encode(ctor)); - return MockPyth(implementation.d3("", CONST.PYTH_MOCK_SALT).implementation); + function createMockPythEP(JSON.Config memory json) internal saveOutput("MockPythEP") returns (address) { + bytes[] memory args = new bytes[](1); + args[0] = abi.encode(json.getMockPrices()); + bytes memory implementation = type(MockPyth).creationCode.ctor(abi.encode(args)); + return implementation.d3("", CONST.PYTH_MOCK_SALT).implementation; } function createKISS( @@ -76,8 +62,8 @@ library LibDeploy { } function createVault(JSON.Config memory json, address _owner) internal saveOutput("Vault") returns (Vault) { - string memory name = string.concat(CONST.VAULT_NAME_PREFIX, json.assets.kiss.name); - string memory symbol = string.concat(CONST.VAULT_SYMBOL_PREFIX, json.assets.kiss.symbol); + string memory name = CONST.VAULT_NAME_PREFIX.cc(json.assets.kiss.name); + string memory symbol = CONST.VAULT_SYMBOL_PREFIX.cc(json.assets.kiss.symbol); bytes memory implementation = type(Vault).creationCode.ctor( abi.encode(name, symbol, 18, 8, _owner, json.params.common.treasury, json.params.common.sequencerUptimeFeed) ); @@ -221,7 +207,7 @@ library LibDeploy { return pkr3(json.assets.kreskoAssets[i]); } } - revert(string.concat("!assetAddr: ", symbol)); + revert(("!assetAddr: ").cc(symbol)); } bytes32 internal constant DEPLOY_STATE_SLOT = keccak256("DeployState"); diff --git a/src/contracts/scripts/deploy/libs/LibDeployUtils.s.sol b/src/contracts/scripts/deploy/libs/LibDeployUtils.s.sol index 1151b486..8579baa3 100644 --- a/src/contracts/scripts/deploy/libs/LibDeployUtils.s.sol +++ b/src/contracts/scripts/deploy/libs/LibDeployUtils.s.sol @@ -3,7 +3,7 @@ pragma solidity ^0.8.0; import {Asset, RawPrice} from "common/Types.sol"; import {IERC20} from "kresko-lib/token/IERC20.sol"; import {IKresko} from "periphery/IKresko.sol"; -import {Help, Log, Utils} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log, Utils} from "kresko-lib/utils/s/LibVm.s.sol"; import {VaultAsset} from "vault/VTypes.sol"; import {IVault} from "vault/interfaces/IVault.sol"; import {SwapRouteSetter} from "scdp/STypes.sol"; @@ -16,7 +16,6 @@ import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; library LibDeployUtils { using Log for *; using Utils for *; - using Help for *; using LibDeploy for *; using LibJSON for *; using Deployed for *; diff --git a/src/contracts/scripts/deploy/libs/LibJSON.s.sol b/src/contracts/scripts/deploy/libs/LibJSON.s.sol index 6a39e418..5470403c 100644 --- a/src/contracts/scripts/deploy/libs/LibJSON.s.sol +++ b/src/contracts/scripts/deploy/libs/LibJSON.s.sol @@ -1,7 +1,7 @@ // solhint-disable state-visibility // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import {Help, Utils, Log, mvm} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Utils} from "kresko-lib/utils/s/LibVm.s.sol"; import {Asset, FeedConfiguration} from "common/Types.sol"; import {Enums} from "common/Constants.sol"; import {VaultAsset} from "vault/VTypes.sol"; @@ -14,7 +14,6 @@ import {IAggregatorV3} from "kresko-lib/vendor/IAggregatorV3.sol"; import {PythView, Price} from "kresko-lib/vendor/Pyth.sol"; library LibJSON { - using Help for *; using Utils for *; using LibDeploy for string; using LibJSON for *; diff --git a/src/contracts/scripts/deploy/libs/LibMocks.s.sol b/src/contracts/scripts/deploy/libs/LibMocks.s.sol index d8cd0037..2c069eb7 100644 --- a/src/contracts/scripts/deploy/libs/LibMocks.s.sol +++ b/src/contracts/scripts/deploy/libs/LibMocks.s.sol @@ -1,16 +1,13 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import {MockOracle} from "mocks/MockOracle.sol"; -import {MockERC20} from "mocks/MockERC20.sol"; import {Deployment} from "factory/IDeploymentFactory.sol"; import {LibDeploy} from "scripts/deploy/libs/LibDeploy.s.sol"; import {JSON, LibJSON} from "scripts/deploy/libs/LibJSON.s.sol"; -import {MockSequencerUptimeFeed} from "mocks/MockSequencerUptimeFeed.sol"; import {WETH9} from "kresko-lib/token/WETH9.sol"; import {LibSafe} from "kresko-lib/mocks/MockSafe.sol"; import {PythView} from "kresko-lib/vendor/Pyth.sol"; import {IWETH9} from "kresko-lib/token/IWETH9.sol"; -import {MockERC1155} from "mocks/MockERC1155.sol"; +import {MockERC1155, MockSequencerUptimeFeed, MockERC20, MockOracle} from "mocks/Mocks.sol"; import {Help, mvm, Utils} from "kresko-lib/utils/s/LibVm.s.sol"; library LibMocks { diff --git a/src/contracts/scripts/tasks/DeployPeriphery.s.sol b/src/contracts/scripts/tasks/DeployPeriphery.s.sol index 880be445..88a699bb 100644 --- a/src/contracts/scripts/tasks/DeployPeriphery.s.sol +++ b/src/contracts/scripts/tasks/DeployPeriphery.s.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import {Help, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {KrMulticall} from "periphery/KrMulticall.sol"; import {ArbDeployAddr} from "kresko-lib/info/ArbDeployAddr.sol"; import {Scripted} from "kresko-lib/utils/s/Scripted.s.sol"; @@ -10,7 +10,6 @@ import {Scripted} from "kresko-lib/utils/s/Scripted.s.sol"; contract DeployPeriphery is Scripted, ArbDeployAddr { using Log for *; - using Help for *; function setUp() public { useMnemonic("MNEMONIC_DEPLOY"); diff --git a/src/contracts/scripts/tasks/DiamondCuts.s.sol b/src/contracts/scripts/tasks/DiamondCuts.s.sol index 3be655af..2ff89770 100644 --- a/src/contracts/scripts/tasks/DiamondCuts.s.sol +++ b/src/contracts/scripts/tasks/DiamondCuts.s.sol @@ -1,19 +1,16 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import {Help, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {Cutter} from "kresko-lib/utils/ffi/Cutter.s.sol"; import {deployPayload} from "scripts/payloads/Payloads.sol"; import {ArbDeployAddr} from "kresko-lib/info/ArbDeployAddr.sol"; -import {Arrays} from "libs/Arrays.sol"; import {gm} from "common/State.sol"; import {IGatingManager} from "periphery/IGatingManager.sol"; // solhint-disable no-empty-blocks, reason-string, state-visibility contract DiamondCutPayload is ArbDeployAddr { - using Arrays for address[]; - function initialize() public { gm().manager = IGatingManager(address(0)); revert("DiamondCutPayload: not implemented"); @@ -22,7 +19,6 @@ contract DiamondCutPayload is ArbDeployAddr { contract DiamondCuts is Cutter { using Log for *; - using Help for *; function setUp() public virtual { useMnemonic("MNEMONIC"); diff --git a/src/contracts/scripts/utils/ArbScript.s.sol b/src/contracts/scripts/utils/ArbScript.s.sol index d49dc398..c95d8e57 100644 --- a/src/contracts/scripts/utils/ArbScript.s.sol +++ b/src/contracts/scripts/utils/ArbScript.s.sol @@ -3,11 +3,9 @@ pragma solidity ^0.8.0; import {Based} from "kresko-lib/utils/Based.s.sol"; import {IKresko} from "periphery/IKresko.sol"; -import {Help, Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log} from "kresko-lib/utils/s/LibVm.s.sol"; -import {IGatingManager} from "periphery/IGatingManager.sol"; -import {IKrMulticall, ISwapRouter} from "periphery/IKrMulticall.sol"; -import {IDeploymentFactory} from "factory/IDeploymentFactory.sol"; +import {IKrMulticall} from "periphery/IKrMulticall.sol"; import {IERC20} from "kresko-lib/token/IERC20.sol"; import {Asset, Oracle} from "common/Types.sol"; import {ArbDeploy} from "kresko-lib/info/ArbDeploy.sol"; @@ -19,18 +17,16 @@ import {Enums} from "common/Constants.sol"; contract ArbScript is Based, ArbDeploy { using Log for *; - using Help for *; IKrMulticall multicall = IKrMulticall(multicallAddr); IKresko kresko = IKresko(kreskoAddr); - IGatingManager manager = IGatingManager(0x13f14aB44B434F16D88645301515C899d69A30Bd); function initialize(string memory mnemonic) internal { base(mnemonic, "RPC_ARBITRUM_ALCHEMY"); Deployed.factory(factoryAddr); } - function initialize(uint256 blockNr) internal repranked(safe) { + function initialize(uint256 blockNr) internal { vm.createSelectFork("arbitrum", blockNr); Deployed.factory(factoryAddr); states_looseOracles(); diff --git a/src/contracts/scripts/utils/AssetAdder.s.sol b/src/contracts/scripts/utils/AssetAdder.s.sol index 837ce5b8..2608bbfa 100644 --- a/src/contracts/scripts/utils/AssetAdder.s.sol +++ b/src/contracts/scripts/utils/AssetAdder.s.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.0; import {ArbScript, Asset} from "scripts/utils/ArbScript.s.sol"; -import {Help, Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; import "scripts/deploy/JSON.s.sol" as JSON; import {LibDeploy} from "scripts/deploy/libs/LibDeploy.s.sol"; import {LibJSON} from "scripts/deploy/libs/LibJSON.s.sol"; @@ -13,7 +13,6 @@ import {IAggregatorV3} from "kresko-lib/vendor/IAggregatorV3.sol"; contract AssetAdder is ArbScript { using Log for *; - using Help for *; using Utils for *; using LibDeploy for *; using LibJSON for *; diff --git a/src/contracts/scripts/utils/DiamondBomb.sol b/src/contracts/scripts/utils/DiamondBomb.sol index c333f423..40b1a338 100644 --- a/src/contracts/scripts/utils/DiamondBomb.sol +++ b/src/contracts/scripts/utils/DiamondBomb.sol @@ -2,6 +2,7 @@ pragma solidity >=0.8.19; import {FacetCut, FacetCutAction, Initializer} from "diamond/DSTypes.sol"; import {Diamond} from "diamond/Diamond.sol"; +import {FacetData} from "kresko-lib/utils/ffi/ffi-facets.s.sol"; error InitializerMismatch(uint256 initializerCount, uint256 initializerArgsCount); error SelectorBytecodeMismatch(uint256 selectorCount, uint256 bytecodeCount); diff --git a/src/contracts/test/AddKrAsset.t.sol b/src/contracts/test/AddKrAsset.t.sol index 50e754df..9a7f14ca 100644 --- a/src/contracts/test/AddKrAsset.t.sol +++ b/src/contracts/test/AddKrAsset.t.sol @@ -27,7 +27,7 @@ contract AddKrAssetTest is Tested, AddKrAsset { uint256 testMint; function setUp() public override { - super.initialize(231759536); + super.initialize(231869463); bytes32[] memory tickers = new bytes32[](1); bytes32[] memory exchanges = new bytes32[](1); tickers[0] = bytes32("DOGE"); @@ -35,26 +35,25 @@ contract AddKrAssetTest is Tested, AddKrAsset { prank(safe); marketStatus.setTickers(tickers, exchanges); - createAddKrAsset(); updatePyth(); syncTime(); + createAddKrAsset(); + assetConfig = kresko.getAsset(newAssetAddr); newAsset = KreskoAsset(newAssetAddr); newAssetAnchor = KreskoAssetAnchor(newAsset.anchor()); testMint = (testMintValue).wdiv(kresko.getPrice(newAssetAddr)); - prank(safe); + prank(safe); (user0, user1) = (address(0x1234), address(0x4321)); address[2] memory testUsers = [user0, user1]; for (uint256 i; i < testUsers.length; i++) { address testUser = testUsers[i]; - deal(testUser, 1 ether); deal(usdcAddr, testUser, 100_000e6); dealERC1155(kreskianAddr, testUser, 0, 1); - prank(testUser); approvals(); newAsset.approve(kreskoAddr, type(uint256).max); @@ -89,7 +88,7 @@ contract AddKrAssetTest is Tested, AddKrAsset { marketStatus.getTickerStatus(assetConfig.ticker).eq(expectedMarketStatus, "ticker-market-status"); } - function testTradeRoutes() external { + function testTradeRoutes() external view { address[] memory assets = kresko.getKreskoAssetsSCDP(); for (uint256 i; i < assets.length; i++) { diff --git a/src/contracts/test/BatchTest.t.sol b/src/contracts/test/BatchTest.t.sol index f5185eea..8fb89b7a 100644 --- a/src/contracts/test/BatchTest.t.sol +++ b/src/contracts/test/BatchTest.t.sol @@ -7,7 +7,7 @@ import {IMinterDepositWithdrawFacet} from "minter/interfaces/IMinterDepositWithd import {IMinterAccountStateFacet} from "minter/interfaces/IMinterAccountStateFacet.sol"; import {PLog} from "kresko-lib/utils/s/PLog.s.sol"; import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; -import {MockERC20} from "mocks/MockERC20.sol"; +import {MockERC20} from "mocks/Mocks.sol"; import {IMinterMintFacet} from "minter/interfaces/IMinterMintFacet.sol"; import {MintArgs} from "common/Args.sol"; import {IKresko} from "periphery/IKresko.sol"; @@ -56,7 +56,7 @@ contract BatchTest is Tested, Deploy { calls[2] = abi.encodeCall(IMinterMintFacet.mintKreskoAsset, (MintArgs(user, krETH, 0.1 ether, user), new bytes[](0))); calls[3] = abi.encodeCall(IMinterMintFacet.mintKreskoAsset, (MintArgs(user, krJPY, 10000 ether, user), new bytes[](0))); - kresko.batchCall{value: updateFee}(calls, updateData); + kresko.batchCall{value: pyth.cost}(calls, pyth.update); DAI.balanceOf(user).eq(600 ether, "user-dai-balance"); USDC.balanceOf(user).eq(900e6, "user-usdc-balance"); @@ -68,8 +68,8 @@ contract BatchTest is Tested, Deploy { function testBatchStaticCall() public pranked(user) { kresko.depositCollateral(user, address(DAI), 400 ether); kresko.depositCollateral(user, address(USDC), 100e6); - kresko.mintKreskoAsset{value: updateFee}(MintArgs(user, krETH, 0.1 ether, user), updateData); - kresko.mintKreskoAsset{value: updateFee}(MintArgs(user, krJPY, 10000 ether, user), updateData); + kresko.mintKreskoAsset{value: pyth.cost}(MintArgs(user, krETH, 0.1 ether, user), pyth.update); + kresko.mintKreskoAsset{value: pyth.cost}(MintArgs(user, krJPY, 10000 ether, user), pyth.update); bytes[] memory staticCalls = new bytes[](4); staticCalls[0] = abi.encodeCall(IMinterAccountStateFacet.getAccountCollateralAmount, (user, address(DAI))); @@ -78,7 +78,7 @@ contract BatchTest is Tested, Deploy { staticCalls[3] = abi.encodeCall(IMinterAccountStateFacet.getAccountDebtAmount, (user, krJPY)); uint256 nativeBalBefore = user.balance; - (uint256 time, bytes[] memory data) = kresko.batchStaticCall{value: updateFee}(staticCalls, updateData); + (uint256 time, bytes[] memory data) = kresko.batchStaticCall{value: pyth.cost}(staticCalls, pyth.update); abi.decode(data[0], (uint256)).eq(400 ether, "static-user-dai-collateral"); abi.decode(data[1], (uint256)).eq(100e6, "static-user-usdc-collateral"); @@ -94,14 +94,14 @@ contract BatchTest is Tested, Deploy { calls[0] = abi.encodeCall(IMinterDepositWithdrawFacet.depositCollateral, (user, address(DAI), 400 ether)); vm.expectRevert(); - kresko.batchStaticCall{value: updateFee}(calls, updateData); + kresko.batchStaticCall{value: pyth.cost}(calls, pyth.update); } function testReentry() public pranked(user) { bytes[] memory calls = new bytes[](1); calls[0] = abi.encodeCall(IMinterAccountStateFacet.getAccountCollateralAmount, (user, address(DAI))); - Reentrant reentrant = new Reentrant(kresko, calls, updateData); + Reentrant reentrant = new Reentrant(kresko, calls, pyth.update); vm.deal(address(kresko), 1 ether); vm.deal(address(reentrant), 0.001 ether); diff --git a/src/contracts/test/Complex.t.sol b/src/contracts/test/Complex.t.sol index afbc3e50..1da6d039 100644 --- a/src/contracts/test/Complex.t.sol +++ b/src/contracts/test/Complex.t.sol @@ -4,20 +4,18 @@ pragma solidity ^0.8.0; // solhint-disable state-visibility, avoid-low-level-calls, no-console, max-states-count, var-name-mixedcase, no-global-import, const-name-snakecase, no-empty-blocks, no-console import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; -import {Help, Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {VaultAsset} from "vault/VTypes.sol"; import {IERC20} from "kresko-lib/token/IERC20.sol"; import {Deploy} from "scripts/deploy/Deploy.s.sol"; import {KreskoAsset} from "kresko-asset/KreskoAsset.sol"; -import {MockERC20} from "mocks/MockERC20.sol"; +import {MockERC20, MockOracle} from "mocks/Mocks.sol"; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; -import {MockOracle} from "mocks/MockOracle.sol"; import "scripts/deploy/JSON.s.sol" as JSON; import {MintArgs, SCDPLiquidationArgs, SCDPWithdrawArgs, SwapArgs} from "common/Args.sol"; contract ComplexTest is Deploy { using ShortAssert for *; - using Help for *; using Log for *; using Utils for *; uint256 constant ETH_PRICE = 2000; @@ -64,7 +62,7 @@ contract ComplexTest is Deploy { usdc.approve(address(kresko), type(uint256).max); krETH.approve(address(kresko), type(uint256).max); // 1000 KISS -> 0.48 ETH - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, pyth.update)); } function testRebase() external { @@ -93,7 +91,7 @@ contract ComplexTest is Deploy { _setETHPrice(1000); krETH.rebase(2e18, true, new address[](0)); // 1000 KISS -> 0.96 ETH - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, pyth.update)); // previous debt amount 0.48 ETH, doubled after rebase so 0.96 ETH uint256 amountDebtAfter = kresko.getDebtSCDP(krETHAddr); amountDebtAfter.eq(0.96e18 + (0.48e18 * 2), "amount-debt-after"); @@ -158,10 +156,10 @@ contract ComplexTest is Deploy { kiss.balanceOf(userOther).eq(0, "bal-not-zero-after-deposit"); uint256 withdrawAmount = amount / 2; - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), pyth.update); kiss.balanceOf(userOther).eq(withdrawAmount, "bal-not-initial-after-withdraw"); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(withdrawAmount, "deposit-not-amount"); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), pyth.update); kiss.balanceOf(userOther).eq(amount, "bal-not-initial-after-withdraw"); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(0, "deposit-not-amount"); } @@ -177,10 +175,10 @@ contract ComplexTest is Deploy { kresko.depositSCDP(userOther, address(kiss), amount); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(amount, "deposit-not-amount"); kiss.balanceOf(userOther).eq(0, "bal-not-zero-after-deposit"); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), amount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), amount, userOther), pyth.update); kiss.balanceOf(userOther).eq(amount, "bal-not-initial-after-withdraw"); vm.expectRevert(); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), 1, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), 1, userOther), pyth.update); kresko.depositSCDP(userOther, address(kiss), amount); // Make it liquidatable _setETHPriceAndLiquidate(80000); @@ -189,8 +187,8 @@ contract ComplexTest is Deploy { uint256 deposits = kresko.getAccountDepositSCDP(userOther, address(kiss)); deposits.dlg("deposits"); vm.expectRevert(); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), amount, userOther), updateData); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), deposits, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), amount, userOther), pyth.update); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), deposits, userOther), pyth.update); kiss.balanceOf(userOther).eq(deposits, "bal-not-deposits-after-withdraw"); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(0, "deposit-not-zero-after-withdarw"); } @@ -211,11 +209,11 @@ contract ComplexTest is Deploy { kiss.balanceOf(userOther).eq(feesClaimed, "bal-not-zero"); kresko.getAccountFeesSCDP(userOther, address(kiss)).eq(0, "fees-not-zero-after-claim"); uint256 withdrawAmount = amount / 2; - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), pyth.update); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(withdrawAmount, "deposit-should-be-half-after-withdraw"); kresko.getAccountFeesSCDP(userOther, address(kiss)).eq(0, "fees-not-zero-after-withdraw"); kiss.balanceOf(userOther).eq(feesClaimed + withdrawAmount, "bal-not-zero-after-withdraw"); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), pyth.update); kiss.balanceOf(userOther).closeTo(feesClaimed + amount, 1); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(0, "deposit-should-be-zero-in-the-end"); } @@ -253,7 +251,7 @@ contract ComplexTest is Deploy { prank(userOther); uint256 feeAmount = kresko.getAccountFeesSCDP(userOther, address(kiss)); feeAmount.gt(0, "no-fees"); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), amount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), amount, userOther), pyth.update); kiss.balanceOf(userOther).eq(feeAmount + amount, "bal-not-zero"); kresko.getAccountFeesSCDP(userOther, address(kiss)).eq(0, "fees-not-zero-after-claim"); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(0, "deposit-not-zero-after-withdraw"); @@ -281,11 +279,11 @@ contract ComplexTest is Deploy { kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(depositsBeforeClaim, "deposit-should-be-same-after-claim"); kresko.getAccountFeesSCDP(userOther, address(kiss)).eq(0, "fees-not-zero-after-claim"); uint256 withdrawAmount = depositsBeforeClaim / 2; - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), pyth.update); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(withdrawAmount, "deposit-should-be-half-after-withdraw"); kresko.getAccountFeesSCDP(userOther, address(kiss)).eq(0, "fees-not-zero-after-withdraw"); kiss.balanceOf(userOther).eq(feesClaimed + withdrawAmount, "bal-not-zero-after-withdraw"); - kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(userOther, address(kiss), withdrawAmount, userOther), pyth.update); kiss.balanceOf(userOther).closeTo(feesClaimed + depositsBeforeClaim, 1); kresko.getAccountDepositSCDP(userOther, address(kiss)).eq(0, "deposit-should-be-zero-in-the-end"); } @@ -295,7 +293,7 @@ contract ComplexTest is Deploy { uint256 feesStart = kresko.getAccountFeesSCDP(getAddr(0), address(kiss)); // Swap, 1000 KISS -> 0.96 ETH prank(getAddr(0)); - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 2000e18, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 2000e18, 0, pyth.update)); uint256 feesUserAfterFirstSwap = kresko.getAccountFeesSCDP(getAddr(0), address(kiss)); uint256 totalSwapFees = feesUserAfterFirstSwap - feesStart; totalSwapFees.eq(feePerSwapTotal, "fees-should-equal-total"); @@ -357,7 +355,7 @@ contract ComplexTest is Deploy { _setETHPrice(test.ethPrice); krETH.rebase(test.rebaseMultiplier, test.positive, new address[](0)); // Swap, 1000 KISS -> 0.96 ETH - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 2000e18, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 2000e18, 0, pyth.update)); uint256 feesUserAfterFirstSwap = kresko.getAccountFeesSCDP(getAddr(0), address(kiss)); uint256 totalSwapFees = feesUserAfterFirstSwap - feesStart; totalSwapFees.eq(feePerSwapTotal, "fees-should-equal-total"); @@ -421,7 +419,7 @@ contract ComplexTest is Deploy { _setETHPrice(test.ethPrice); krETH.rebase(test.rebaseMultiplier, test.positive, new address[](0)); // Swap, 1000 KISS -> 0.96 ETH - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 2000e18, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 2000e18, 0, pyth.update)); uint256 feesUserAfterFirstSwap = kresko.getAccountFeesSCDP(getAddr(0), address(kiss)); uint256 totalSwapFees = feesUserAfterFirstSwap - feesStart; totalSwapFees.eq(feePerSwapTotal, "fees-should-equal-total"); @@ -554,7 +552,7 @@ contract ComplexTest is Deploy { prank(getAddr(0)); _setETHPrice(price); kresko.setAssetKFactor(krETHAddr, 1.2e4); - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, swapAmount, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, swapAmount, 0, pyth.update)); } function _setETHPriceAndLiquidate(uint256 price) internal { @@ -563,7 +561,7 @@ contract ComplexTest is Deploy { if (debt < krETH.balanceOf(getAddr(0))) { usdc.mint(getAddr(0), 100_000e6); kresko.depositCollateral(getAddr(0), address(usdc), 100_000e6); - kresko.mintKreskoAsset(MintArgs(getAddr(0), krETHAddr, debt, getAddr(0)), updateData); + kresko.mintKreskoAsset(MintArgs(getAddr(0), krETHAddr, debt, getAddr(0)), pyth.update); } kresko.setAssetKFactor(krETHAddr, 1e4); _setETHPrice(price); @@ -576,7 +574,7 @@ contract ComplexTest is Deploy { if (amount < krETH.balanceOf(getAddr(0))) { usdc.mint(getAddr(0), 100_000e6); kresko.depositCollateral(getAddr(0), address(usdc), 100_000e6); - kresko.mintKreskoAsset(MintArgs(getAddr(0), krETHAddr, amount, getAddr(0)), updateData); + kresko.mintKreskoAsset(MintArgs(getAddr(0), krETHAddr, amount, getAddr(0)), pyth.update); } kresko.setAssetKFactor(krETHAddr, 1e4); _setETHPrice(price); @@ -623,13 +621,13 @@ contract ComplexTest is Deploy { krETH.approve(address(kresko), type(uint256).max); (uint256 tradeAmount, ) = kiss.vaultDeposit(address(usdc), mintAmount * count, trader); for (uint256 i = 0; i < count; i++) { - kresko.swapSCDP(SwapArgs(trader, address(kiss), krETHAddr, tradeAmount / count, 0, updateData)); - kresko.swapSCDP(SwapArgs(trader, krETHAddr, address(kiss), krETH.balanceOf(trader), 0, updateData)); + kresko.swapSCDP(SwapArgs(trader, address(kiss), krETHAddr, tradeAmount / count, 0, pyth.update)); + kresko.swapSCDP(SwapArgs(trader, krETHAddr, address(kiss), krETH.balanceOf(trader), 0, pyth.update)); } } function _cover(uint256 _coverAmount) internal returns (uint256 crAfter, uint256 debtValAfter) { - kresko.coverSCDP(address(kiss), _coverAmount, updateData); + kresko.coverSCDP(address(kiss), _coverAmount, pyth.update); return (kresko.getCollateralRatioSCDP(), kresko.getTotalDebtValueSCDP(true)); } @@ -637,7 +635,7 @@ contract ComplexTest is Deploy { uint256 _coverAmount, address _seizeAsset ) internal returns (uint256 crAfter, uint256 debtValAfter) { - kresko.coverWithIncentiveSCDP(address(kiss), _coverAmount, _seizeAsset, updateData); + kresko.coverWithIncentiveSCDP(address(kiss), _coverAmount, _seizeAsset, pyth.update); return (kresko.getCollateralRatioSCDP(), kresko.getTotalDebtValueSCDP(true)); } @@ -646,7 +644,7 @@ contract ComplexTest is Deploy { uint256 _repayAmount, address _seizeAsset ) internal returns (uint256 crAfter, uint256 debtValAfter, uint256 debtAmountAfter) { - kresko.liquidateSCDP(SCDPLiquidationArgs(_repayAsset, _repayAmount, _seizeAsset), updateData); + kresko.liquidateSCDP(SCDPLiquidationArgs(_repayAsset, _repayAmount, _seizeAsset), pyth.update); return (kresko.getCollateralRatioSCDP(), kresko.getDebtValueSCDP(_repayAsset, true), kresko.getDebtSCDP(_repayAsset)); } diff --git a/src/contracts/test/DeploymentFactory.t.sol b/src/contracts/test/DeploymentFactory.t.sol index 514fb710..6fe1b767 100644 --- a/src/contracts/test/DeploymentFactory.t.sol +++ b/src/contracts/test/DeploymentFactory.t.sol @@ -11,7 +11,7 @@ import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; import {stdStorage, StdStorage} from "forge-std/StdStorage.sol"; import {PLog} from "kresko-lib/utils/s/PLog.s.sol"; import {Conversions, Deploys, Proxies} from "libs/Utils.sol"; -import {LogicA, LogicB} from "mocks-misc/MockLogic.sol"; +import {LogicA, LogicB} from "mocks/MockLogic.sol"; import {DeploymentFactory, IDeploymentFactory, Deployment, TransparentUpgradeableProxy} from "factory/DeploymentFactory.sol"; import {KreskoAsset} from "kresko-asset/KreskoAsset.sol"; import {KreskoAssetAnchor} from "kresko-asset/KreskoAssetAnchor.sol"; diff --git a/src/contracts/test/ICDP.t.sol b/src/contracts/test/ICDP.t.sol index 1773abd2..8030b4be 100644 --- a/src/contracts/test/ICDP.t.sol +++ b/src/contracts/test/ICDP.t.sol @@ -9,7 +9,7 @@ import {PercentageMath} from "libs/PercentageMath.sol"; import {Asset} from "common/Types.sol"; import {PLog} from "kresko-lib/utils/s/PLog.s.sol"; import {Deploy} from "scripts/deploy/Deploy.s.sol"; -import {MockERC20} from "mocks/MockERC20.sol"; +import {MockERC20} from "mocks/Mocks.sol"; import {IKreskoAsset} from "kresko-asset/IKreskoAsset.sol"; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; import "scripts/deploy/JSON.s.sol" as JSON; @@ -97,7 +97,7 @@ contract ICDPTest is Tested, Deploy { kresko.depositCollateral(user0, address(usdc), depositAmount); kresko.getAccountCollateralAmount(user0, address(usdc)).eq(depositAmount); - kresko.mintKreskoAsset(MintArgs(user0, address(krJPY), mintAmount, user0), updateData); + kresko.mintKreskoAsset(MintArgs(user0, address(krJPY), mintAmount, user0), pyth.update); kresko.getAccountTotalCollateralValue(user0).eq(1000e8); kresko.getAccountTotalDebtValue(user0).eq(67.67e8); } @@ -112,11 +112,11 @@ contract ICDPTest is Tested, Deploy { kresko.depositCollateral(user0, address(usdc), depositAmount); kresko.getAccountCollateralAmount(user0, address(usdc)).eq(depositAmount); - kresko.mintKreskoAsset(MintArgs(user0, address(krJPY), mintAmount, user0), updateData); + kresko.mintKreskoAsset(MintArgs(user0, address(krJPY), mintAmount, user0), pyth.update); uint256 feeValue = kresko.getValue(address(krJPY), mintAmount.percentMul(krJPYConfig.closeFee)); - kresko.burnKreskoAsset(BurnArgs(user0, address(krJPY), mintAmount, 0, user0), updateData); + kresko.burnKreskoAsset(BurnArgs(user0, address(krJPY), mintAmount, 0, user0), pyth.update); kresko.getAccountTotalCollateralValue(user0).eq(1000e8 - feeValue); kresko.getAccountTotalDebtValue(user0).eq(0); @@ -132,10 +132,10 @@ contract ICDPTest is Tested, Deploy { kresko.depositCollateral(user0, address(usdc), depositAmount); kresko.getAccountCollateralAmount(user0, address(usdc)).eq(depositAmount); - kresko.mintKreskoAsset(MintArgs(user0, address(krJPY), mintAmount, user0), updateData); - kresko.burnKreskoAsset(BurnArgs(user0, address(krJPY), mintAmount, 0, user0), updateData); + kresko.mintKreskoAsset(MintArgs(user0, address(krJPY), mintAmount, user0), pyth.update); + kresko.burnKreskoAsset(BurnArgs(user0, address(krJPY), mintAmount, 0, user0), pyth.update); - kresko.withdrawCollateral(WithdrawArgs(user0, address(usdc), type(uint256).max, 0, user0), updateData); + kresko.withdrawCollateral(WithdrawArgs(user0, address(usdc), type(uint256).max, 0, user0), pyth.update); kresko.getAccountTotalCollateralValue(user0).eq(0); kresko.getAccountTotalDebtValue(user0).eq(0); @@ -156,7 +156,7 @@ contract ICDPTest is Tested, Deploy { bytes memory mintData = abi.encodeWithSelector( kresko.mintKreskoAsset.selector, MintArgs(user0, address(krJPY), mintAmount, user0), - updateData + pyth.update ); uint256 gasMint = gasleft(); (success, ) = address(kresko).call(mintData); @@ -166,7 +166,7 @@ contract ICDPTest is Tested, Deploy { bytes memory burnData = abi.encodeWithSelector( kresko.burnKreskoAsset.selector, BurnArgs(user0, address(krJPY), mintAmount, 0, user0), - updateData + pyth.update ); uint256 gasBurn = gasleft(); (success, ) = address(kresko).call(burnData); @@ -176,7 +176,7 @@ contract ICDPTest is Tested, Deploy { bytes memory withdrawData = abi.encodeWithSelector( kresko.withdrawCollateral.selector, WithdrawArgs(user0, address(usdc), 998e18, 0, user0), - updateData + pyth.update ); uint256 gasWithdraw = gasleft(); (success, ) = address(kresko).call(withdrawData); diff --git a/src/contracts/test/Meta.t.sol b/src/contracts/test/Meta.t.sol index edde1d12..3f4bebfd 100644 --- a/src/contracts/test/Meta.t.sol +++ b/src/contracts/test/Meta.t.sol @@ -4,8 +4,7 @@ pragma solidity ^0.8.0; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; import {Deploy} from "scripts/deploy/Deploy.s.sol"; -import {Log, Help} from "kresko-lib/utils/s/LibVm.s.sol"; -import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; +import {Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {Tested} from "kresko-lib/utils/s/Tested.t.sol"; import {IAccess} from "kresko-lib/vendor/IAccess.sol"; import {Role} from "common/Constants.sol"; @@ -28,9 +27,7 @@ contract InitializerTest { contract MetaTest is Tested, Deploy { using Log for *; - using Help for *; using Deployed for *; - using ShortAssert for *; address payable krETH; address admin; diff --git a/src/contracts/test/Multicall.t.sol b/src/contracts/test/Multicall.t.sol index 3342a8b7..87bfde9b 100644 --- a/src/contracts/test/Multicall.t.sol +++ b/src/contracts/test/Multicall.t.sol @@ -2,21 +2,19 @@ pragma solidity ^0.8.0; import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; -import {Help, Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Utils, Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {IKrMulticall} from "periphery/KrMulticall.sol"; import {Deploy} from "scripts/deploy/Deploy.s.sol"; import {KreskoAsset} from "kresko-asset/KreskoAsset.sol"; -import {MockOracle} from "mocks/MockOracle.sol"; -import {MockERC20} from "mocks/MockERC20.sol"; +import {MockOracle, MockERC20} from "mocks/Mocks.sol"; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; -import {SCDPLiquidationArgs, SwapArgs} from "common/Args.sol"; +import {SwapArgs} from "common/Args.sol"; import "scripts/deploy/JSON.s.sol" as JSON; // solhint-disable state-visibility, max-states-count, var-name-mixedcase, no-global-import, const-name-snakecase, no-empty-blocks, no-console contract MulticallTest is Deploy { using ShortAssert for *; - using Help for *; using Log for *; using Utils for *; uint256 constant ETH_PRICE = 2000; @@ -49,7 +47,7 @@ contract MulticallTest is Deploy { krETH.approve(address(kresko), type(uint256).max); _setETHPrice(ETH_PRICE); // 1000 KISS -> 0.48 ETH - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, pyth.update)); vault.setDepositFee(address(usdt), 10e2); vault.setWithdrawFee(address(usdt), 10e2); @@ -92,7 +90,7 @@ contract MulticallTest is Deploy { }) }); - IKrMulticall.Result[] memory results = multicall.execute(ops, updateData); + IKrMulticall.Result[] memory results = multicall.execute(ops, pyth.update); usdc.balanceOf(user).eq(0, "usdc-balance"); krJPY.balanceOf(user).eq(10000e18, "jpy-borrow-balance"); results[0].amountIn.eq(10_000e6, "usdc-deposit-amount"); @@ -104,7 +102,7 @@ contract MulticallTest is Deploy { function testNativeDeposit() public { address user = getAddr(100); uint256 amount = 5 ether; - vm.deal(user, amount * 2 + updateFee); + vm.deal(user, amount * 2 + pyth.cost); prank(user); IKrMulticall.Operation[] memory ops = new IKrMulticall.Operation[](1); @@ -123,7 +121,7 @@ contract MulticallTest is Deploy { }) }); - IKrMulticall.Result[] memory results = multicall.execute{value: 5 ether + updateFee}(ops, updateData); + IKrMulticall.Result[] memory results = multicall.execute{value: 5 ether + pyth.cost}(ops, pyth.update); results[0].amountIn.eq(5 ether, "native-deposit-amount"); results[0].tokenIn.eq(address(weth), "native-deposit-addr"); uint256 depositsAfter = kresko.getAccountCollateralAmount(user, address(weth)); @@ -156,13 +154,13 @@ contract MulticallTest is Deploy { }); vm.expectRevert(); - multicall.execute{value: 5 ether}(ops, updateData); + multicall.execute{value: 5 ether}(ops, pyth.update); } function testNativeDepositWithdraw() public { address user = getAddr(100); uint256 amount = 5 ether; - vm.deal(user, amount * 2 + updateFee); + vm.deal(user, amount * 2 + pyth.cost); prank(user); IKrMulticall.Operation[] memory ops = new IKrMulticall.Operation[](2); @@ -195,7 +193,7 @@ contract MulticallTest is Deploy { }) }); - IKrMulticall.Result[] memory results = multicall.execute{value: amount + updateFee}(ops, updateData); + IKrMulticall.Result[] memory results = multicall.execute{value: amount + pyth.cost}(ops, pyth.update); results[0].amountIn.eq(amount, "native-deposit-amount"); results[0].tokenIn.eq(address(weth), "native-deposit-addr"); results[1].amountOut.eq(amount, "native-deposit-amount"); @@ -257,7 +255,7 @@ contract MulticallTest is Deploy { }) }); - IKrMulticall.Result[] memory results = multicall.execute(ops, updateData); + IKrMulticall.Result[] memory results = multicall.execute(ops, pyth.update); usdc.balanceOf(user).eq(0, "usdc-balance"); krJPY.balanceOf(user).eq(0, "jpy-borrow-balance"); results[0].amountIn.eq(10_000e6, "usdc-deposit-amount"); @@ -304,7 +302,7 @@ contract MulticallTest is Deploy { }) }); - IKrMulticall.Result[] memory results = multicall.execute(ops, updateData); + IKrMulticall.Result[] memory results = multicall.execute(ops, pyth.update); usdc.balanceOf(user).eq(0, "usdc-balance"); kresko.getAccountDepositSCDP(user, address(kiss)).eq(9998e18, "kiss-deposit-amount"); kiss.balanceOf(user).eq(0, "jpy-borrow-balance"); @@ -350,7 +348,7 @@ contract MulticallTest is Deploy { }) }); - multicall.execute(opsDeposit, updateData); + multicall.execute(opsDeposit, pyth.update); IKrMulticall.Operation[] memory opsWithdraw = new IKrMulticall.Operation[](2); opsWithdraw[0] = IKrMulticall.Operation({ @@ -382,7 +380,7 @@ contract MulticallTest is Deploy { }) }); - IKrMulticall.Result[] memory results = multicall.execute(opsWithdraw, updateData); + IKrMulticall.Result[] memory results = multicall.execute(opsWithdraw, pyth.update); usdc.balanceOf(user).eq(9996000400, "usdc-balance"); kresko.getAccountDepositSCDP(user, address(kiss)).eq(0, "kiss-deposit-amount"); @@ -435,7 +433,7 @@ contract MulticallTest is Deploy { index: 0 }) }); - IKrMulticall.Result[] memory results = multicall.execute(opsShort, updateData); + IKrMulticall.Result[] memory results = multicall.execute(opsShort, pyth.update); krJPY.balanceOf(address(multicall)).eq(0, "jpy-balance-multicall-after"); kiss.balanceOf(address(multicall)).eq(0, "kiss-balance-multicall-after"); @@ -492,7 +490,7 @@ contract MulticallTest is Deploy { index: 0 }) }); - multicall.execute(opsShort, updateData); + multicall.execute(opsShort, pyth.update); IKrMulticall.Operation[] memory opsShortClose = new IKrMulticall.Operation[](2); @@ -524,7 +522,7 @@ contract MulticallTest is Deploy { index: 0 }) }); - IKrMulticall.Result[] memory results = multicall.execute(opsShortClose, updateData); + IKrMulticall.Result[] memory results = multicall.execute(opsShortClose, pyth.update); usdc.balanceOf(user).eq(0, "usdc-balance"); kresko.getAccountCollateralAmount(user, address(usdc)).eq(9997520000, "usdc-deposit-amount"); @@ -676,7 +674,7 @@ contract MulticallTest is Deploy { prank(getAddr(0)); krJPY.approve(address(multicall), type(uint256).max); - IKrMulticall.Result[] memory results = multicall.execute(ops, updateData); + IKrMulticall.Result[] memory results = multicall.execute(ops, pyth.update); for (uint256 i; i < results.length; i++) { results[i].tokenIn.clg("tokenIn"); results[i].amountIn.clg("amountIn"); diff --git a/src/contracts/test/Pyth.t.sol b/src/contracts/test/Pyth.t.sol index 609ea2ed..69c1b5de 100644 --- a/src/contracts/test/Pyth.t.sol +++ b/src/contracts/test/Pyth.t.sol @@ -2,8 +2,6 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; -import {Help} from "kresko-lib/utils/s/LibVm.s.sol"; import {PLog} from "kresko-lib/utils/s/PLog.s.sol"; import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; import {Tested} from "kresko-lib/utils/s/Tested.t.sol"; @@ -15,18 +13,15 @@ contract PythTest is Tested { bytes32 constant PYTH_ETH = 0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace; using PLog for *; - using Help for *; - using Deployed for *; using ShortAssert for *; IPyth mockPyth; - IPyth pyth = IPyth(0x4374e5a8b9C22271E9EB878A2AA31DE97DF15DAF); uint8 oracleDec = 8; bytes32[] ids; Price[] prices; - function setUp() public users(address(111), address(222), address(333)) { + function setUp() public { useMnemonic("MNEMONIC_DEVNET"); prices.push(Price({price: 2000e8, conf: 0, expo: -8, publishTime: 0})); diff --git a/src/contracts/test/SCDP.t.sol b/src/contracts/test/SCDP.t.sol index 324bd5be..42316ce9 100644 --- a/src/contracts/test/SCDP.t.sol +++ b/src/contracts/test/SCDP.t.sol @@ -4,15 +4,14 @@ pragma solidity ^0.8.0; // solhint-disable no-console, state-visibility, var-name-mixedcase, avoid-low-level-calls, max-states-count import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; -import {Log, Utils, Help} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log, Utils} from "kresko-lib/utils/s/LibVm.s.sol"; import {Tested} from "kresko-lib/utils/s/Tested.t.sol"; import {Asset} from "common/Types.sol"; import {Deploy} from "scripts/deploy/Deploy.s.sol"; -import {MockERC20} from "mocks/MockERC20.sol"; +import {MockERC20, MockOracle} from "mocks/Mocks.sol"; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; import {IKreskoAsset} from "kresko-asset/IKreskoAsset.sol"; import "scripts/deploy/JSON.s.sol" as JSON; -import {MockOracle} from "mocks/MockOracle.sol"; import {Enums} from "common/Constants.sol"; import {SCDPLiquidationArgs, SCDPWithdrawArgs, SwapArgs, SCDPRepayArgs} from "common/Args.sol"; import {Errors} from "common/Errors.sol"; @@ -20,7 +19,6 @@ import {Errors} from "common/Errors.sol"; contract SCDPTest is Tested, Deploy { using ShortAssert for *; using Log for *; - using Help for *; using Utils for *; using Deployed for *; @@ -72,10 +70,10 @@ contract SCDPTest is Tested, Deploy { usdc.mint(user0, 1000e6); prank(getAddr(0)); - kiss.transfer(user0, 2000e18); - council = kresko.getRoleMember(keccak256("kresko.roles.minter.safety.council"), 0); assertNotEq(council, address(0)); + + kiss.transfer(user0, 2000e18); } modifier withDeposits() { @@ -318,7 +316,7 @@ contract SCDPTest is Tested, Deploy { _poolDeposit(deployer, address(kiss), 50000e18); (, uint256 feesDistributed, ) = kresko.previewSwapSCDP(address(kiss), address(krETH), 1000e18); - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, 1000e18, 0, pyth.update)); _liquidate(75, 1000e18, 0.01e18); uint256 kissBalBefore = kiss.balanceOf(deployer); @@ -340,7 +338,7 @@ contract SCDPTest is Tested, Deploy { uint256 fees = kresko.getAccountFeesSCDP(deployer, address(kiss)); fees.gt(0, "fees"); uint256 kissBalBefore = kiss.balanceOf(deployer); - kresko.emergencyWithdrawSCDP(SCDPWithdrawArgs(deployer, address(kiss), 1000e18, deployer), updateData); + kresko.emergencyWithdrawSCDP(SCDPWithdrawArgs(deployer, address(kiss), 1000e18, deployer), pyth.update); (kiss.balanceOf(deployer) - kissBalBefore).eq(1000e18, "received-withdraw"); kresko.getAccountFeesSCDP(deployer, address(kiss)).eq(0, "fees-after"); @@ -360,7 +358,7 @@ contract SCDPTest is Tested, Deploy { bytes memory withdrawData = abi.encodeWithSelector( kresko.withdrawSCDP.selector, SCDPWithdrawArgs(user0, address(kiss), amount, user0), - updateData + pyth.update ); uint256 gasWithdraw = gasleft(); (success, ) = address(kresko).call(withdrawData); @@ -372,7 +370,7 @@ contract SCDPTest is Tested, Deploy { bytes memory swapData = abi.encodeWithSelector( kresko.swapSCDP.selector, - SwapArgs(user0, address(kiss), address(krETH), amount, 0, updateData) + SwapArgs(user0, address(kiss), address(krETH), amount, 0, pyth.update) ); uint256 gasSwap = gasleft(); (success, ) = address(kresko).call(swapData); @@ -382,7 +380,7 @@ contract SCDPTest is Tested, Deploy { bytes memory swapData2 = abi.encodeWithSelector( kresko.swapSCDP.selector, - SwapArgs(user0, address(krETH), address(kiss), krETH.balanceOf(user0), 0, updateData) + SwapArgs(user0, address(krETH), address(kiss), krETH.balanceOf(user0), 0, pyth.update) ); uint256 gasSwap2 = gasleft(); @@ -393,7 +391,7 @@ contract SCDPTest is Tested, Deploy { bytes memory swapData3 = abi.encodeWithSelector( kresko.swapSCDP.selector, - SwapArgs(user0, address(kiss), address(krETH), kiss.balanceOf(user0), 0, updateData) + SwapArgs(user0, address(kiss), address(krETH), kiss.balanceOf(user0), 0, pyth.update) ); uint256 gasSwap3 = gasleft(); (success, ) = address(kresko).call(swapData3); @@ -436,7 +434,7 @@ contract SCDPTest is Tested, Deploy { Enums.Action.SCDPWithdraw ) ); - kresko.withdrawSCDP(SCDPWithdrawArgs(user0, address(usdc), 1000e6, user0), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(user0, address(usdc), 1000e6, user0), pyth.update); // Unpause SCDPWithdraw for USDC _toggleActionPaused(address(usdc), Enums.Action.SCDPWithdraw, false); @@ -464,10 +462,10 @@ contract SCDPTest is Tested, Deploy { Enums.Action.SCDPWithdraw ) ); - kresko.emergencyWithdrawSCDP(SCDPWithdrawArgs(deployer, address(kiss), 1000e18, deployer), updateData); + kresko.emergencyWithdrawSCDP(SCDPWithdrawArgs(deployer, address(kiss), 1000e18, deployer), pyth.update); _toggleActionPaused(address(kiss), Enums.Action.SCDPWithdraw, false); - kresko.emergencyWithdrawSCDP(SCDPWithdrawArgs(deployer, address(kiss), 1000e18, deployer), updateData); + kresko.emergencyWithdrawSCDP(SCDPWithdrawArgs(deployer, address(kiss), 1000e18, deployer), pyth.update); (kiss.balanceOf(deployer) - kissBalBefore).eq(1000e18, "received-withdraw"); kresko.getAccountFeesSCDP(deployer, address(kiss)).eq(0, "fees-after"); } @@ -523,7 +521,7 @@ contract SCDPTest is Tested, Deploy { assertGt(krETH.balanceOf(user0), 0); - SCDPRepayArgs memory repay = SCDPRepayArgs(address(krETH), krETH.balanceOf(user0), address(kiss), updateData); + SCDPRepayArgs memory repay = SCDPRepayArgs(address(krETH), krETH.balanceOf(user0), address(kiss), pyth.update); vm.expectRevert( abi.encodeWithSelector( Errors.ASSET_PAUSED_FOR_THIS_ACTION.selector, @@ -535,7 +533,7 @@ contract SCDPTest is Tested, Deploy { _toggleActionPaused(address(krETH), Enums.Action.SCDPRepay, false); - repay = SCDPRepayArgs(address(krETH), krETH.balanceOf(user0), address(kiss), updateData); + repay = SCDPRepayArgs(address(krETH), krETH.balanceOf(user0), address(kiss), pyth.update); prank(user0); kresko.repaySCDP(repay); } @@ -584,7 +582,7 @@ contract SCDPTest is Tested, Deploy { Enums.Action.SCDPCover ) ); - kresko.coverSCDP(address(krETH), 1000e18, updateData); + kresko.coverSCDP(address(krETH), 1000e18, pyth.update); } function test_coverWithIncentiveSCDP_Paused() public { @@ -597,7 +595,7 @@ contract SCDPTest is Tested, Deploy { Enums.Action.SCDPCover ) ); - kresko.coverWithIncentiveSCDP(address(kiss), 1000e18, address(krETH), updateData); + kresko.coverWithIncentiveSCDP(address(kiss), 1000e18, address(krETH), pyth.update); } /* -------------------------------------------------------------------------- */ @@ -619,14 +617,14 @@ contract SCDPTest is Tested, Deploy { for (uint256 i; i < times; i++) { _setETHPrice(uint256(2000e8)); (uint256 amountOut, , ) = kresko.previewSwapSCDP(address(kiss), address(krETH), swapAmount); - kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, swapAmount, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), address(kiss), krETHAddr, swapAmount, 0, pyth.update)); _setETHPrice(uint256(90000e8)); if (i > 40) { liquidateAmount = liquidateAmount.pmul(0.50e4); } _liquidate(krETHAddr, liquidateAmount.pmul(1e4 - (100 * i)), address(kiss)); _setETHPrice(uint256(2000e8)); - kresko.swapSCDP(SwapArgs(getAddr(0), krETHAddr, address(kiss), amountOut, 0, updateData)); + kresko.swapSCDP(SwapArgs(getAddr(0), krETHAddr, address(kiss), amountOut, 0, pyth.update)); } } @@ -640,11 +638,11 @@ contract SCDPTest is Tested, Deploy { } function _poolWithdraw(address user, address asset, uint256 amount) internal repranked(user) { - kresko.withdrawSCDP(SCDPWithdrawArgs(user, asset, amount, user), updateData); + kresko.withdrawSCDP(SCDPWithdrawArgs(user, asset, amount, user), pyth.update); } function _swap(address user, address assetIn, uint256 amount, address assetOut) internal repranked(user) { - kresko.swapSCDP(SwapArgs(user, assetIn, assetOut, amount, 0, updateData)); + kresko.swapSCDP(SwapArgs(user, assetIn, assetOut, amount, 0, pyth.update)); } function _liquidate( @@ -652,7 +650,7 @@ contract SCDPTest is Tested, Deploy { uint256 _repayAmount, address _seizeAsset ) internal repranked(liquidator) returns (uint256 crAfter, uint256 debtValAfter, uint256 debtAmountAfter) { - kresko.liquidateSCDP(SCDPLiquidationArgs(_repayAsset, _repayAmount, _seizeAsset), updateData); + kresko.liquidateSCDP(SCDPLiquidationArgs(_repayAsset, _repayAmount, _seizeAsset), pyth.update); return (kresko.getCollateralRatioSCDP(), kresko.getDebtValueSCDP(_repayAsset, true), kresko.getDebtSCDP(_repayAsset)); } diff --git a/src/contracts/test/Vault.t.sol b/src/contracts/test/Vault.t.sol index e64cabe1..6387a1d8 100644 --- a/src/contracts/test/Vault.t.sol +++ b/src/contracts/test/Vault.t.sol @@ -4,9 +4,8 @@ pragma solidity ^0.8.0; import {IAggregatorV3} from "kresko-lib/vendor/IAggregatorV3.sol"; import {IERC20} from "kresko-lib/token/IERC20.sol"; import {Test} from "forge-std/Test.sol"; -import {MockOracle} from "mocks/MockOracle.sol"; -import {MockERC20, USDC, USDT, DAI} from "mocks/MockERC20.sol"; -import {MockSequencerUptimeFeed} from "mocks/MockSequencerUptimeFeed.sol"; +import {MockOracle, MockSequencerUptimeFeed} from "mocks/Mocks.sol"; +import {MockERC20, USDC, USDT, DAI} from "kresko-lib/mocks/MockERC20.sol"; import {VaultAsset} from "vault/VTypes.sol"; import {Vault} from "vault/Vault.sol"; diff --git a/src/contracts/test/forked/GateTest.t.sol b/src/contracts/test/forked/GateTest.t.sol deleted file mode 100644 index 80c75a0c..00000000 --- a/src/contracts/test/forked/GateTest.t.sol +++ /dev/null @@ -1,232 +0,0 @@ -// solhint-disable state-visibility, max-states-count, no-empty-blocks, no-console -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; -import {Log, Help} from "kresko-lib/utils/s/LibVm.s.sol"; -import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; -import {Tested} from "kresko-lib/utils/s/Tested.t.sol"; -import {IKresko} from "periphery/IKresko.sol"; -import {IWETH9} from "kresko-lib/token/IWETH9.sol"; -import {IAccess} from "kresko-lib/vendor/IAccess.sol"; -import {IGatingManager} from "periphery/IGatingManager.sol"; -import {GatingManager} from "periphery/GatingManager.sol"; -import {IERC1155} from "common/interfaces/IERC1155.sol"; -import {Errors} from "common/Errors.sol"; - -contract GateTest is Tested { - using Log for *; - using Help for *; - using Deployed for *; - using ShortAssert for *; - - IWETH9 nativew = IWETH9(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1); - IKresko kresko = IKresko(0x0000000000177abD99485DCaea3eFaa91db3fe72); - IGatingManager manager = IGatingManager(0x00000000685B935476005E6A7ed5E1Bf3C000B12); - - IERC1155 kreskian = IERC1155(0xAbDb949a18d27367118573A217E5353EDe5A0f1E); - IERC1155 questForKresk = IERC1155(0x1C04925779805f2dF7BbD0433ABE92Ea74829bF6); - - GatingManager newManager; - - address USDC = 0xaf88d065e77c8cC2239327C5EDb3A432268e5831; - address USDCe = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8; - address krETH = 0x24dDC92AA342e92f26b4A676568D04d2E3Ea0abc; - address KISS = 0x6A1D6D2f4aF6915e6bBa8F2db46F442d18dB5C9b; - - address safe = 0x266489Bde85ff0dfe1ebF9f0a7e6Fed3a973cEc3; - address deployer = 0x5a6B3E907b83DE2AbD9010509429683CF5ad5984; - address nftMultisig = 0x389297F0d8C489954D65e04ff0690FC54E57Dad6; - - address acc1 = 0xf16803A6602D612b2BE9c845B2679F3A7D61ea6a; - address acc2 = 0x99999A0B66AF30f6FEf832938a5038644a72180a; - address acc3 = 0x7BF50060a0C3EE0ba4073CF33E39a18304A7586E; - - address userValidPhaseThree = address(1152191); - address userValidPhaseTwo = address(225552); - - address userValidPhaseOne = address(2241242); - address userValidPhaseOne2 = address(661246); - address userValidPhaseOne3 = address(7774214); - - address userNotValid = address(332414213); - address userNotValid2 = address(4444921); - address userNotValid3 = address(1294219); - - function setUp() public { - vm.createSelectFork("arbitrum", 191129102); - - // deploy fixed manager - newManager = new GatingManager(safe, address(kreskian), address(questForKresk), 1); - - // update manager in the protocol storage through the safe - prank(safe); - kresko.setGatingManager(address(newManager)); - newManager.whitelist(acc3, true); - - // mint mainnet NFTs from NFT multisig - prank(nftMultisig); - IAccess(address(kreskian)).grantRole(0x43e8266d03af0985c5e796e22decb8dc2151c5e8a7f68cdc0d56474847d60a7a, nftMultisig); - IAccess(address(questForKresk)).grantRole( - 0x43e8266d03af0985c5e796e22decb8dc2151c5e8a7f68cdc0d56474847d60a7a, - nftMultisig - ); - - // mint phase 3 NFTs - kreskian.mint(userValidPhaseThree, 0, 1); - kreskian.mint(userValidPhaseTwo, 0, 1); - kreskian.mint(userValidPhaseOne, 0, 1); - kreskian.mint(userValidPhaseOne2, 0, 1); - kreskian.mint(userValidPhaseOne3, 0, 1); - - // mint phase 2 NFTs - questForKresk.mint(userValidPhaseTwo, 0, 1); - questForKresk.mint(userValidPhaseOne, 0, 1); - questForKresk.mint(userValidPhaseOne2, 0, 1); - questForKresk.mint(userValidPhaseOne3, 0, 1); - - // mint phase 1 NFTs - questForKresk.mint(userValidPhaseOne, 1, 1); - questForKresk.mint(userValidPhaseOne2, 1, 7); - questForKresk.mint(userValidPhaseOne3, 1, 4); - - questForKresk.mint(userNotValid2, 1, 1); - // This user will be able to enter Phase2 after latest Gating Manager update - questForKresk.mint(userNotValid3, 0, 1); - } - - function testPhase3() external pranked(safe) { - newManager.setPhase(3); - newManager.phase().eq(3); - - vm.expectRevert(Errors.MISSING_PHASE_3_NFT.selector); - newManager.check(userNotValid); - newManager.isEligible(userNotValid).eq(false, "userNotValid"); - - vm.expectRevert(Errors.MISSING_PHASE_3_NFT.selector); - newManager.check(userNotValid2); - newManager.isEligible(userNotValid2).eq(false, "userNotValid2"); - - vm.expectRevert(Errors.MISSING_PHASE_3_NFT.selector); - newManager.check(userNotValid3); - newManager.isEligible(userNotValid3).eq(false, "userNotValid3"); - - newManager.isEligible(userValidPhaseThree).eq(true); - newManager.isEligible(userValidPhaseTwo).eq(true); - newManager.isEligible(userValidPhaseOne).eq(true); - newManager.isEligible(userValidPhaseOne2).eq(true); - newManager.isEligible(userValidPhaseOne3).eq(true); - newManager.check(userValidPhaseThree); - newManager.check(userValidPhaseTwo); - newManager.check(userValidPhaseOne); - newManager.check(userValidPhaseOne2); - newManager.check(userValidPhaseOne3); - - newManager.isEligible(acc1).eq(true); - newManager.isEligible(acc2).eq(true); - newManager.isEligible(acc3).eq(true); - newManager.check(acc1); - newManager.check(acc2); - newManager.check(acc3); - } - - function testPhase2() external pranked(safe) { - newManager.setPhase(2); - newManager.phase().eq(2); - - newManager.isEligible(userNotValid).eq(false, "userNotValid"); - newManager.isEligible(userNotValid2).eq(false, "userNotValid2"); - newManager.isEligible(userValidPhaseThree).eq(false, "userValidPhaseThree"); - - vm.expectRevert(Errors.MISSING_PHASE_2_NFT.selector); - newManager.check(userNotValid); - - vm.expectRevert(Errors.MISSING_PHASE_2_NFT.selector); - newManager.check(userNotValid2); - - vm.expectRevert(Errors.MISSING_PHASE_2_NFT.selector); - newManager.check(userValidPhaseThree); - - newManager.isEligible(userValidPhaseTwo).eq(true, "userValidPhaseTwo"); - newManager.isEligible(userValidPhaseOne).eq(true, "userValidPhaseOne"); - newManager.isEligible(userValidPhaseOne2).eq(true, "userValidPhaseOne2"); - newManager.isEligible(userValidPhaseOne3).eq(true, "userValidPhaseOne3"); - newManager.isEligible(userNotValid3).eq(true, "userNotValid3"); - newManager.check(userValidPhaseTwo); - newManager.check(userValidPhaseOne); - newManager.check(userValidPhaseOne2); - newManager.check(userValidPhaseOne3); - newManager.check(userNotValid3); - - newManager.isEligible(acc1).eq(true, "acc1"); - newManager.isEligible(acc2).eq(true, "acc2"); - newManager.isEligible(acc3).eq(true, "acc3"); - newManager.check(acc1); - newManager.check(acc2); - newManager.check(acc3); - } - - function testPhase1() external pranked(safe) { - newManager.phase().eq(1); - newManager.isEligible(userNotValid).eq(false, "userNotValid"); - newManager.isEligible(userNotValid2).eq(false, "userNotValid2"); - newManager.isEligible(userNotValid3).eq(false, "userNotValid3"); - newManager.isEligible(userValidPhaseThree).eq(false, "userValidPhaseThree"); - newManager.isEligible(userValidPhaseTwo).eq(false, "userValidPhaseTwo"); - - vm.expectRevert(Errors.MISSING_PHASE_1_NFT.selector); - newManager.check(userNotValid); - - vm.expectRevert(Errors.MISSING_PHASE_1_NFT.selector); - newManager.check(userNotValid2); - - vm.expectRevert(Errors.MISSING_PHASE_1_NFT.selector); - newManager.check(userNotValid3); - - vm.expectRevert(Errors.MISSING_PHASE_1_NFT.selector); - newManager.check(userValidPhaseThree); - - vm.expectRevert(Errors.MISSING_PHASE_1_NFT.selector); - newManager.check(userValidPhaseTwo); - - newManager.isEligible(userValidPhaseOne).eq(true, "userValidPhaseOne"); - newManager.isEligible(userValidPhaseOne2).eq(true, "userValidPhaseOne2"); - newManager.isEligible(userValidPhaseOne3).eq(true, "userValidPhaseOne3"); - newManager.check(userValidPhaseOne); - newManager.check(userValidPhaseOne2); - newManager.check(userValidPhaseOne3); - - newManager.isEligible(acc1).eq(true, "acc1"); - newManager.isEligible(acc2).eq(true, "acc2"); - newManager.isEligible(acc3).eq(true, "acc3"); - newManager.check(acc1); - newManager.check(acc2); - newManager.check(acc3); - } - - function testPhase0() external pranked(safe) { - newManager.setPhase(0); - newManager.phase().eq(0); - - newManager.isEligible(userNotValid).eq(true); - newManager.isEligible(userNotValid2).eq(true); - newManager.isEligible(userNotValid3).eq(true); - newManager.check(userNotValid); - newManager.check(userNotValid2); - newManager.check(userNotValid3); - - newManager.isEligible(userValidPhaseThree).eq(true); - newManager.isEligible(userValidPhaseTwo).eq(true); - newManager.isEligible(userValidPhaseOne).eq(true); - newManager.check(userValidPhaseOne); - newManager.check(userValidPhaseOne2); - newManager.check(userValidPhaseOne3); - - newManager.isEligible(acc1).eq(true, "acc1"); - newManager.isEligible(acc2).eq(true, "acc2"); - newManager.isEligible(acc3).eq(true, "acc3"); - newManager.check(acc1); - newManager.check(acc2); - newManager.check(acc3); - } -} diff --git a/src/contracts/test/forked/MarketStatusTest.t.sol b/src/contracts/test/forked/MarketStatusTest.t.sol index d05d68e2..9322aa52 100644 --- a/src/contracts/test/forked/MarketStatusTest.t.sol +++ b/src/contracts/test/forked/MarketStatusTest.t.sol @@ -3,13 +3,10 @@ pragma solidity ^0.8.0; import {Deployed} from "scripts/deploy/libs/Deployed.s.sol"; -import {Log, Help} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; import {Tested} from "kresko-lib/utils/s/Tested.t.sol"; import {IKresko} from "periphery/IKresko.sol"; -import {CommonConfigFacet} from "common/facets/CommonConfigFacet.sol"; -import {CommonStateFacet} from "common/facets/CommonStateFacet.sol"; -import {AssetStateFacet} from "common/facets/AssetStateFacet.sol"; import {IData} from "kresko-lib/core/types/Views.sol"; import {IMarketStatus} from "common/interfaces/IMarketStatus.sol"; import {ArbDeployAddr} from "kresko-lib/info/ArbDeployAddr.sol"; @@ -17,7 +14,6 @@ import {IData} from "kresko-lib/core/types/Views.sol"; contract MarketStatusTest is Tested, ArbDeployAddr { using Log for *; - using Help for *; using Deployed for *; using ShortAssert for *; diff --git a/src/contracts/test/forked/MulticallUpdate.t.sol b/src/contracts/test/forked/MulticallUpdate.t.sol index fc0622ab..f8a7069b 100644 --- a/src/contracts/test/forked/MulticallUpdate.t.sol +++ b/src/contracts/test/forked/MulticallUpdate.t.sol @@ -3,7 +3,7 @@ pragma solidity ^0.8.0; import {ArbScript} from "scripts/utils/ArbScript.s.sol"; import {Tested} from "kresko-lib/utils/s/Tested.t.sol"; -import {Help, Log} from "kresko-lib/utils/s/LibVm.s.sol"; +import {Log} from "kresko-lib/utils/s/LibVm.s.sol"; import {ShortAssert} from "kresko-lib/utils/s/ShortAssert.t.sol"; import {IKrMulticall, KrMulticall} from "periphery/KrMulticall.sol"; import {Role} from "common/Constants.sol"; @@ -12,11 +12,12 @@ import {Role} from "common/Constants.sol"; contract MulticallUpdate is Tested, ArbScript { using Log for *; - using Help for *; using ShortAssert for *; function setUp() public { - ArbScript.initialize("MNEMONIC_DEPLOY"); + ArbScript.initialize(231869463); + useMnemonic("MNEMONIC_DEPLOY"); + sender = vm.createWallet("sender").addr; deal(sender, 100 ether); deal(usdcAddr, sender, 100e6); diff --git a/src/deploy/local/02-add-facets.ts b/src/deploy/local/02-add-facets.ts index 77f2d3c9..171066ff 100644 --- a/src/deploy/local/02-add-facets.ts +++ b/src/deploy/local/02-add-facets.ts @@ -24,15 +24,7 @@ const deploy: DeployFunction = async function (hre) { }) await hre.deploy('MockSequencerUptimeFeed') - const [GatingManager] = await hre.deploy('GatingManager', { - args: [ - hre.users.deployer.address, - '0xAbDb949a18d27367118573A217E5353EDe5A0f1E', - '0x1C04925779805f2dF7BbD0433ABE92Ea74829bF6', - 0, - ], - }) - const commonInit = (await getCommonInitializer(hre, GatingManager.address)).args + const commonInit = (await getCommonInitializer(hre)).args if (commonInit.council === zeroAddress) throw new Error('Council address not set') await addFacets({ names: commonFacets, diff --git a/src/test/diamond/03-protocol.ts b/src/test/diamond/03-protocol.ts index eb8b0ee0..2264217c 100644 --- a/src/test/diamond/03-protocol.ts +++ b/src/test/diamond/03-protocol.ts @@ -35,8 +35,7 @@ describe('Diamond', () => { }) it('initialized correct state', async function () { expect(await hre.Diamond.getStorageVersion()).to.equal(3) - const GatingManager = await hre.deployments.get('GatingManager') - const { args } = await getCommonInitializer(hre, GatingManager.address) + const { args } = await getCommonInitializer(hre) const { args: minterArgs } = await getMinterInitializer(hre) const { args: scdpArgs } = await getSCDPInitializer(hre) diff --git a/src/test/minter/06-gating.ts b/src/test/minter/06-gating.ts deleted file mode 100644 index c3c600f9..00000000 --- a/src/test/minter/06-gating.ts +++ /dev/null @@ -1,148 +0,0 @@ -import { MockERC1155 } from '@/types/typechain' -import { expect } from '@test/chai' -import { type DefaultFixture, defaultFixture } from '@utils/test/fixtures' -import { toBig } from '@utils/values' - -describe('Gating', () => { - let f: DefaultFixture - let nft: MockERC1155 - let nft2: MockERC1155 - - beforeEach(async function () { - f = await defaultFixture() - // Set Gating phase to 3 - ;[nft] = await hre.deploy('MockERC1155', { - args: ['MockERC1155_1', 'MockERC1155_1', 'https://mock.com/{id}.json', 'https://mock.com/contract.json'], - deploymentName: 'MockERC1155_1', - from: hre.users.deployer.address, - }) - ;[nft2] = await hre.deploy('MockERC1155', { - args: ['MockERC1155_2', 'MockERC1155_2', 'https://mock2.com/{id}.json', 'https://mock2.com/contract2.json'], - deploymentName: 'MockERC1155_2', - from: hre.users.deployer.address, - }) - ;[this.GatingManager] = await hre.deploy('GatingManager', { - args: [hre.users.deployer.address, nft.address, nft2.address, 1], - from: hre.users.deployer.address, - }) - await hre.Diamond.setGatingManager(this.GatingManager.address) - - // setup collateral for userOne and userTwo - this.initialBalance = toBig(100000) - - await f.Collateral.setBalance(hre.users.userOne, this.initialBalance, hre.Diamond.address) - await f.Collateral.setBalance(hre.users.userTwo, this.initialBalance, hre.Diamond.address) - - this.depositArgsOne = { - user: hre.users.userOne, - asset: f.Collateral, - amount: toBig(10000), - } - this.depositArgsTwo = { - user: hre.users.userTwo, - asset: f.Collateral, - amount: toBig(10000), - } - }) - - it('should not allow users to access phase 1 without nfts', async function () { - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).to.be.reverted - - await nft['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - await nft2['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).to.be.reverted - }) - - it('should allow users to access in phase 1', async function () { - await nft['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - await nft2['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - await nft2['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 3, 1) - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).not.to.be.reverted - }) - it('should not allow users to access phase 2 without nfts', async function () { - await this.GatingManager.setPhase(2) - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).to.be.reverted - - await nft['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).to.be.reverted - }) - - it('should allow users to access in phase 2', async function () { - await this.GatingManager.setPhase(2) - await nft['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - await nft2['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).not.to.be.reverted - }) - it('should not allow users to access phase 3 without nfts', async function () { - await this.GatingManager.setPhase(3) - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).to.be.reverted - }) - - it('should allow users to access in phase 3', async function () { - await this.GatingManager.setPhase(3) - await nft['mint(address,uint256,uint256)'](this.depositArgsOne.user.address, 0, 1) - await expect( - hre.Diamond.connect(this.depositArgsOne.user).depositCollateral( - this.depositArgsOne.user.address, - f.Collateral.address, - this.depositArgsOne.amount, - ), - ).not.to.be.reverted - }) - - it('After all the phases anyone should be able to deposit collateral', async function () { - await this.GatingManager.setPhase(0) - - // Anyone should be able to deposit collateral - await expect( - hre.Diamond.connect(this.depositArgsTwo.user).depositCollateral( - this.depositArgsTwo.user.address, - f.Collateral.address, - this.depositArgsTwo.amount, - ), - ).not.to.be.reverted - }) -}) diff --git a/src/types/index.ts b/src/types/index.ts index 2abec738..f68aa4c0 100644 --- a/src/types/index.ts +++ b/src/types/index.ts @@ -1,29 +1,29 @@ -import type { AllTokenSymbols } from '@config/hardhat/deploy'; -import type { AssetConfigExtended } from '@config/hardhat/deploy/arbitrumSepolia'; -import type { BigNumber, Overrides } from 'ethers'; -import type { Address } from 'hardhat-deploy/types'; -import type * as Contracts from './typechain'; +import type { AllTokenSymbols } from '@config/hardhat/deploy' +import type { AssetConfigExtended } from '@config/hardhat/deploy/arbitrumSepolia' +import type { BigNumber, Overrides } from 'ethers' +import type { Address } from 'hardhat-deploy/types' +import type * as Contracts from './typechain' import type { AssetStruct, CommonInitArgsStruct, FeedConfigurationStruct, MinterInitArgsStruct, SCDPInitArgsStruct, -} from './typechain/hardhat-diamond-abi/HardhatDiamondABI.sol/Kresko'; -import type { AllTickers } from '@utils/test/helpers/oracle'; +} from './typechain/hardhat-diamond-abi/HardhatDiamondABI.sol/Kresko' +import type { AllTickers } from '@utils/test/helpers/oracle' -export type ContractTypes = GetContractTypes; -export type ContractNames = keyof ContractTypes; +export type ContractTypes = GetContractTypes +export type ContractNames = keyof ContractTypes export type NetworkConfig = { [network: string]: { - commonInitAgs: Omit; - minterInitArgs: MinterInitArgsStruct; - scdpInitArgs: SCDPInitArgsStruct; - assets: AssetConfigExtended[]; - gnosisSafeDeployments?: GnosisSafeDeployment[]; - }; -}; + commonInitArgs: Omit + minterInitArgs: MinterInitArgsStruct + scdpInitArgs: SCDPInitArgsStruct + assets: AssetConfigExtended[] + gnosisSafeDeployments?: GnosisSafeDeployment[] + } +} export enum OracleType { Empty, @@ -31,7 +31,7 @@ export enum OracleType { Chainlink, API3, Vault, - Pyth + Pyth, } export enum Action { @@ -53,92 +53,92 @@ export enum MinterFee { } export type SCDPDepositAssetConfig = { - depositLimitSCDP: BigNumberish; -}; + depositLimitSCDP: BigNumberish +} type ExtendedInfo = { - decimals: number; - symbol: string; -}; + decimals: number + symbol: string +} export type AssetConfig = { - args: AssetArgs; - assetStruct: AssetStruct; - feedConfig: FeedConfigurationStruct; - extendedInfo: ExtendedInfo; -}; + args: AssetArgs + assetStruct: AssetStruct + feedConfig: FeedConfigurationStruct + extendedInfo: ExtendedInfo +} export type AssetArgs = { - ticker: AllTickers; - getPrice?: () => Promise; - getMarketStatus?: () => Promise; - symbol: AllTokenSymbols; - name?: string; - price?: number; - staleTimes?: [number, number]; + ticker: AllTickers + getPrice?: () => Promise + getMarketStatus?: () => Promise + symbol: AllTokenSymbols + name?: string + price?: number + staleTimes?: [number, number] pyth: { - id: string | null; - invert: boolean; - }; - marketOpen?: boolean; - decimals?: number; - feed?: string; - oracleIds?: [OracleType, OracleType] | readonly [OracleType, OracleType]; - collateralConfig?: CollateralConfig; - krAssetConfig?: KrAssetConfig; - scdpKrAssetConfig?: SCDPKrAssetConfig; - scdpDepositConfig?: SCDPDepositAssetConfig; -}; + id: string | null + invert: boolean + } + marketOpen?: boolean + decimals?: number + feed?: string + oracleIds?: [OracleType, OracleType] | readonly [OracleType, OracleType] + collateralConfig?: CollateralConfig + krAssetConfig?: KrAssetConfig + scdpKrAssetConfig?: SCDPKrAssetConfig + scdpDepositConfig?: SCDPDepositAssetConfig +} export type KrAssetConfig = { - anchor: string | null; - anchorSymbol?: string; - underlyingAddr?: string; - kFactor: BigNumberish; - maxDebtMinter: BigNumberish; - closeFee: BigNumberish; - openFee: BigNumberish; -}; + anchor: string | null + anchorSymbol?: string + underlyingAddr?: string + kFactor: BigNumberish + maxDebtMinter: BigNumberish + closeFee: BigNumberish + openFee: BigNumberish +} export type SCDPKrAssetConfig = { - swapInFeeSCDP: BigNumberish; - swapOutFeeSCDP: BigNumberish; - liqIncentiveSCDP: BigNumberish; - protocolFeeShareSCDP: BigNumberish; - maxDebtSCDP: BigNumberish; -}; + swapInFeeSCDP: BigNumberish + swapOutFeeSCDP: BigNumberish + liqIncentiveSCDP: BigNumberish + protocolFeeShareSCDP: BigNumberish + maxDebtSCDP: BigNumberish +} export type CollateralConfig = { - cFactor: BigNumberish; - liqIncentive: BigNumberish; -}; + cFactor: BigNumberish + liqIncentive: BigNumberish +} export type MinterInitializer = { - name: 'MinterConfigFacet'; - args: MinterInitArgsStruct; -}; + name: 'MinterConfigFacet' + args: MinterInitArgsStruct +} export type SCDPInitializer = { - name: 'SCDPConfigFacet'; - args: SCDPInitArgsStruct; -}; + name: 'SCDPConfigFacet' + args: SCDPInitArgsStruct +} export type CommonInitializer = { - name: 'CommonConfigFacet'; - args: CommonInitArgsStruct; -}; + name: 'CommonConfigFacet' + args: CommonInitArgsStruct +} export type GnosisSafeDeployment = { - defaultAddress: Address; - released: boolean; - contractName: string; - version: string; + defaultAddress: Address + released: boolean + contractName: string + version: string networkAddresses: { - opgoerli: string; - }; - abi: any; -}; + opgoerli: string + } + abi: any +} /* -------------------------------------------------------------------------- */ /* TYPE UTILS */ /* -------------------------------------------------------------------------- */ -export type FuncNames = keyof TC[T]['functions'] | undefined; +export type FuncNames = keyof TC[T]['functions'] | undefined export type FuncArgs, T extends ContractNames> = F extends keyof TC[T]['functions'] ? TC[T]['functions'][F] extends (...args: infer Args) => any @@ -148,34 +148,34 @@ export type FuncArgs, T extends ContractNames> = F extend : readonly [...Args2] : never : never - : never; + : never export type Or = T extends readonly [infer Head, ...infer Tail] ? Head extends true ? true : Or - : false; -export type ValueOf = T[keyof T]; + : false +export type ValueOf = T[keyof T] -export type IsUndefined = [undefined] extends [T] ? true : false; +export type IsUndefined = [undefined] extends [T] ? true : false export type MaybeExcludeEmpty = TMaybeExclude extends true ? Exclude - : T; + : T -export type MaybeRequired = TRequired extends true ? Required : T; -export type MaybeUndefined = TUndefinedish extends true ? T | undefined : T; +export type MaybeRequired = TRequired extends true ? Required : T +export type MaybeUndefined = TUndefinedish extends true ? T | undefined : T export type Split = string extends S ? string[] : S extends '' - ? [] - : S extends `${infer T}${D}${infer U}` - ? [T, ...Split] - : [S]; + ? [] + : S extends `${infer T}${D}${infer U}` + ? [T, ...Split] + : [S] export type Prettify = { - [K in keyof T]: T[K]; -} & {}; + [K in keyof T]: T[K] +} & {} export type ExcludeType = { - [K in keyof T]: T[K] extends E ? K : never; -}[keyof T]; + [K in keyof T]: T[K] extends E ? K : never +}[keyof T] export type Excludes = | 'AccessControlEnumerableUpgradeable' @@ -187,17 +187,17 @@ export type Excludes = | 'ModuleManager' | 'OwnerManager' | 'EtherPaymentFallback' - | 'StorageAccessible'; + | 'StorageAccessible' type KeyValue = { - [key: string]: T; -}; -export type FactoryName = Exclude; + [key: string]: T +} +export type FactoryName = Exclude export type MinEthersFactoryExt = { - connect(address: string, signerOrProvider: any): C; -}; -export type InferContractType = Factory extends MinEthersFactoryExt ? C : unknown; + connect(address: string, signerOrProvider: any): C +} +export type InferContractType = Factory extends MinEthersFactoryExt ? C : unknown export type GetContractTypes = { - [K in FactoryName as `${Split[0]}`]: InferContractType; -}; + [K in FactoryName as `${Split[0]}`]: InferContractType +}