diff --git a/CLAUDE.md b/CLAUDE.md index 0246843..e96be5f 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,10 +4,10 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co ## Overview -HARB is a multi-component DeFi protocol implementing a Harberger tax mechanism with dynamic liquidity provisioning. The project consists of: +KRAIKEN is a multi-component DeFi protocol implementing a Harberger tax mechanism with dynamic liquidity provisioning. The project consists of: - **Smart Contracts** (Solidity/Foundry) - Core protocol logic -- **TypeScript Library** (harb-lib) - Helper functions and GraphQL client +- **TypeScript Library** (kraiken-lib) - Helper functions and GraphQL client - **Subgraph** (AssemblyScript) - Blockchain data indexing - **Transaction Bot** (Node.js) - Automated market making service @@ -15,7 +15,7 @@ HARB is a multi-component DeFi protocol implementing a Harberger tax mechanism w ### Core Components -1. **Harberg Contract** (`onchain/src/Harberg.sol`) - Main protocol contract implementing Harberger tax mechanism +1. **Kraiken Contract** (`onchain/src/Kraiken.sol`) - Main protocol contract implementing Harberger tax mechanism 2. **Stake Contract** (`onchain/src/Stake.sol`) - Staking mechanism for sentiment data 3. **LiquidityManager Contract** (`onchain/src/LiquidityManager.sol`) - Uniswap V3 liquidity management 4. **Optimizer Contract** (`onchain/src/Optimizer.sol`) - Dynamic liquidity optimization @@ -93,7 +93,7 @@ node service.js ## Key Contracts and Interfaces -### Harberg.sol +### Kraiken.sol - Main protocol contract implementing Harberger tax - Integrates with Uniswap V3 for token swaps - Manages tax collection and distribution @@ -126,7 +126,7 @@ node service.js **Order:** ANCHOR → DISCOVERY → FLOOR **Economic Rationale:** -- **ANCHOR → DISCOVERY**: Discovery amount proportional to HARB minted by anchor; positions border anchor for continuous fee capture +- **ANCHOR → DISCOVERY**: Discovery amount proportional to KRAIKEN minted by anchor; positions border anchor for continuous fee capture - **ANCHOR + DISCOVERY → FLOOR**: Floor must defend against maximum selling pressure from final circulating supply, only known after all position minting complete - **VWAP Exclusivity**: Only FLOOR position uses VWAP for historical price memory; ANCHOR/DISCOVERY use current tick for immediate market response @@ -145,19 +145,19 @@ node service.js - **Floor Position Calculation**: Uses adjusted VWAP (70% base + capital inefficiency) to set floor support levels ### Stake.sol -- Staking mechanism for HARB tokens +- Staking mechanism for KRAIKEN tokens - Collects sentiment data through staking behavior - Provides tax rate and staking percentage data ## Deployment Addresses ### Base Sepolia -- Harberg: `0x22c264Ecf8D4E49D1E3CabD8DD39b7C4Ab51C1B8` +- Kraiken: `0x22c264Ecf8D4E49D1E3CabD8DD39b7C4Ab51C1B8` - Stake: `0xe28020BCdEeAf2779dd47c670A8eFC2973316EE2` - LP: `0x3d6a8797693a0bC598210782B6a889E11A2340Cd` ### Base Mainnet -- Harberg: `0x45caa5929f6ee038039984205bdecf968b954820` +- Kraiken: `0x45caa5929f6ee038039984205bdecf968b954820` - Stake: `0xed70707fab05d973ad41eae8d17e2bcd36192cfc` - LP: `0x7fd4e645ce258dd3942eddbeb2f99137da8ba13b` diff --git a/README.md b/README.md index 9612363..d08e3e5 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,3 @@ - [design doc](https://hackmd.io/JvxEI0fnR_uZsIrrBm95Qw) -- [Liquidity Provisioning in HARB](https://hackmd.io/yNiN3TyETT2A1uwQVGYiSA) \ No newline at end of file +- [Liquidity Provisioning in KRAIKEN](https://hackmd.io/yNiN3TyETT2A1uwQVGYiSA) \ No newline at end of file diff --git a/harb-lib/.gitignore b/kraiken-lib/.gitignore similarity index 100% rename from harb-lib/.gitignore rename to kraiken-lib/.gitignore diff --git a/harb-lib/README.md b/kraiken-lib/README.md similarity index 100% rename from harb-lib/README.md rename to kraiken-lib/README.md diff --git a/harb-lib/codegen.yml b/kraiken-lib/codegen.yml similarity index 100% rename from harb-lib/codegen.yml rename to kraiken-lib/codegen.yml diff --git a/harb-lib/jest.config.js b/kraiken-lib/jest.config.js similarity index 100% rename from harb-lib/jest.config.js rename to kraiken-lib/jest.config.js diff --git a/harb-lib/package.json b/kraiken-lib/package.json similarity index 96% rename from harb-lib/package.json rename to kraiken-lib/package.json index 827cce3..4fb015a 100644 --- a/harb-lib/package.json +++ b/kraiken-lib/package.json @@ -1,5 +1,5 @@ { - "name": "harb-lib", + "name": "kraiken-lib", "version": "0.2.0", "description": "helper functions and snatch selection", "main": "dist/index.js", diff --git a/harb-lib/src/__generated__/graphql.ts b/kraiken-lib/src/__generated__/graphql.ts similarity index 100% rename from harb-lib/src/__generated__/graphql.ts rename to kraiken-lib/src/__generated__/graphql.ts diff --git a/harb-lib/src/helpers.ts b/kraiken-lib/src/helpers.ts similarity index 100% rename from harb-lib/src/helpers.ts rename to kraiken-lib/src/helpers.ts diff --git a/harb-lib/src/index.ts b/kraiken-lib/src/index.ts similarity index 100% rename from harb-lib/src/index.ts rename to kraiken-lib/src/index.ts diff --git a/harb-lib/src/subgraph.ts b/kraiken-lib/src/subgraph.ts similarity index 100% rename from harb-lib/src/subgraph.ts rename to kraiken-lib/src/subgraph.ts diff --git a/harb-lib/src/tests/functions.test.ts b/kraiken-lib/src/tests/functions.test.ts similarity index 100% rename from harb-lib/src/tests/functions.test.ts rename to kraiken-lib/src/tests/functions.test.ts diff --git a/harb-lib/src/tests/helpers.test.ts b/kraiken-lib/src/tests/helpers.test.ts similarity index 100% rename from harb-lib/src/tests/helpers.test.ts rename to kraiken-lib/src/tests/helpers.test.ts diff --git a/harb-lib/tsconfig.json b/kraiken-lib/tsconfig.json similarity index 100% rename from harb-lib/tsconfig.json rename to kraiken-lib/tsconfig.json diff --git a/harb-lib/yarn.lock b/kraiken-lib/yarn.lock similarity index 100% rename from harb-lib/yarn.lock rename to kraiken-lib/yarn.lock diff --git a/onchain/script/BaseDeploy.sol b/onchain/script/BaseDeploy.sol index 86cf4d8..e8191b9 100644 --- a/onchain/script/BaseDeploy.sol +++ b/onchain/script/BaseDeploy.sol @@ -1,14 +1,13 @@ pragma solidity ^0.8.19; -import {DeployScript} from "./DeployScript.sol"; +import "forge-std/Script.sol"; -contract BaseDeploy is DeployScript { - function setUp() public { +contract BaseDeploy is Script { + function run() public view { // Base data - feeDest = 0x31ea4993dd336158E1536a1851b76B738BDd24c8; - weth = 0x4200000000000000000000000000000000000006; - v3Factory = 0x33128a8fC17869897dcE68Ed026d694621f6FDfD; - // comment out if new deployment - //twabc = 0xFCFa3b066981027516121bd27a9B1cBb9C00c5Fd; + string memory seedPhrase = vm.readFile(".secret"); + uint256 privateKey = vm.deriveKey(seedPhrase, 0); + address sender = vm.addr(privateKey); + console.log(sender); } } diff --git a/onchain/script/BaseSepoliaDeploy.sol b/onchain/script/BaseSepoliaDeploy.sol deleted file mode 100644 index e387df5..0000000 --- a/onchain/script/BaseSepoliaDeploy.sol +++ /dev/null @@ -1,14 +0,0 @@ -pragma solidity ^0.8.19; - -import {DeployScript} from "./DeployScript.sol"; - -contract BaseSepoliaDeploy is DeployScript { - function setUp() public { - // Base Sepolia data - feeDest = 0xf6a3eef9088A255c32b6aD2025f83E57291D9011; - weth = 0x4200000000000000000000000000000000000006; - v3Factory = 0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24; - // comment out if new deployment - twabc = 0xFCFa3b066981027516121bd27a9B1cBb9C00c5Fd; - } -} diff --git a/onchain/script/DeployScript.sol b/onchain/script/DeployScript.sol deleted file mode 100644 index 72bd945..0000000 --- a/onchain/script/DeployScript.sol +++ /dev/null @@ -1,49 +0,0 @@ -pragma solidity ^0.8.19; - -import "forge-std/Script.sol"; -import "@uniswap-v3-core/interfaces/IUniswapV3Factory.sol"; -import "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol"; -import "../src/Harberg.sol"; -import "../src/Stake.sol"; -import "../src/Optimizer.sol"; -import "../src/helpers/UniswapHelpers.sol"; -import {LiquidityManager} from "../src/LiquidityManager.sol"; -import {ERC1967Proxy} from "@openzeppelin/proxy/ERC1967/ERC1967Proxy.sol"; - -uint24 constant FEE = uint24(10_000); - -contract DeployScript is Script { - using UniswapHelpers for IUniswapV3Pool; - - bool token0isWeth; - address feeDest; - address weth; - address v3Factory; - address twabc; - - function run() public { - string memory seedPhrase = vm.readFile(".secret"); - uint256 privateKey = vm.deriveKey(seedPhrase, 0); - vm.startBroadcast(privateKey); - address sender = vm.addr(privateKey); - console.log(sender); - Harberg harb = new Harberg("Kraiken", "KRK"); - token0isWeth = address(weth) < address(harb); - Stake stake = new Stake(address(harb), feeDest); - harb.setStakingPool(address(stake)); - IUniswapV3Factory factory = IUniswapV3Factory(v3Factory); - address liquidityPool = factory.createPool(weth, address(harb), FEE); - IUniswapV3Pool(liquidityPool).initializePoolFor1Cent(token0isWeth); - Optimizer optimizer = new Optimizer(); - bytes memory params = abi.encodeWithSignature("initialize(address,address)", address(harb), address(stake)); - ERC1967Proxy proxy = new ERC1967Proxy(address(optimizer), params); - LiquidityManager liquidityManager = new LiquidityManager(v3Factory, weth, address(harb), address(proxy)); - liquidityManager.setFeeDestination(feeDest); - // note: this delayed initialization is not a security issue. - harb.setLiquidityManager(address(liquidityManager)); - (bool sent,) = address(liquidityManager).call{value: 0.01 ether}(""); - require(sent, "Failed to send Ether"); - //TODO: wait few minutes and call recenter - vm.stopBroadcast(); - } -} diff --git a/onchain/script/DeployScript2.sol b/onchain/script/DeployScript2.sol new file mode 100644 index 0000000..2c8b765 --- /dev/null +++ b/onchain/script/DeployScript2.sol @@ -0,0 +1,31 @@ +pragma solidity ^0.8.19; + +import "forge-std/Script.sol"; +import "@uniswap-v3-core/interfaces/IUniswapV3Factory.sol"; +import "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol"; +import "../src/Kraiken.sol"; +import "../src/Stake.sol"; +import "../src/Optimizer.sol"; +import "../src/helpers/UniswapHelpers.sol"; +import {LiquidityManager} from "../src/LiquidityManager.sol"; +import {ERC1967Proxy} from "@openzeppelin/proxy/ERC1967/ERC1967Proxy.sol"; + +uint24 constant FEE = uint24(10_000); + +contract DeployScript is Script { + using UniswapHelpers for IUniswapV3Pool; + + bool token0isWeth; + address feeDest; + address weth; + address v3Factory; + address twabc; + + function run() public { + string memory seedPhrase = vm.readFile(".secret"); + uint256 privateKey = vm.deriveKey(seedPhrase, 0); + vm.startBroadcast(privateKey); + address sender = vm.addr(privateKey); + console.log(sender); + } +} diff --git a/onchain/src/Harberg.sol b/onchain/src/Kraiken.sol similarity index 97% rename from onchain/src/Harberg.sol rename to onchain/src/Kraiken.sol index 635737d..b2aa0ed 100644 --- a/onchain/src/Harberg.sol +++ b/onchain/src/Kraiken.sol @@ -9,7 +9,7 @@ import {Math} from "@openzeppelin/utils/math/Math.sol"; * @title stakeable ERC20 Token * @notice This contract implements an ERC20 token with mechanisms for minting and burning in which a single account (staking Pool) is proportionally receiving a share. Only the liquidity manager has permission to manage token supply. */ -contract Harberg is ERC20, ERC20Permit { +contract Kraiken is ERC20, ERC20Permit { using Math for uint256; // Minimum fraction of the total supply required for staking to prevent fragmentation of staking positions @@ -33,7 +33,7 @@ contract Harberg is ERC20, ERC20Permit { } /** - * @notice Constructor for the Harberg token + * @notice Constructor for the Kraiken token * @param name_ The name of the token * @param symbol_ The symbol of the token */ @@ -81,7 +81,7 @@ contract Harberg is ERC20, ERC20Permit { /** * @notice Allows the liquidity manager to mint tokens for itself. - * @dev Tokens minted are managed as community liquidity in the Uniswap pool to stabilize HARB prices. + * @dev Tokens minted are managed as community liquidity in the Uniswap pool to stabilize KRAIKEN prices. * Only callable by the Liquidity Manager. Minting rules and limits are defined externally. * @param _amount The number of tokens to mint. */ diff --git a/onchain/src/LiquidityManager.sol b/onchain/src/LiquidityManager.sol index 4116783..bfcccc9 100644 --- a/onchain/src/LiquidityManager.sol +++ b/onchain/src/LiquidityManager.sol @@ -13,17 +13,17 @@ import "@openzeppelin/utils/math/SignedMath.sol"; import {Math} from "@openzeppelin/utils/math/Math.sol"; import {ABDKMath64x64} from "@abdk/ABDKMath64x64.sol"; import "./interfaces/IWETH9.sol"; -import {Harberg} from "./Harberg.sol"; +import {Kraiken} from "./Kraiken.sol"; import {Optimizer} from "./Optimizer.sol"; import {VWAPTracker} from "./VWAPTracker.sol"; /** - * @title LiquidityManager for Harberg Token on Uniswap V3 - * @notice Manages liquidity provisioning on Uniswap V3 for the Harberg token by maintaining three distinct positions: - * - Floor Position: Ensures a minimum price support by having enough reserve assets to potentially buy back the circulating supply of Harberg. + * @title LiquidityManager for Kraiken Token on Uniswap V3 + * @notice Manages liquidity provisioning on Uniswap V3 for the Kraiken token by maintaining three distinct positions: + * - Floor Position: Ensures a minimum price support by having enough reserve assets to potentially buy back the circulating supply of Kraiken. * - Anchor Position: Provides liquidity around the current market price to facilitate trading and maintain market stability. - * - Discovery Position: Expands liquidity by minting new Harberg tokens as the price rises, capturing potential growth in the ecosystem. - * The contract dynamically adjusts these positions in response to market movements to maintain strategic liquidity levels and support the Harberg token's price. + * - Discovery Position: Expands liquidity by minting new Kraiken tokens as the price rises, capturing potential growth in the ecosystem. + * The contract dynamically adjusts these positions in response to market movements to maintain strategic liquidity levels and support the Kraiken token's price. * It also collects and transfers fees generated from trading activities to a designated fee destination. * @dev Utilizes Uniswap V3's concentrated liquidity feature, enabling highly efficient use of capital. */ @@ -46,7 +46,7 @@ contract LiquidityManager is VWAPTracker { // the address of the Uniswap V3 factory address private immutable factory; IWETH9 private immutable weth; - Harberg private immutable harb; + Kraiken private immutable harb; Optimizer private immutable optimizer; IUniswapV3Pool private immutable pool; bool private immutable token0isWeth; @@ -83,17 +83,17 @@ contract LiquidityManager is VWAPTracker { _; } - /// @notice Creates a liquidity manager for managing Harberg token liquidity on Uniswap V3. + /// @notice Creates a liquidity manager for managing Kraiken token liquidity on Uniswap V3. /// @param _factory The address of the Uniswap V3 factory. /// @param _WETH9 The address of the WETH contract for handling ETH in trades. - /// @param _harb The address of the Harberg token contract. - /// @dev Computes the Uniswap pool address for the Harberg-WETH pair and sets up the initial configuration for the liquidity manager. + /// @param _harb The address of the Kraiken token contract. + /// @dev Computes the Uniswap pool address for the Kraiken-WETH pair and sets up the initial configuration for the liquidity manager. constructor(address _factory, address _WETH9, address _harb, address _optimizer) { factory = _factory; weth = IWETH9(_WETH9); poolKey = PoolAddress.getPoolKey(_WETH9, _harb, FEE); pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey)); - harb = Harberg(_harb); + harb = Kraiken(_harb); token0isWeth = _WETH9 < _harb; optimizer = Optimizer(_optimizer); } @@ -101,7 +101,7 @@ contract LiquidityManager is VWAPTracker { /// @notice Callback function that Uniswap V3 calls for liquidity actions requiring minting or burning of tokens. /// @param amount0Owed The amount of token0 owed for the liquidity provision. /// @param amount1Owed The amount of token1 owed for the liquidity provision. - /// @dev This function mints Harberg tokens as needed and handles WETH deposits for ETH conversions during liquidity interactions. + /// @dev This function mints Kraiken tokens as needed and handles WETH deposits for ETH conversions during liquidity interactions. function uniswapV3MintCallback(uint256 amount0Owed, uint256 amount1Owed, bytes calldata) external { CallbackValidation.verifyCallback(factory, poolKey); // take care of harb @@ -136,9 +136,9 @@ contract LiquidityManager is VWAPTracker { receive() external payable {} - /// @notice Calculates the Uniswap V3 tick corresponding to a given price ratio between Harberg and ETH. + /// @notice Calculates the Uniswap V3 tick corresponding to a given price ratio between Kraiken and ETH. /// @param t0isWeth Boolean flag indicating if token0 is WETH. - /// @param tokenAmount Amount of the Harberg token. + /// @param tokenAmount Amount of the Kraiken token. /// @param ethAmount Amount of Ethereum. /// @return tick_ The calculated tick for the given price ratio. function tickAtPrice(bool t0isWeth, uint256 tokenAmount, uint256 ethAmount) internal pure returns (int24 tick_) { @@ -384,7 +384,7 @@ contract LiquidityManager is VWAPTracker { return (currentTick >= averageTick - MAX_TICK_DEVIATION && currentTick <= averageTick + MAX_TICK_DEVIATION); } - /// @notice Adjusts liquidity positions in response to an increase or decrease in the Harberg token's price. + /// @notice Adjusts liquidity positions in response to an increase or decrease in the Kraiken token's price. /// @dev This function should be called when significant price movement is detected. It recalibrates the liquidity ranges to align with the new market conditions. function recenter() external returns (bool isUp) { // Fetch the current tick from the Uniswap V3 pool diff --git a/onchain/src/LiquidityManagerV2.sol b/onchain/src/LiquidityManagerV2.sol index bde0d4e..ca930ed 100644 --- a/onchain/src/LiquidityManagerV2.sol +++ b/onchain/src/LiquidityManagerV2.sol @@ -7,7 +7,7 @@ import "@aperture/uni-v3-lib/PoolAddress.sol"; import "@aperture/uni-v3-lib/CallbackValidation.sol"; import "@openzeppelin/token/ERC20/IERC20.sol"; import "./interfaces/IWETH9.sol"; -import {Harberg} from "./Harberg.sol"; +import {Kraiken} from "./Kraiken.sol"; import {Optimizer} from "./Optimizer.sol"; import "./abstracts/ThreePositionStrategy.sol"; import "./abstracts/PriceOracle.sol"; @@ -24,7 +24,7 @@ contract LiquidityManagerV2 is ThreePositionStrategy, PriceOracle { /// @notice Immutable contract references address private immutable factory; IWETH9 private immutable weth; - Harberg private immutable harb; + Kraiken private immutable harb; Optimizer private immutable optimizer; IUniswapV3Pool private immutable pool; bool private immutable token0isWeth; @@ -47,14 +47,14 @@ contract LiquidityManagerV2 is ThreePositionStrategy, PriceOracle { /// @notice Constructor initializes all contract references and pool configuration /// @param _factory The address of the Uniswap V3 factory /// @param _WETH9 The address of the WETH contract - /// @param _harb The address of the Harberg token contract + /// @param _harb The address of the Kraiken token contract /// @param _optimizer The address of the optimizer contract constructor(address _factory, address _WETH9, address _harb, address _optimizer) { factory = _factory; weth = IWETH9(_WETH9); poolKey = PoolAddress.getPoolKey(_WETH9, _harb, FEE); pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey)); - harb = Harberg(_harb); + harb = Kraiken(_harb); token0isWeth = _WETH9 < _harb; optimizer = Optimizer(_optimizer); } diff --git a/onchain/src/Optimizer.sol b/onchain/src/Optimizer.sol index addd600..87648bb 100644 --- a/onchain/src/Optimizer.sol +++ b/onchain/src/Optimizer.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.19; -import {Harberg} from "./Harberg.sol"; +import {Kraiken} from "./Kraiken.sol"; import {Stake} from "./Stake.sol"; import {UUPSUpgradeable} from "@openzeppelin/proxy/utils/UUPSUpgradeable.sol"; import {Initializable} from "@openzeppelin/proxy/utils/Initializable.sol"; @@ -9,11 +9,11 @@ import {Initializable} from "@openzeppelin/proxy/utils/Initializable.sol"; /** * @title Optimizer * @notice This contract (formerly Sentimenter) calculates a “sentiment” value and liquidity parameters - * based on the tax rate and the percentage of Harberg staked. + * based on the tax rate and the percentage of Kraiken staked. * @dev It is upgradeable using UUPS. Only the admin (set during initialization) can upgrade. */ contract Optimizer is Initializable, UUPSUpgradeable { - Harberg private harberg; + Kraiken private harberg; Stake private stake; /// @dev Reverts if the caller is not the admin. @@ -21,13 +21,13 @@ contract Optimizer is Initializable, UUPSUpgradeable { /** * @notice Initialize the Optimizer. - * @param _harberg The address of the Harberg token. + * @param _harberg The address of the Kraiken token. * @param _stake The address of the Stake contract. */ function initialize(address _harberg, address _stake) public initializer { // Set the admin for upgradeability (using ERC1967Upgrade _changeAdmin) _changeAdmin(msg.sender); - harberg = Harberg(_harberg); + harberg = Kraiken(_harberg); stake = Stake(_stake); } diff --git a/onchain/src/Stake.sol b/onchain/src/Stake.sol index d0586c0..42eb804 100644 --- a/onchain/src/Stake.sol +++ b/onchain/src/Stake.sol @@ -6,14 +6,14 @@ import {IERC20Metadata} from "@openzeppelin/token/ERC20/extensions/IERC20Metadat import {ERC20Permit} from "@openzeppelin/token/ERC20/extensions/ERC20Permit.sol"; import {SafeERC20} from "@openzeppelin/token/ERC20/utils/SafeERC20.sol"; import {Math} from "@openzeppelin/utils/math/Math.sol"; -import {Harberg} from "./Harberg.sol"; +import {Kraiken} from "./Kraiken.sol"; error ExceededAvailableStake(address receiver, uint256 stakeWanted, uint256 availableStake); error TooMuchSnatch(address receiver, uint256 stakeWanted, uint256 availableStake, uint256 smallestShare); /** - * @title Stake Contract for Harberg Token - * @notice This contract manages the staking positions for the Harberg token, allowing users to stake tokens + * @title Stake Contract for Kraiken Token + * @notice This contract manages the staking positions for the Kraiken token, allowing users to stake tokens * in exchange for a share of the total supply. Stakers can set and adjust tax rates on their stakes, * which affect the Universal Basic Income (UBI) paid from the tax pool. * @@ -33,8 +33,8 @@ contract Stake { // the offset between the "precision" of the representation of shares and assets // see https://docs.openzeppelin.com/contracts/4.x/erc4626 for reason and details uint256 internal DECIMAL_OFFSET = 5 + 2; - // only 20% of the total HARB supply can be staked. - uint256 internal constant MAX_STAKE = 20; // 20% of HARB supply + // only 20% of the total KRAIKEN supply can be staked. + uint256 internal constant MAX_STAKE = 20; // 20% of KRAIKEN supply uint256 internal constant TAX_FLOOR_DURATION = 60 * 60 * 24 * 3; //this duration is the minimum basis for fee calculation, regardless of actual holding time. // the tax rates are discrete to prevent users from snatching by micro incroments of tax uint256[] public TAX_RATES = [ @@ -81,14 +81,14 @@ contract Stake { error PositionNotFound(uint256 positionId, address requester); event PositionCreated( - uint256 indexed positionId, address indexed owner, uint256 harbergDeposit, uint256 share, uint32 taxRate + uint256 indexed positionId, address indexed owner, uint256 kraikenDeposit, uint256 share, uint32 taxRate ); event PositionTaxPaid( uint256 indexed positionId, address indexed owner, uint256 taxPaid, uint256 newShares, uint256 taxRate ); event PositionRateHiked(uint256 indexed positionId, address indexed owner, uint256 newTaxRate); - event PositionShrunk(uint256 indexed positionId, address indexed owner, uint256 newShares, uint256 harbergPayout); - event PositionRemoved(uint256 indexed positionId, address indexed owner, uint256 harbergPayout); + event PositionShrunk(uint256 indexed positionId, address indexed owner, uint256 newShares, uint256 kraikenPayout); + event PositionRemoved(uint256 indexed positionId, address indexed owner, uint256 kraikenPayout); struct StakingPosition { uint256 share; @@ -98,7 +98,7 @@ contract Stake { uint32 taxRate; // index of TAX_RATES array } - Harberg private immutable harberg; + Kraiken private immutable kraiken; address private immutable taxReceiver; uint256 public immutable totalSupply; @@ -110,13 +110,13 @@ contract Stake { // Array to keep track of total shares at each tax rate uint256[] public totalSharesAtTaxRate; - /// @notice Initializes the stake contract with references to the Harberg contract and sets the initial position ID. - /// @param _harberg Address of the Harberg contract which this Stake contract interacts with. - /// @dev Sets up the total supply based on the decimals of the Harberg token plus a fixed offset. - constructor(address _harberg, address _taxReceiver) { - harberg = Harberg(_harberg); + /// @notice Initializes the stake contract with references to the Kraiken contract and sets the initial position ID. + /// @param _kraiken Address of the Kraiken contract which this Stake contract interacts with. + /// @dev Sets up the total supply based on the decimals of the Kraiken token plus a fixed offset. + constructor(address _kraiken, address _taxReceiver) { + kraiken = Kraiken(_kraiken); taxReceiver = _taxReceiver; - totalSupply = 10 ** (harberg.decimals() + DECIMAL_OFFSET); + totalSupply = 10 ** (kraiken.decimals() + DECIMAL_OFFSET); // start counting somewhere nextPositionId = 654321; // Initialize totalSharesAtTaxRate array @@ -161,7 +161,7 @@ contract Stake { delete pos.creationTime; delete pos.share; } - SafeERC20.safeTransfer(harberg, taxReceiver, taxAmountDue); + SafeERC20.safeTransfer(kraiken, taxReceiver, taxAmountDue); } /// @dev Internal function to close a staking position, transferring the remaining Harberg tokens back to the owner after tax payment. @@ -174,7 +174,7 @@ contract Stake { delete pos.owner; delete pos.creationTime; delete pos.share; - SafeERC20.safeTransfer(harberg, owner, assets); + SafeERC20.safeTransfer(kraiken, owner, assets); } /// @dev Internal function to reduce the size of a staking position by a specified number of shares, transferring the corresponding Harberg tokens to the owner. @@ -185,21 +185,21 @@ contract Stake { totalSharesAtTaxRate[pos.taxRate] -= sharesToTake; outstandingStake -= sharesToTake; emit PositionShrunk(positionId, pos.owner, pos.share, assets); - SafeERC20.safeTransfer(harberg, pos.owner, assets); + SafeERC20.safeTransfer(kraiken, pos.owner, assets); } /// @notice Converts Harberg token assets to shares of the total staking pool. /// @param assets Number of Harberg tokens to convert. /// @return Number of shares corresponding to the input assets based on the current total supply of Harberg tokens. function assetsToShares(uint256 assets) public view returns (uint256) { - return assets.mulDiv(totalSupply, harberg.totalSupply(), Math.Rounding.Down); + return assets.mulDiv(totalSupply, kraiken.totalSupply(), Math.Rounding.Down); } /// @notice Converts shares of the total staking pool back to Harberg token assets. /// @param shares Number of shares to convert. /// @return The equivalent number of Harberg tokens for the given shares. function sharesToAssets(uint256 shares) public view returns (uint256) { - return shares.mulDiv(harberg.totalSupply(), totalSupply, Math.Rounding.Down); + return shares.mulDiv(kraiken.totalSupply(), totalSupply, Math.Rounding.Down); } /// @notice Creates a new staking position by potentially snatching shares from existing positions. @@ -218,7 +218,7 @@ contract Stake { { // check that position size is at least minStake // to prevent excessive fragmentation, increasing snatch cost - uint256 minStake = harberg.minStake(); + uint256 minStake = kraiken.minStake(); if (assets < minStake) { revert StakeTooLow(receiver, assets, minStake); } @@ -287,7 +287,7 @@ contract Stake { } // transfer - SafeERC20.safeTransferFrom(harberg, msg.sender, address(this), assets); + SafeERC20.safeTransferFrom(kraiken, msg.sender, address(this), assets); // mint positionId = nextPositionId++; @@ -324,7 +324,7 @@ contract Stake { bytes32 r, bytes32 s ) external returns (uint256 positionId) { - ERC20Permit(address(harberg)).permit(receiver, address(this), assets, deadline, v, r, s); + ERC20Permit(address(kraiken)).permit(receiver, address(this), assets, deadline, v, r, s); return snatch(assets, receiver, taxRate, positionsToSnatch); } diff --git a/onchain/test/Harberg.t.sol b/onchain/test/Kraiken.t.sol similarity index 71% rename from onchain/test/Harberg.t.sol rename to onchain/test/Kraiken.t.sol index e9a5349..3ce3e36 100644 --- a/onchain/test/Harberg.t.sol +++ b/onchain/test/Kraiken.t.sol @@ -4,109 +4,109 @@ pragma solidity ^0.8.19; import "forge-std/Test.sol"; import "forge-std/console.sol"; import {IERC20} from "@openzeppelin/token/ERC20/IERC20.sol"; -import "../src/Harberg.sol"; +import "../src/Kraiken.sol"; -contract HarbergTest is Test { - Harberg harberg; +contract KraikenTest is Test { + Kraiken kraiken; address stakingPool; address liquidityPool; address liquidityManager; function setUp() public { - harberg = new Harberg("HARB", "HARB"); + kraiken = new Kraiken("KRAIKEN", "KRK"); stakingPool = makeAddr("stakingPool"); - harberg.setStakingPool(stakingPool); + kraiken.setStakingPool(stakingPool); liquidityManager = makeAddr("liquidityManager"); - harberg.setLiquidityManager(liquidityManager); + kraiken.setLiquidityManager(liquidityManager); } // Simulates staking by transferring tokens to the stakingPool address. function simulateStake(uint256 amount) internal { // the amount of token has to be available on the balance // of the test contract - harberg.transfer(stakingPool, amount); + kraiken.transfer(stakingPool, amount); } // Simulates unstaking by transferring tokens from the stakingPool back to a given address. function simulateUnstake(uint256 amount) internal { // Direct transfer from the stakingPool to 'to' address to simulate unstaking vm.prank(stakingPool); // Assuming 'stake' contract would allow this in an actual scenario - harberg.transfer(address(this), amount); + kraiken.transfer(address(this), amount); } - function testHarbergConstructor() public view { + function testKraikenConstructor() public view { // Check if the token details are set as expected - assertEq(harberg.name(), "HARB"); - assertEq(harberg.symbol(), "HARB"); + assertEq(kraiken.name(), "KRAIKEN"); + assertEq(kraiken.symbol(), "KRK"); // Confirm that the TwabController address is correctly set - (address _lm, address _sp) = harberg.peripheryContracts(); + (address _lm, address _sp) = kraiken.peripheryContracts(); assertEq(_lm, liquidityManager); assertEq(_sp, stakingPool); } function testMintWithEmptyStakingPool() public { - uint256 initialSupply = harberg.totalSupply(); + uint256 initialSupply = kraiken.totalSupply(); uint256 mintAmount = 1000 * 1e18; // 1000 HARB tokens vm.prank(address(liquidityManager)); - harberg.mint(mintAmount); + kraiken.mint(mintAmount); // Check if the total supply has increased correctly - assertEq(harberg.totalSupply(), initialSupply + mintAmount); + assertEq(kraiken.totalSupply(), initialSupply + mintAmount); // Check if the staking pool balance is still 0, as before - assertEq(harberg.balanceOf(stakingPool), 0); + assertEq(kraiken.balanceOf(stakingPool), 0); } function testBurnWithEmptyStakingPool() public { - uint256 initialSupply = harberg.totalSupply(); + uint256 initialSupply = kraiken.totalSupply(); uint256 burnAmount = 500 * 1e18; // 500 HARB tokens // First, mint some tokens to burn vm.prank(address(liquidityManager)); - harberg.mint(burnAmount); + kraiken.mint(burnAmount); vm.prank(address(liquidityManager)); - harberg.burn(burnAmount); + kraiken.burn(burnAmount); // Check if the total supply has decreased correctly - assertEq(harberg.totalSupply(), initialSupply); + assertEq(kraiken.totalSupply(), initialSupply); // Check if the staking pool balance has decreased correctly - assertEq(harberg.balanceOf(stakingPool), 0); + assertEq(kraiken.balanceOf(stakingPool), 0); } function testMintImpactOnSimulatedStaking() public { - uint256 initialStakingPoolBalance = harberg.balanceOf(stakingPool); + uint256 initialStakingPoolBalance = kraiken.balanceOf(stakingPool); uint256 mintAmount = 1000 * 1e18; // 1000 HARB tokens // Ensure the test contract has enough tokens to simulate staking vm.prank(address(liquidityManager)); - harberg.mint(mintAmount); + kraiken.mint(mintAmount); vm.prank(address(liquidityManager)); - harberg.transfer(address(this), mintAmount); + kraiken.transfer(address(this), mintAmount); // Simulate staking of the minted amount simulateStake(mintAmount); // Check balances after simulated staking - assertEq(harberg.balanceOf(stakingPool), initialStakingPoolBalance + mintAmount); + assertEq(kraiken.balanceOf(stakingPool), initialStakingPoolBalance + mintAmount); } function testUnstakeImpactOnTotalSupply() public { uint256 stakeAmount = 500 * 1e18; // 500 HARB tokens // Ensure the test contract has enough tokens to simulate staking vm.prank(address(liquidityManager)); - harberg.mint(stakeAmount); + kraiken.mint(stakeAmount); vm.prank(address(liquidityManager)); - harberg.transfer(address(this), stakeAmount); + kraiken.transfer(address(this), stakeAmount); - uint256 initialTotalSupply = harberg.totalSupply(); + uint256 initialTotalSupply = kraiken.totalSupply(); // Simulate staking and then unstaking simulateStake(stakeAmount); simulateUnstake(stakeAmount); // Check total supply remains unchanged after unstake - assertEq(harberg.totalSupply(), initialTotalSupply); + assertEq(kraiken.totalSupply(), initialTotalSupply); } // Fuzz test for mint function with varying stake amounts @@ -114,37 +114,37 @@ contract HarbergTest is Test { uint256 initialAmount = 500 * 1e18; // Ensure the test contract has enough tokens to simulate staking vm.prank(address(liquidityManager)); - harberg.mint(initialAmount); + kraiken.mint(initialAmount); vm.prank(address(liquidityManager)); - harberg.transfer(address(this), initialAmount); + kraiken.transfer(address(this), initialAmount); // Limit fuzzing input to 0% - 20% uint8 effectiveStakePercentage = _stakePercentage % 21; uint256 stakeAmount = (initialAmount * effectiveStakePercentage) / 100; simulateStake(stakeAmount); - uint256 initialTotalSupply = harberg.totalSupply(); - uint256 initialStakingPoolBalance = harberg.balanceOf(stakingPool); + uint256 initialTotalSupply = kraiken.totalSupply(); + uint256 initialStakingPoolBalance = kraiken.balanceOf(stakingPool); mintAmount = bound(mintAmount, 1, 500 * 1e18); uint256 expectedNewStake = initialStakingPoolBalance * mintAmount / (initialTotalSupply - initialStakingPoolBalance); // Expect Transfer events - vm.expectEmit(true, true, true, true, address(harberg)); + vm.expectEmit(true, true, true, true, address(kraiken)); emit IERC20.Transfer(address(0), address(liquidityManager), mintAmount); vm.prank(address(liquidityManager)); - harberg.mint(mintAmount); + kraiken.mint(mintAmount); uint256 expectedStakingPoolBalance = initialStakingPoolBalance + expectedNewStake; uint256 expectedTotalSupply = initialTotalSupply + mintAmount + expectedNewStake; assertEq( - harberg.balanceOf(stakingPool), + kraiken.balanceOf(stakingPool), expectedStakingPoolBalance, "Staking pool balance did not adjust correctly after mint." ); - assertEq(harberg.totalSupply(), expectedTotalSupply, "Total supply did not match expected after mint."); + assertEq(kraiken.totalSupply(), expectedTotalSupply, "Total supply did not match expected after mint."); } // Fuzz test for burn function with varying stake amounts @@ -152,32 +152,32 @@ contract HarbergTest is Test { uint256 mintAmount = 500 * 1e18; // Ensure the test contract has enough tokens to simulate staking vm.prank(address(liquidityManager)); - harberg.mint(mintAmount); + kraiken.mint(mintAmount); // Limit fuzzing input to 0% - 20% uint8 effectiveStakePercentage = _stakePercentage % 21; uint256 stakeAmount = (mintAmount * effectiveStakePercentage) / 100; vm.prank(address(liquidityManager)); - harberg.transfer(address(this), stakeAmount); + kraiken.transfer(address(this), stakeAmount); simulateStake(stakeAmount); burnAmount = bound(burnAmount, 0, 200 * 1e18); - uint256 initialTotalSupply = harberg.totalSupply(); - uint256 initialStakingPoolBalance = harberg.balanceOf(stakingPool); + uint256 initialTotalSupply = kraiken.totalSupply(); + uint256 initialStakingPoolBalance = kraiken.balanceOf(stakingPool); uint256 expectedExcessStake = initialStakingPoolBalance * burnAmount / (initialTotalSupply - initialStakingPoolBalance); vm.prank(address(liquidityManager)); - harberg.burn(burnAmount); + kraiken.burn(burnAmount); uint256 expectedStakingPoolBalance = initialStakingPoolBalance - expectedExcessStake; uint256 expectedTotalSupply = initialTotalSupply - burnAmount - expectedExcessStake; assertEq( - harberg.balanceOf(stakingPool), + kraiken.balanceOf(stakingPool), expectedStakingPoolBalance, "Staking pool balance did not adjust correctly after burn." ); - assertEq(harberg.totalSupply(), expectedTotalSupply, "Total supply did not match expected after burn."); + assertEq(kraiken.totalSupply(), expectedTotalSupply, "Total supply did not match expected after burn."); } } diff --git a/onchain/test/LiquidityManager.t.sol b/onchain/test/LiquidityManager.t.sol index 47776a9..b1603bf 100644 --- a/onchain/test/LiquidityManager.t.sol +++ b/onchain/test/LiquidityManager.t.sol @@ -18,7 +18,7 @@ import {PoolAddress, PoolKey} from "@aperture/uni-v3-lib/PoolAddress.sol"; import "@uniswap-v3-core/interfaces/IUniswapV3Factory.sol"; import "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol"; import "../src/interfaces/IWETH9.sol"; -import {Harberg} from "../src/Harberg.sol"; +import {Kraiken} from "../src/Kraiken.sol"; import {Stake, ExceededAvailableStake} from "../src/Stake.sol"; import {LiquidityManager} from "../src/LiquidityManager.sol"; @@ -115,7 +115,7 @@ contract LiquidityManagerTest is UniswapTestBase { } weth = IWETH9(address(new WETH())); - harberg = new Harberg("HARB", "HARB"); + harberg = new Kraiken("HARB", "HARB"); // Check if the setup meets the required condition if (token0shouldBeWeth == address(weth) < address(harberg)) { diff --git a/onchain/test/Stake.t.sol b/onchain/test/Stake.t.sol index 2900bfb..a7ab413 100644 --- a/onchain/test/Stake.t.sol +++ b/onchain/test/Stake.t.sol @@ -3,26 +3,26 @@ pragma solidity ^0.8.19; import "forge-std/Test.sol"; import "forge-std/console.sol"; -import "../src/Harberg.sol"; +import "../src/Kraiken.sol"; import {TooMuchSnatch, Stake} from "../src/Stake.sol"; contract StakeTest is Test { - Harberg harberg; + Kraiken kraiken; Stake stakingPool; address liquidityPool; address liquidityManager; event PositionCreated( - uint256 indexed positionId, address indexed owner, uint256 harbergDeposit, uint256 share, uint32 taxRate + uint256 indexed positionId, address indexed owner, uint256 kraikenDeposit, uint256 share, uint32 taxRate ); - event PositionRemoved(uint256 indexed positionId, address indexed owner, uint256 harbergPayout); + event PositionRemoved(uint256 indexed positionId, address indexed owner, uint256 kraikenPayout); function setUp() public { - harberg = new Harberg("HARB", "HARB"); - stakingPool = new Stake(address(harberg), makeAddr("taxRecipient")); - harberg.setStakingPool(address(stakingPool)); + kraiken = new Kraiken("KRAIKEN", "KRK"); + stakingPool = new Stake(address(kraiken), makeAddr("taxRecipient")); + kraiken.setStakingPool(address(stakingPool)); liquidityManager = makeAddr("liquidityManager"); - harberg.setLiquidityManager(liquidityManager); + kraiken.setLiquidityManager(liquidityManager); } function assertPosition(uint256 positionId, uint256 expectedShares, uint32 expectedTaxRate) private view { @@ -46,14 +46,14 @@ contract StakeTest is Test { address staker = makeAddr("staker"); vm.startPrank(liquidityManager); - harberg.mint(stakeAmount * 5); - harberg.transfer(staker, stakeAmount); + kraiken.mint(stakeAmount * 5); + kraiken.transfer(staker, stakeAmount); vm.stopPrank(); vm.startPrank(staker); // Approve and stake - harberg.approve(address(stakingPool), stakeAmount); + kraiken.approve(address(stakingPool), stakeAmount); uint256[] memory empty; uint256 sharesExpected = stakingPool.assetsToShares(stakeAmount); vm.expectEmit(address(stakingPool)); @@ -81,13 +81,13 @@ contract StakeTest is Test { address staker = makeAddr("staker"); vm.startPrank(liquidityManager); - harberg.mint(stakeAmount * 5); // Ensuring the staker has enough balance - harberg.transfer(staker, stakeAmount); + kraiken.mint(stakeAmount * 5); // Ensuring the staker has enough balance + kraiken.transfer(staker, stakeAmount); vm.stopPrank(); // Staker stakes tokens vm.startPrank(staker); - harberg.approve(address(stakingPool), stakeAmount); + kraiken.approve(address(stakingPool), stakeAmount); uint256[] memory empty; uint256 positionId = stakingPool.snatch(stakeAmount, staker, 1, empty); @@ -106,7 +106,7 @@ contract StakeTest is Test { stakingPool.exitPosition(positionId); // Check results after unstaking - assertEq(harberg.balanceOf(staker), assetsAfterTax, "Assets after tax not returned correctly"); + assertEq(kraiken.balanceOf(staker), assetsAfterTax, "Assets after tax not returned correctly"); assertEq(stakingPool.outstandingStake(), 0, "Outstanding stake not updated correctly"); // Ensure the position is cleared @@ -127,10 +127,10 @@ contract StakeTest is Test { // Mint and distribute tokens vm.startPrank(liquidityManager); - harberg.mint((initialStake1 + initialStake2) * 5); - harberg.transfer(firstStaker, initialStake1); - harberg.transfer(secondStaker, initialStake2); - harberg.transfer(newStaker, snatchAmount); + kraiken.mint((initialStake1 + initialStake2) * 5); + kraiken.transfer(firstStaker, initialStake1); + kraiken.transfer(secondStaker, initialStake2); + kraiken.transfer(newStaker, snatchAmount); vm.stopPrank(); // Setup initial stakers @@ -139,7 +139,7 @@ contract StakeTest is Test { // Snatch setup vm.startPrank(newStaker); - harberg.approve(address(stakingPool), snatchAmount); + kraiken.approve(address(stakingPool), snatchAmount); uint256 snatchShares = stakingPool.assetsToShares(snatchAmount); uint256[] memory targetPositions = new uint256[](2); targetPositions[0] = positionId1; @@ -160,7 +160,7 @@ contract StakeTest is Test { function doSnatch(address staker, uint256 amount, uint32 taxRate) private returns (uint256 positionId) { vm.startPrank(staker); - harberg.approve(address(stakingPool), amount); + kraiken.approve(address(stakingPool), amount); uint256[] memory empty; positionId = stakingPool.snatch(amount, staker, taxRate, empty); vm.stopPrank(); @@ -183,9 +183,9 @@ contract StakeTest is Test { // Mint and distribute tokens vm.startPrank(liquidityManager); // mint all the tokens we will need in the test - harberg.mint((smallstake + stakeOneThird + stakeTwoThird) * 5); + kraiken.mint((smallstake + stakeOneThird + stakeTwoThird) * 5); // send 20% of that to staker - harberg.transfer(staker, (smallstake + stakeOneThird + stakeTwoThird) * 2); + kraiken.transfer(staker, (smallstake + stakeOneThird + stakeTwoThird) * 2); vm.stopPrank(); // Setup initial stakers @@ -259,18 +259,18 @@ contract StakeTest is Test { function testRevert_SharesTooLow() public { address staker = makeAddr("staker"); vm.startPrank(liquidityManager); - harberg.mint(10 ether); - uint256 tooSmallStake = harberg.previousTotalSupply() / 4000; // Less than minStake calculation - harberg.transfer(staker, tooSmallStake); + kraiken.mint(10 ether); + uint256 tooSmallStake = kraiken.previousTotalSupply() / 4000; // Less than minStake calculation + kraiken.transfer(staker, tooSmallStake); vm.stopPrank(); vm.startPrank(staker); - harberg.approve(address(stakingPool), tooSmallStake); + kraiken.approve(address(stakingPool), tooSmallStake); uint256[] memory empty; vm.expectRevert( abi.encodeWithSelector( - Stake.StakeTooLow.selector, staker, tooSmallStake, harberg.previousTotalSupply() / 3000 + Stake.StakeTooLow.selector, staker, tooSmallStake, kraiken.previousTotalSupply() / 3000 ) ); stakingPool.snatch(tooSmallStake, staker, 1, empty); @@ -281,16 +281,16 @@ contract StakeTest is Test { address existingStaker = makeAddr("existingStaker"); address newStaker = makeAddr("newStaker"); vm.startPrank(liquidityManager); - harberg.mint(10 ether); - harberg.transfer(existingStaker, 1 ether); - harberg.transfer(newStaker, 1 ether); + kraiken.mint(10 ether); + kraiken.transfer(existingStaker, 1 ether); + kraiken.transfer(newStaker, 1 ether); vm.stopPrank(); uint256 positionId = doSnatch(existingStaker, 1 ether, 5); // Existing staker with tax rate 5 vm.startPrank(newStaker); - harberg.transfer(newStaker, 1 ether); - harberg.approve(address(stakingPool), 1 ether); + kraiken.transfer(newStaker, 1 ether); + kraiken.approve(address(stakingPool), 1 ether); uint256[] memory positions = new uint256[](1); positions[0] = positionId; // Assuming position ID 1 has tax rate 5 @@ -305,15 +305,15 @@ contract StakeTest is Test { address ambitiousStaker = makeAddr("ambitiousStaker"); vm.startPrank(liquidityManager); - harberg.mint(20 ether); - harberg.transfer(staker, 2 ether); - harberg.transfer(ambitiousStaker, 1 ether); + kraiken.mint(20 ether); + kraiken.transfer(staker, 2 ether); + kraiken.transfer(ambitiousStaker, 1 ether); vm.stopPrank(); uint256 positionId = doSnatch(staker, 2 ether, 10); vm.startPrank(ambitiousStaker); - harberg.approve(address(stakingPool), 1 ether); + kraiken.approve(address(stakingPool), 1 ether); uint256[] memory positions = new uint256[](1); positions[0] = positionId; @@ -328,12 +328,12 @@ contract StakeTest is Test { address staker = makeAddr("staker"); vm.startPrank(liquidityManager); - harberg.mint(10 ether); - harberg.transfer(staker, 1 ether); + kraiken.mint(10 ether); + kraiken.transfer(staker, 1 ether); vm.stopPrank(); vm.startPrank(staker); - harberg.approve(address(stakingPool), 1 ether); + kraiken.approve(address(stakingPool), 1 ether); uint256[] memory nonExistentPositions = new uint256[](1); nonExistentPositions[0] = 999; // Assumed non-existent position ID @@ -349,12 +349,12 @@ contract StakeTest is Test { address staker = makeAddr("staker"); vm.startPrank(liquidityManager); - harberg.mint(10 ether); - harberg.transfer(staker, 1 ether); + kraiken.mint(10 ether); + kraiken.transfer(staker, 1 ether); vm.stopPrank(); vm.startPrank(staker); - harberg.approve(address(stakingPool), 1 ether); + kraiken.approve(address(stakingPool), 1 ether); uint256[] memory empty; uint256 positionId = stakingPool.snatch(1 ether, staker, 1, empty); @@ -380,12 +380,12 @@ contract StakeTest is Test { address staker = makeAddr("staker"); vm.startPrank(liquidityManager); - harberg.mint(10 ether); - harberg.transfer(staker, 1 ether); + kraiken.mint(10 ether); + kraiken.transfer(staker, 1 ether); vm.stopPrank(); vm.startPrank(staker); - harberg.approve(address(stakingPool), 1 ether); + kraiken.approve(address(stakingPool), 1 ether); uint256[] memory empty; uint256 positionId = stakingPool.snatch(1 ether, staker, 5, empty); // Using tax rate index 5, which is 18% per year (uint256 shareBefore,,,,) = stakingPool.positions(positionId); @@ -419,12 +419,12 @@ contract StakeTest is Test { address staker = makeAddr("staker"); vm.startPrank(liquidityManager); - harberg.mint(10 ether); - harberg.transfer(staker, 1 ether); + kraiken.mint(10 ether); + kraiken.transfer(staker, 1 ether); vm.stopPrank(); vm.startPrank(staker); - harberg.approve(address(stakingPool), 1 ether); + kraiken.approve(address(stakingPool), 1 ether); uint256[] memory empty; uint256 positionId = stakingPool.snatch(1 ether, staker, 12, empty); // Using tax rate index 5, which is 100% per year vm.warp(block.timestamp + 365 days); // Move time forward to ensure maximum tax due diff --git a/onchain/test/helpers/UniswapTestBase.sol b/onchain/test/helpers/UniswapTestBase.sol index cd468ef..071046a 100644 --- a/onchain/test/helpers/UniswapTestBase.sol +++ b/onchain/test/helpers/UniswapTestBase.sol @@ -5,7 +5,7 @@ import "forge-std/Test.sol"; import "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol"; import {TickMath} from "@aperture/uni-v3-lib/TickMath.sol"; import "../../src/interfaces/IWETH9.sol"; -import {Harberg} from "../../src/Harberg.sol"; +import {Kraiken} from "../../src/Kraiken.sol"; /** * @title UniswapTestBase @@ -15,7 +15,7 @@ abstract contract UniswapTestBase is Test { address account = makeAddr("alice"); IUniswapV3Pool public pool; IWETH9 public weth; - Harberg public harberg; + Kraiken public harberg; bool public token0isWeth; /** @@ -80,7 +80,7 @@ abstract contract UniswapTestBase is Test { /// @notice Callback function that Uniswap V3 calls for liquidity actions requiring minting or burning of tokens. /// @param amount0Owed The amount of token0 owed for the liquidity provision. /// @param amount1Owed The amount of token1 owed for the liquidity provision. - /// @dev This function mints Harberg tokens as needed and handles WETH deposits for ETH conversions during liquidity interactions. + /// @dev This function mints Kraiken tokens as needed and handles WETH deposits for ETH conversions during liquidity interactions. function uniswapV3MintCallback(uint256 amount0Owed, uint256 amount1Owed, bytes calldata) external { // CallbackValidation.verifyCallback(factory, poolKey); // take care of harb diff --git a/onchain/test/mocks/MockOptimizer.sol b/onchain/test/mocks/MockOptimizer.sol index af375a4..b0d7176 100644 --- a/onchain/test/mocks/MockOptimizer.sol +++ b/onchain/test/mocks/MockOptimizer.sol @@ -1,13 +1,13 @@ // SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.19; -import {Harberg} from "../../src/Harberg.sol"; +import {Kraiken} from "../../src/Kraiken.sol"; import {Stake} from "../../src/Stake.sol"; import {UUPSUpgradeable} from "@openzeppelin/proxy/utils/UUPSUpgradeable.sol"; import {Initializable} from "@openzeppelin/proxy/utils/Initializable.sol"; contract MockOptimizer is Initializable, UUPSUpgradeable { - Harberg private harberg; + Kraiken private kraiken; Stake private stake; // Configurable parameters for sentiment analysis @@ -21,9 +21,9 @@ contract MockOptimizer is Initializable, UUPSUpgradeable { */ error UnauthorizedAccount(address account); - function initialize(address _harberg, address _stake) public initializer { + function initialize(address _kraiken, address _stake) public initializer { _changeAdmin(msg.sender); - harberg = Harberg(_harberg); + kraiken = Kraiken(_kraiken); stake = Stake(_stake); } /** diff --git a/services/txnBot/package.json b/services/txnBot/package.json index 4279a81..fb321a9 100644 --- a/services/txnBot/package.json +++ b/services/txnBot/package.json @@ -7,7 +7,7 @@ "dotenv": "^16.4.5", "ethers": "^6.13.2", "express": "^5.0.0", - "harb-lib": "^0.2.0" + "kraiken-lib": "file:../../kraiken-lib" }, "devDependencies": { "@graphprotocol/client-cli": "^3.0.7" diff --git a/services/txnBot/service.js b/services/txnBot/service.js index c75c462..1dc7ebd 100644 --- a/services/txnBot/service.js +++ b/services/txnBot/service.js @@ -2,7 +2,7 @@ require('dotenv').config(); const { ethers } = require('ethers'); const express = require('express'); const { execute } = require('./.graphclient'); -const { bytesToUint256 } = require('harb-lib'); +const { bytesToUint256 } = require('kraiken-lib'); const myQuery = ` query GetPositions {