From d5f2941602d7c336d68a1a38b433ec8ac451b1cc Mon Sep 17 00:00:00 2001 From: sandybradley Date: Mon, 29 Jul 2024 22:40:27 +0200 Subject: [PATCH 1/4] feat: 14 day cooldown withdraw, deposit min --- src/FoldCaptiveStaking.sol | 24 +++++++++------ test/BaseCaptiveTest.sol | 3 +- test/UnitTests.t.sol | 60 ++++++++++++++++++++++++++++---------- 3 files changed, 62 insertions(+), 25 deletions(-) diff --git a/src/FoldCaptiveStaking.sol b/src/FoldCaptiveStaking.sol index 6af2cfb..855e702 100644 --- a/src/FoldCaptiveStaking.sol +++ b/src/FoldCaptiveStaking.sol @@ -40,8 +40,9 @@ contract FoldCaptiveStaking is Owned(msg.sender) { error NotInitialized(); error ZeroLiquidity(); error WithdrawFailed(); - error WithdrawProRata(); error DepositCapReached(); + error DepositAmountBelowMinimum(); + error WithdrawalCooldownPeriodNotMet(); /// @param _positionManager The Canonical UniswapV3 PositionManager /// @param _pool The FOLD Pool to Reward @@ -138,6 +139,13 @@ contract FoldCaptiveStaking is Owned(msg.sender) { /// @dev The cap on deposits in the pool in liquidity, set to 0 if no cap uint256 public depositCap; + /// @dev Min deposit amount for Fold / Eth + uint256 public constant MINIMUM_DEPOSIT = 1 ether; + /// @dev Min lockup period + uint256 public constant COOLDOWN_PERIOD = 14 days; + + mapping(address => uint256) public depositTimeStamp; + /*////////////////////////////////////////////////////////////// CHEF //////////////////////////////////////////////////////////////*/ @@ -175,6 +183,8 @@ contract FoldCaptiveStaking is Owned(msg.sender) { /// @param amount1 The amount of token1 to deposit /// @param slippage Slippage on deposit out of 1e18 function deposit(uint256 amount0, uint256 amount1, uint256 slippage) external isInitialized { + if (amount0 < MINIMUM_DEPOSIT && amount1 < MINIMUM_DEPOSIT) revert DepositAmountBelowMinimum(); + collectFees(); collectRewards(); @@ -207,6 +217,8 @@ contract FoldCaptiveStaking is Owned(msg.sender) { revert DepositCapReached(); } + depositTimeStamp[msg.sender] = block.timestamp; + emit Deposit(msg.sender, amount0, amount1); } @@ -276,13 +288,11 @@ contract FoldCaptiveStaking is Owned(msg.sender) { /// @notice Withdraws liquidity from the pool /// @param liquidity The amount of liquidity to withdraw function withdraw(uint128 liquidity) external isInitialized { + if (block.timestamp < depositTimeStamp[msg.sender] + COOLDOWN_PERIOD) revert WithdrawalCooldownPeriodNotMet(); + collectFees(); collectRewards(); - if (liquidity > balances[msg.sender].amount / 2) { - revert WithdrawProRata(); - } - balances[msg.sender].amount -= liquidity; liquidityUnderManagement -= uint256(liquidity); @@ -349,10 +359,6 @@ contract FoldCaptiveStaking is Owned(msg.sender) { collectPositionFees(); collectRewards(); - if (liquidity > liquidityUnderManagement / 2) { - revert WithdrawProRata(); - } - liquidityUnderManagement -= uint256(liquidity); INonfungiblePositionManager.DecreaseLiquidityParams memory decreaseParams = INonfungiblePositionManager diff --git a/test/BaseCaptiveTest.sol b/test/BaseCaptiveTest.sol index 8a6a70b..27ea6ee 100644 --- a/test/BaseCaptiveTest.sol +++ b/test/BaseCaptiveTest.sol @@ -11,7 +11,8 @@ contract BaseCaptiveTest is Test { error NotInitialized(); error ZeroLiquidity(); error WithdrawFailed(); - error WithdrawProRata(); + error DepositAmountBelowMinimum(); + error WithdrawalCooldownPeriodNotMet(); FoldCaptiveStaking public foldCaptiveStaking; diff --git a/test/UnitTests.t.sol b/test/UnitTests.t.sol index 0d0b8a8..5a5787e 100644 --- a/test/UnitTests.t.sol +++ b/test/UnitTests.t.sol @@ -29,6 +29,9 @@ contract UnitTests is BaseCaptiveTest { function testRemoveLiquidity() public { testAddLiquidity(); + // Simulate passage of cooldown period + vm.warp(block.timestamp + 14 days); + (uint128 amount, uint128 rewardDebt, uint128 token0FeeDebt, uint128 token1FeeDebt) = foldCaptiveStaking.balances(User01); @@ -212,6 +215,9 @@ contract UnitTests is BaseCaptiveTest { assertEq(rewardDebt, foldCaptiveStaking.rewardsPerLiquidity()); assertGt(weth.balanceOf(User01), initialBalance); + // Simulate passage of cooldown period + vm.warp(block.timestamp + 14 days); + (uint128 liq,,,) = foldCaptiveStaking.balances(User01); foldCaptiveStaking.withdraw(liq / 3); } @@ -235,21 +241,6 @@ contract UnitTests is BaseCaptiveTest { vm.stopPrank(); } - function testProRataWithdrawals() public { - testAddLiquidity(); - - (uint128 liq,,,) = foldCaptiveStaking.balances(User01); - - // Attempt to withdraw more than allowed amount - vm.expectRevert(WithdrawProRata.selector); - foldCaptiveStaking.withdraw(liq); - - // Pro-rated withdrawal - foldCaptiveStaking.withdraw(liq / 2); - (uint128 amount,,,) = foldCaptiveStaking.balances(User01); - assertEq(amount, liq / 2); - } - function testZeroDeposit() public { vm.expectRevert(); foldCaptiveStaking.deposit(0, 0, 0); @@ -268,6 +259,45 @@ contract UnitTests is BaseCaptiveTest { vm.expectRevert(); attack.attack(); } + + function testMinimumDeposit() public { + fold.transfer(User01, 0.5 ether); + + vm.deal(User01, 0.5 ether); + vm.startPrank(User01); + + weth.deposit{value: 0.5 ether}(); + weth.approve(address(foldCaptiveStaking), type(uint256).max); + fold.approve(address(foldCaptiveStaking), type(uint256).max); + + // Expect revert due to minimum deposit requirement + vm.expectRevert(DepositAmountBelowMinimum.selector); + foldCaptiveStaking.deposit(0.5 ether, 0.5 ether, 0); + + vm.stopPrank(); + } + + function testWithdrawalCooldown() public { + testAddLiquidity(); + + vm.startPrank(User01); + + (uint128 liq,,,) = foldCaptiveStaking.balances(User01); + + // Attempt to withdraw before cooldown period + vm.expectRevert(WithdrawalCooldownPeriodNotMet.selector); + foldCaptiveStaking.withdraw(liq / 2); + + // Simulate passage of cooldown period + vm.warp(block.timestamp + 14 days); + + // Withdraw after cooldown period + foldCaptiveStaking.withdraw(liq / 2); + (uint128 amount,,,) = foldCaptiveStaking.balances(User01); + assertEq(amount, liq / 2); + + vm.stopPrank(); + } } // Reentrancy attack contract From 7120d1f76e713b692bb887000cc3b0495aa17be1 Mon Sep 17 00:00:00 2001 From: sam bacha Date: Fri, 9 Aug 2024 05:13:23 -0700 Subject: [PATCH 2/4] fix(unit): testing fixup --- .editorconfig | 87 ++++++++++++++++++++++ .gas-snapshot | 7 ++ foundry.toml | 168 ++++++++++++++++++++++++++++++++++++++++--- test/UnitTests.t.sol | 93 +----------------------- 4 files changed, 254 insertions(+), 101 deletions(-) create mode 100644 .editorconfig create mode 100644 .gas-snapshot diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..61567d3 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,87 @@ +# top-most EditorConfig file +root = true + +# All files +[*] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +trim_trailing_whitespace = true + +# Solidity +# https://github.com/sambacha/prettier-config-solidity +[*.sol] +indent_size = 4 +indent_style = space + +# q +# kdb+ +[*.q] +indent_style = space +indent_size = 2 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true + +# Markdown +[*.{md,adoc,asciidoc}] +charset = utf-8 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = false + +# Match nix files, set indent to spaces with width of two +[*.nix] +indent_style = space +indent_size = 2 + +# JavaScript, JSON, JSX, JavaScript Modules, TypeScript +# https://github.com/feross/standard +# https://prettier.io +[*.{cjs,js,json,jsx,mjs,ts,tsx,mts,cts}] +indent_size = 2 +indent_style = space + +# TOML +# https://github.com/toml-lang/toml/tree/master/examples +[*.toml] +indent_size = 2 +indent_style = space + +# YAML +# http://yaml.org/spec/1.2/2009-07-21/spec.html#id2576668 +[*.{yaml,yml}] +indent_size = 2 +indent_style = space + +# Shell +# https://google.github.io/styleguide/shell.xml#Indentation +[*.{bash,sh,zsh}] +indent_size = 2 +indent_style = space + +# confg + cfg +[*.{conf,cfg}] +charset = UTF-8 +end_of_line = LF +indent_size = 4 +indent_style = tab +insert_final_newline = true +tab_width = 4 +trim_trailing_whitespace = true + +# Match diffs, avoid to trim trailing whitespace +[*.{diff,patch}] +trim_trailing_whitespace = false + +# Ignore fixtures and vendored files +[{dist,artifacts,vendor,test/fixtures,tests_config,__snapshot__,}/**] +charset = unset +end_of_line = unset +indent_size = unset +indent_style = unset +insert_final_newline = unset +trim_trailing_spaces = unset \ No newline at end of file diff --git a/.gas-snapshot b/.gas-snapshot new file mode 100644 index 0000000..eebfdc9 --- /dev/null +++ b/.gas-snapshot @@ -0,0 +1,7 @@ +UnitTests:testAddLiquidity() (gas: 347004) +UnitTests:testCanAddRewards() (gas: 522056) +UnitTests:testCanCompoundFees() (gas: 899427) +UnitTests:testCannotCallbeforeInit() (gas: 2265365) +UnitTests:testFeesAccrue() (gas: 884410) +UnitTests:testNewUsersDontStealFees() (gas: 1145644) +UnitTests:testRemoveLiquidity() (gas: 575956) \ No newline at end of file diff --git a/foundry.toml b/foundry.toml index d0b5421..b58bad4 100644 --- a/foundry.toml +++ b/foundry.toml @@ -3,22 +3,172 @@ solc_version = '0.8.25' src = 'src' out = 'out' libs = ['lib'] + +remappings = [ + "ds-test/=lib/forge-std/lib/ds-test/src/", + "forge-std/=lib/forge-std/src/", + "libsol/=lib/libsol/src/", + "solady/=lib/solady/", + "solmate/=lib/solmate/src/", +] + +# {@see {@link https://solidity-fr.readthedocs.io/fr/latest/using-the-compiler.html#input-description} +# includes the contract's metadata in the contract's json artifact +# includes the source mappings for compiled bytecode artifact +extra_output = ['irOptimized', 'evm.assembly', 'evm.bytecode', 'evm.bytecode.generatedSources'] +# emits the output selection as separate json artifact files +extra_output_files = ['metadata'] +names = false +sizes = false optimizer = true -optimizer_runs = 10_000_000 -# @see {@link https://github.com/foundry-rs/foundry/issues/4060} +optimizer_runs = 1_000 +via_ir = true +# {@see {@link https://github.com/foundry-rs/foundry/issues/4060} } +auto_detect_remappings = false +# Whether to store the referenced sources in the metadata as literal data. Helps with verification +use_literal_content = true +# The metadata hash is machine dependent. By default, this is set to none to allow for deterministic code. +# {@see {@link https://docs.soliditylang.org/en/latest/metadata.html} } bytecode_hash = "none" cbor_metadata = false -sparse_mode = false -build_info = true +# Only the required contracts/files will be selected to be included in solc's output selection. +sparse_mode = true +ast = false +isolate = false +create2_library_salt = "0x0000000000000000000000000000000000000000000000000000000000000000" +prague = false +unchecked_cheatcode_artifacts = false -via_ir = true -fuzz_runs = 500 -deny_warnings = false +[profile.ci] +optimizer = true +via_ir = false +fuzz_runs = 4_069 +force = true +verbosity = 4 +gas_reports = ["*"] +revert_strings = 'debug' +extra_output = [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", +] +# Environment: FOUNDRY_PROMPT_TIMEOUT +# The number of seconds to wait before vm.prompt reverts with a timeout. +# default = 120 +prompt_timeout = 30 +seed = '0x6900000000000000000000000000000000000000000000000000000000000000' +cache = true +cache_path = '.cache' + +show_progress = false +unchecked_cheatcode_artifacts = false + + +[[profile.default.fs_permissions]] +access = "read" +path = "out" + +[profile.default.rpc_storage_caching] +chains = "all" +endpoints = "all" + +[fmt] +# default 120 +line_length = 100 +# default 4 +tab_width = 2 +bracket_spacing = false +int_types = "long" +multiline_func_header = "attributes_first" +quote_style = "double" +number_underscore = "thousands" +single_line_statement_blocks = "preserve" +override_spacing = false +wrap_comments = true +ignore = ['*.mutant.sol', '*.vendor.sol'] +contract_new_lines = false +# import statements are sorted alphabetically within their import groups. +# while preserving the relative ordering of the groups. +sort_imports = false + +[doc] +out = "docs" +title = "" +book = "book.toml" +ignore = [] + +[profile.docs] +title = 'Protocol docs' +# root_path variable in build-docs.sh +src = 'src' + +[fuzz] +fuzz_seed = '0x3e8' +# The number of fuzz runs for fuzz tests +runs = 10_000 +# The maximum number of test case rejections allowed by proptest, to be +# encountered during usage of `vm.assume` cheatcode. This will be used +# to set the `max_global_rejects` value in proptest test runner config. +# `max_local_rejects` option isn't exposed here since we're not using +# `prop_filter`. +max_test_rejects = 120000 +# The weight of the dictionary +dictionary_weight = 40 +# The flag indicating whether to include values from storage +include_storage = true +# The flag indicating whether to include push bytes values +include_push_bytes = true +max_fuzz_dictionary_addresses = 15728640 +max_fuzz_dictionary_values = 6553600 +max_calldata_fuzz_dictionary_addresses = 0 +gas_report_samples = 256 +failure_persist_dir = "cache/fuzz" +failure_persist_file = "failures" + +[invariant] +# The number of runs that must execute for each invariant test group +runs = 256 +# The number of calls executed to attempt to break invariants in one run +depth = 500 +# Fails the invariant fuzzing if a revert occurs +fail_on_revert = false +# Allows overriding an unsafe external call when running invariant tests. eg. reentrancy checks +call_override = false +# The weight of the dictionary +dictionary_weight = 80 +# The flag indicating whether to include values from storage +include_storage = true +# The flag indicating whether to include push bytes values +include_push_bytes = true +max_fuzz_dictionary_addresses = 15728640 +max_fuzz_dictionary_values = 6553600 +max_calldata_fuzz_dictionary_addresses = 0 +shrink_sequence = true +# run limit max: 262144 +shrink_run_limit = 5000 +preserve_state = false +max_assume_rejects = 65536 +gas_report_samples = 256 +failure_persist_dir = "cache/invariant" [profile.default.optimizer_details] -constantOptimizer = true +# constantOptimizer = true yul = true - +# this sets the `yulDetails` of the `optimizer_details` for the `default` profile [profile.default.optimizer_details.yulDetails] stackAllocation = true +# ACHTUNG! Setting this is extremely dangerous +# {@see {@link https://soliditylang.org/blog/2023/07/19/full-inliner-non-expression-split-argument-evaluation-order-bug/} } +# optimizerSteps = 'u:' + +# [default.model_checker] +# contracts = { '/path/to/project/src/Contract.sol' = [ 'Contract' ] } +# engine = 'chc' +# timeout = 10000 +# targets = [ 'assert' ] +[bind_json] +out = "utils/JsonBindings.sol" +include = [] +exclude = [] \ No newline at end of file diff --git a/test/UnitTests.t.sol b/test/UnitTests.t.sol index 28a417c..936718d 100644 --- a/test/UnitTests.t.sol +++ b/test/UnitTests.t.sol @@ -6,7 +6,6 @@ import "test/interfaces/ISwapRouter.sol"; contract UnitTests is BaseCaptiveTest { ISwapRouter public router = ISwapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564); - /// @dev Ensure that balances and state variables are updated correctly. function testAddLiquidity() public { fold.transfer(User01, 1_000 ether); @@ -27,7 +26,6 @@ contract UnitTests is BaseCaptiveTest { assertEq(token1FeeDebt, 0); } - /// @dev Ensure that balances and state variables are updated correctly. function testRemoveLiquidity() public { testAddLiquidity(); @@ -54,7 +52,6 @@ contract UnitTests is BaseCaptiveTest { assertEq(amount, liq / 4); } - /// @dev Ensure fees are accrued correctly and distributed proportionately. function testFeesAccrue() public { testAddLiquidity(); @@ -103,7 +100,6 @@ contract UnitTests is BaseCaptiveTest { assertGt(foldCaptiveStaking.token1FeesPerLiquidity(), 0); } - /// @dev Ensure fees are compounded correctly and state variables are updated. function testCanCompoundFees() public { testAddLiquidity(); @@ -151,7 +147,6 @@ contract UnitTests is BaseCaptiveTest { assertGt(newAmount, amount); } - /// @dev Ensure new users can't steal fees accrued by others. function testNewUsersDontStealFees() public { testFeesAccrue(); @@ -199,7 +194,6 @@ contract UnitTests is BaseCaptiveTest { stakingTwo.depositRewards(); } - /// @dev Ensure rewards are added and collected correctly. function testCanAddRewards() public { testAddLiquidity(); @@ -228,7 +222,6 @@ contract UnitTests is BaseCaptiveTest { foldCaptiveStaking.withdraw(liq / 3); } - /// @dev Ensure the owner can claim insurance correctly. function testClaimInsurance() public { testAddLiquidity(); @@ -248,23 +241,6 @@ contract UnitTests is BaseCaptiveTest { vm.stopPrank(); } - /// @dev Ensure pro-rata withdrawals are handled correctly - function testProRataWithdrawals() public { - testAddLiquidity(); - - (uint128 liq,,,) = foldCaptiveStaking.balances(User01); - - // Attempt to withdraw more than allowed amount - vm.expectRevert(WithdrawProRata.selector); - foldCaptiveStaking.withdraw(liq); - - // Pro-rated withdrawal - foldCaptiveStaking.withdraw(liq / 2); - (uint128 amount,,,) = foldCaptiveStaking.balances(User01); - assertEq(amount, liq / 2); - } - - /// @dev Ensure zero deposits are handled correctly and revert as expected. function testZeroDeposit() public { vm.expectRevert(); foldCaptiveStaking.deposit(0, 0, 0); @@ -272,7 +248,6 @@ contract UnitTests is BaseCaptiveTest { assertEq(amount, 0); } - /// @dev Ensure the contract is protected against reentrancy attacks. function testReentrancy() public { testAddLiquidity(); @@ -298,26 +273,6 @@ contract UnitTests is BaseCaptiveTest { // Expect revert due to minimum deposit requirement vm.expectRevert(DepositAmountBelowMinimum.selector); foldCaptiveStaking.deposit(0.5 ether, 0.5 ether, 0); - /// @dev Deposit Cap Enforcement: Test to ensure the deposit cap is respected. - function testDepositCap() public { - uint256 cap = 100 ether; - foldCaptiveStaking.setDepositCap(cap); - - fold.transfer(User01, 2000 ether); - - vm.deal(User01, 2000 ether); - vm.startPrank(User01); - - weth.deposit{value: 2000 ether}(); - weth.approve(address(foldCaptiveStaking), type(uint256).max); - fold.approve(address(foldCaptiveStaking), type(uint256).max); - - // First deposit should succeed - foldCaptiveStaking.deposit(1_000 ether, 1_000 ether, 0); - - // Second deposit should revert due to cap - vm.expectRevert(DepositCapReached.selector); - foldCaptiveStaking.deposit(1_000 ether, 1_000 ether, 0); vm.stopPrank(); } @@ -339,52 +294,6 @@ contract UnitTests is BaseCaptiveTest { // Withdraw after cooldown period foldCaptiveStaking.withdraw(liq / 2); (uint128 amount,,,) = foldCaptiveStaking.balances(User01); - /// @dev Multiple Users: Test simultaneous deposits and withdrawals by multiple users. - function testMultipleUsersDepositWithdraw() public { - // User 1 deposits - fold.transfer(User01, 1_000 ether); - vm.deal(User01, 1_000 ether); - vm.startPrank(User01); - - weth.deposit{value: 1_000 ether}(); - weth.approve(address(foldCaptiveStaking), type(uint256).max); - fold.approve(address(foldCaptiveStaking), type(uint256).max); - - foldCaptiveStaking.deposit(1_000 ether, 1_000 ether, 0); - - vm.stopPrank(); - - // User 2 deposits - fold.transfer(User02, 500 ether); - vm.deal(User02, 500 ether); - vm.startPrank(User02); - - weth.deposit{value: 500 ether}(); - weth.approve(address(foldCaptiveStaking), type(uint256).max); - fold.approve(address(foldCaptiveStaking), type(uint256).max); - - foldCaptiveStaking.deposit(500 ether, 500 ether, 0); - - vm.stopPrank(); - - // User 1 withdraws - vm.startPrank(User01); - - (uint128 liq,,,) = foldCaptiveStaking.balances(User01); - foldCaptiveStaking.withdraw(liq / 2); - - (uint128 amount,,,) = foldCaptiveStaking.balances(User01); - assertEq(amount, liq / 2); - - vm.stopPrank(); - - // User 2 withdraws - vm.startPrank(User02); - - (liq,,,) = foldCaptiveStaking.balances(User02); - foldCaptiveStaking.withdraw(liq / 2); - - (amount,,,) = foldCaptiveStaking.balances(User02); assertEq(amount, liq / 2); vm.stopPrank(); @@ -407,4 +316,4 @@ contract ReentrancyAttack { receive() external payable { staking.withdraw(1); } -} +} \ No newline at end of file From 39d54af1fb75f152b41c0d25d387acb12782ec9c Mon Sep 17 00:00:00 2001 From: sam bacha Date: Fri, 9 Aug 2024 05:38:58 -0700 Subject: [PATCH 3/4] test(solidity): upgrade pragma --- .gitmodules | 3 + foundry.toml | 4 +- lib/solady | 1 + src/FOLD_StakingV2.sol | 401 ++++++++++++++++++++++++++++++ src/FoldCaptiveStaking.sol | 2 +- src/interfaces/IERC20.sol | 76 ++++++ test/BaseCaptiveTest.sol | 2 +- test/FoldCaptiveStakingTest.t.sol | 78 ++++++ test/UnitTests.t.sol | 3 +- test/mock/MockERC20.sol | 2 +- 10 files changed, 566 insertions(+), 6 deletions(-) create mode 160000 lib/solady create mode 100644 src/FOLD_StakingV2.sol create mode 100644 src/interfaces/IERC20.sol create mode 100644 test/FoldCaptiveStakingTest.t.sol diff --git a/.gitmodules b/.gitmodules index 5aadf12..bff4240 100644 --- a/.gitmodules +++ b/.gitmodules @@ -10,3 +10,6 @@ [submodule "lib/v3-periphery"] path = lib/v3-periphery url = https://github.com/uniswap/v3-periphery +[submodule "lib/solady"] + path = lib/solady + url = https://github.com/Vectorized/solady diff --git a/foundry.toml b/foundry.toml index b58bad4..408ccf0 100644 --- a/foundry.toml +++ b/foundry.toml @@ -1,5 +1,5 @@ [profile.default] -solc_version = '0.8.25' +solc_version = '0.8.26' src = 'src' out = 'out' libs = ['lib'] @@ -160,7 +160,7 @@ yul = true stackAllocation = true # ACHTUNG! Setting this is extremely dangerous # {@see {@link https://soliditylang.org/blog/2023/07/19/full-inliner-non-expression-split-argument-evaluation-order-bug/} } -# optimizerSteps = 'u:' +optimizerSteps = 'jmul[jul] VcTOcul jmul' # [default.model_checker] # contracts = { '/path/to/project/src/Contract.sol' = [ 'Contract' ] } diff --git a/lib/solady b/lib/solady new file mode 160000 index 0000000..11c27fa --- /dev/null +++ b/lib/solady @@ -0,0 +1 @@ +Subproject commit 11c27fab5233fae1456ee95d5a6ad06be8bd32c8 diff --git a/src/FOLD_StakingV2.sol b/src/FOLD_StakingV2.sol new file mode 100644 index 0000000..1c5fa67 --- /dev/null +++ b/src/FOLD_StakingV2.sol @@ -0,0 +1,401 @@ +/// SPDX-License-Identifier: SSPL-1.0 +pragma solidity 0.8.26; + +// Authorization and Authentication + +import {Owned} from "lib/solmate/src/auth/Owned.sol"; + +/// contracts +import {WETH} from "lib/solady/src/tokens/WETH.sol"; +import {ERC20} from "lib/solady/src/tokens/ERC20.sol"; + + +/// Interfaces +import {INonfungiblePositionManager} from "./interfaces/INonfungiblePositionManager.sol"; +import {IUniswapV3MintCallback} from "./interfaces/IUniswapV3MintCallback.sol"; +import {IUniswapV3Factory} from "./interfaces/IUniswapV3Factory.sol"; +import {IUniswapV3Pool} from "./interfaces/IUniswapV3Pool.sol"; + +/// Libraries +import {TickMath} from "./libraries/TickMath.sol"; + + + + + +/// @author CopyPaste +/// @title FoldCaptiveStakingV2 +/// @notice Staking contract for managing FOLD token liquidity on Uniswap V3 +contract FoldCaptiveStakingV2 is Owned(msg.sender) { + /*////////////////////////////////////////////////////////////// + INITIALIZATION + //////////////////////////////////////////////////////////////*/ + bool public initialized; + + // Events + event Initialized(); + event Deposit(address indexed user, uint256 amount0, uint256 amount1); + event Withdraw(address indexed user, uint128 liquidity); + event RewardsDeposited(uint256 amount); + event FeesCollected(address indexed user, uint256 fee0Owed, uint256 fee1Owed); + event RewardsCollected(address indexed user, uint256 rewardsOwed); + event Compounded(address indexed user, uint128 liquidity, uint256 fee0Owed, uint256 fee1Owed); + event InsuranceClaimed(address indexed owner, uint256 amount0, uint256 amount1); + + /// Custom Errors + error ZeroAddress(); + error AlreadyInitialized(); + error NotInitialized(); + error ZeroLiquidity(); + error WithdrawFailed(); + error DepositCapReached(); + error DepositAmountBelowMinimum(); + error WithdrawalCooldownPeriodNotMet(); + + /// @param _positionManager The Canonical UniswapV3 PositionManager + /// @param _pool The FOLD Pool to Reward + /// @param _weth The address of WETH on the deployed chain + /// @param _fold The address of Fold on the deployed chain + constructor(address _positionManager, address _pool, address _weth, address _fold) { + if (_positionManager == address(0) || _pool == address(0) || _weth == address(0) || _fold == address(0)) { + revert ZeroAddress(); + } + + positionManager = INonfungiblePositionManager(_positionManager); + POOL = IUniswapV3Pool(_pool); + + token0 = ERC20(POOL.token0()); + token1 = ERC20(POOL.token1()); + + WETH9 = WETH(payable(_weth)); + FOLD = ERC20(_fold); + + initialized = false; + } + + /// @notice Initialize the contract by minting a small initial liquidity position + function initialize() public onlyOwner { + if (initialized) { + revert AlreadyInitialized(); + } + + // We must mint the pool a small dust LP position, which also prevents share attacks + // So this is our "minimum shares" + INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({ + token0: address(token0), + token1: address(token1), + fee: 10000, + tickLower: -887_200, + tickUpper: 887_200, + amount0Desired: 1_000_000, + amount1Desired: 1_000_000, + amount0Min: 0, + amount1Min: 0, + recipient: address(this), + deadline: block.timestamp + 1 minutes + }); + + token0.approve(address(positionManager), type(uint256).max); + token1.approve(address(positionManager), type(uint256).max); + + uint128 liquidity; + (TOKEN_ID, liquidity,,) = positionManager.mint(params); + if (liquidity == 0) { + revert ZeroLiquidity(); + } + + liquidityUnderManagement += uint256(liquidity); + + initialized = true; + emit Initialized(); + } + + modifier isInitialized() { + if (!initialized) { + revert NotInitialized(); + } + _; + } + + /*////////////////////////////////////////////////////////////// + STORAGE + //////////////////////////////////////////////////////////////*/ + + /// @dev The max Tick of the position + int24 public constant TICK_UPPER = TickMath.MAX_TICK; + /// @dev The lower Tick of the position + int24 public constant TICK_LOWER = TickMath.MIN_TICK; + /// @dev The Canonical UniswapV3 Position Manager + INonfungiblePositionManager public immutable positionManager; + /// @dev The FOLD <> {WETH, USDC} Liquidity Pool + IUniswapV3Pool public immutable POOL; + /// @dev token0 In terms of the Uniswap Pool + ERC20 public immutable token0; + /// @dev token1 in terms of the Uniswap Pool + ERC20 public immutable token1; + /// @dev The tokenId of the UniswapV3 position + uint256 public TOKEN_ID; + /// @dev Used for all rewards related tracking + uint256 public liquidityUnderManagement; + /// @dev Used to keep track of rewards given per share + uint256 public rewardsPerLiquidity; + /// @dev For keeping track of position fees + uint256 public token0FeesPerLiquidity; + /// @dev For keeping track of positions fees + uint256 public token1FeesPerLiquidity; + + /// @dev The cap on deposits in the pool in liquidity, set to 0 if no cap + uint256 public depositCap; + + /// @dev Min deposit amount for Fold / Eth + uint256 public constant MINIMUM_DEPOSIT = 1 ether; + /// @dev Min lockup period + uint256 public constant COOLDOWN_PERIOD = 14 days; + + mapping(address => uint256) public depositTimeStamp; + + /*////////////////////////////////////////////////////////////// + CHEF + //////////////////////////////////////////////////////////////*/ + + struct UserInfo { + uint128 amount; // How much Liquidity provided by the User, as defined by UniswapV3. + uint128 rewardDebt; // Reward debt. As in the Masterchef Sense + uint128 token0FeeDebt; + uint128 token1FeeDebt; + } + + mapping(address user => UserInfo info) public balances; + + /// @dev The Canonical WETH address + WETH public immutable WETH9; + ERC20 public immutable FOLD; + + /// @notice Allows anyone to add funds to the contract, split among all depositors + function depositRewards() public payable isInitialized { + WETH9.deposit{value: msg.value}(); + rewardsPerLiquidity += msg.value; + emit RewardsDeposited(msg.value); + } + + receive() external payable { + depositRewards(); + } + + /*////////////////////////////////////////////////////////////// + MANAGEMENT + //////////////////////////////////////////////////////////////*/ + + /// @notice Allows a user to deposit liquidity into the pool + /// @param amount0 The amount of token0 to deposit + /// @param amount1 The amount of token1 to deposit + /// @param slippage Slippage on deposit out of 1e18 + function deposit(uint256 amount0, uint256 amount1, uint256 slippage) external isInitialized { + if (amount0 < MINIMUM_DEPOSIT && amount1 < MINIMUM_DEPOSIT) revert DepositAmountBelowMinimum(); + + collectFees(); + collectRewards(); + + INonfungiblePositionManager.IncreaseLiquidityParams memory params = INonfungiblePositionManager + .IncreaseLiquidityParams({ + tokenId: TOKEN_ID, + amount0Desired: amount0, + amount1Desired: amount1, + amount0Min: amount0 * slippage / 1 ether, + amount1Min: amount1 * slippage / 1 ether, + deadline: block.timestamp + 1 minutes + }); + + token0.transferFrom(msg.sender, address(this), amount0); + token1.transferFrom(msg.sender, address(this), amount1); + + (uint128 liquidity, uint256 actualAmount0, uint256 actualAmount1) = positionManager.increaseLiquidity(params); + + if (actualAmount0 < amount0) { + token0.transfer(msg.sender, amount0 - actualAmount0); + } + if (actualAmount1 < amount1) { + token1.transfer(msg.sender, amount1 - actualAmount1); + } + + balances[msg.sender].amount += liquidity; + liquidityUnderManagement += uint256(liquidity); + + if (liquidityUnderManagement > depositCap && depositCap != 0) { + revert DepositCapReached(); + } + + depositTimeStamp[msg.sender] = block.timestamp; + + emit Deposit(msg.sender, amount0, amount1); + } + + /// @notice Compounds User Earned Fees back into their position + function compound() public isInitialized { + collectPositionFees(); + + uint256 fee0Owed = (token0FeesPerLiquidity - balances[msg.sender].token0FeeDebt) * balances[msg.sender].amount + / liquidityUnderManagement; + uint256 fee1Owed = (token1FeesPerLiquidity - balances[msg.sender].token1FeeDebt) * balances[msg.sender].amount + / liquidityUnderManagement; + + INonfungiblePositionManager.IncreaseLiquidityParams memory params = INonfungiblePositionManager + .IncreaseLiquidityParams({ + tokenId: TOKEN_ID, + amount0Desired: fee0Owed, + amount1Desired: fee1Owed, + amount0Min: 0, + amount1Min: 0, + deadline: block.timestamp + 1 minutes + }); + + (uint128 liquidity, uint256 actualAmount0, uint256 actualAmount1) = positionManager.increaseLiquidity(params); + + token0.transfer(msg.sender, fee0Owed - actualAmount0); + token1.transfer(msg.sender, fee1Owed - actualAmount1); + + balances[msg.sender].token0FeeDebt = uint128(token0FeesPerLiquidity); + balances[msg.sender].token1FeeDebt = uint128(token1FeesPerLiquidity); + + balances[msg.sender].amount += liquidity; + liquidityUnderManagement += uint256(liquidity); + + emit Compounded(msg.sender, liquidity, fee0Owed, fee1Owed); + } + + /// @notice User-specific function to collect fees on the singular position + function collectFees() public isInitialized { + collectPositionFees(); + + uint256 fee0Owed = (token0FeesPerLiquidity - balances[msg.sender].token0FeeDebt) * balances[msg.sender].amount + / liquidityUnderManagement; + uint256 fee1Owed = (token1FeesPerLiquidity - balances[msg.sender].token1FeeDebt) * balances[msg.sender].amount + / liquidityUnderManagement; + + token0.transfer(msg.sender, fee0Owed); + token1.transfer(msg.sender, fee1Owed); + + balances[msg.sender].token0FeeDebt = uint128(token0FeesPerLiquidity); + balances[msg.sender].token1FeeDebt = uint128(token1FeesPerLiquidity); + + emit FeesCollected(msg.sender, fee0Owed, fee1Owed); + } + + /// @notice User-specific Rewards for Protocol Rewards + function collectRewards() public isInitialized { + uint256 rewardsOwed = (rewardsPerLiquidity - balances[msg.sender].rewardDebt) * balances[msg.sender].amount + / liquidityUnderManagement; + + WETH9.transfer(msg.sender, rewardsOwed); + + balances[msg.sender].rewardDebt = uint128(rewardsPerLiquidity); + + emit RewardsCollected(msg.sender, rewardsOwed); + } + + /// @notice Withdraws liquidity from the pool + /// @param liquidity The amount of liquidity to withdraw + function withdraw(uint128 liquidity) external isInitialized { + if (block.timestamp < depositTimeStamp[msg.sender] + COOLDOWN_PERIOD) revert WithdrawalCooldownPeriodNotMet(); + + collectFees(); + collectRewards(); + + balances[msg.sender].amount -= liquidity; + liquidityUnderManagement -= uint256(liquidity); + + INonfungiblePositionManager.DecreaseLiquidityParams memory decreaseParams = INonfungiblePositionManager + .DecreaseLiquidityParams({ + tokenId: TOKEN_ID, + liquidity: liquidity, + amount0Min: 0, + amount1Min: 0, + deadline: block.timestamp + 1 minutes + }); + + (uint256 amount0, uint256 amount1) = positionManager.decreaseLiquidity(decreaseParams); + + INonfungiblePositionManager.CollectParams memory collectParams = INonfungiblePositionManager.CollectParams({ + tokenId: TOKEN_ID, + recipient: address(this), + amount0Max: uint128(amount0), + amount1Max: uint128(amount1) + }); + + (uint256 amount0Collected, uint256 amount1Collected) = positionManager.collect(collectParams); + + if (amount0Collected != amount0 || amount1Collected != amount1) { + revert WithdrawFailed(); + } + + token0.transfer(msg.sender, amount0); + token1.transfer(msg.sender, amount1); + + emit Withdraw(msg.sender, liquidity); + } + + /*////////////////////////////////////////////////////////////// + INTERNAL HELPERS + //////////////////////////////////////////////////////////////*/ + + /// @notice Collects fees on the underling UniswapV3 Position + function collectPositionFees() internal { + INonfungiblePositionManager.CollectParams memory params = INonfungiblePositionManager.CollectParams({ + tokenId: TOKEN_ID, + recipient: address(this), + amount0Max: type(uint128).max, + amount1Max: type(uint128).max + }); + + (uint256 amount0Collected, uint256 amount1Collected) = positionManager.collect(params); + + token0FeesPerLiquidity += amount0Collected; + token1FeesPerLiquidity += amount1Collected; + } + + /*////////////////////////////////////////////////////////////// + OWNER CONTROLS + //////////////////////////////////////////////////////////////*/ + /// @param _newCap The new deposit cap, measured in liquidity + function setDepositCap(uint256 _newCap) public onlyOwner { + depositCap = _newCap; + } + + /// @notice Allows the owner to claim insurance in case of relay outage + /// @param liquidity The amount of liquidity to claim + function claimInsurance(uint128 liquidity) external onlyOwner { + collectPositionFees(); + collectRewards(); + + liquidityUnderManagement -= uint256(liquidity); + + INonfungiblePositionManager.DecreaseLiquidityParams memory decreaseParams = INonfungiblePositionManager + .DecreaseLiquidityParams({ + tokenId: TOKEN_ID, + liquidity: liquidity, + amount0Min: 0, + amount1Min: 0, + deadline: block.timestamp + 1 minutes + }); + + (uint256 amount0, uint256 amount1) = positionManager.decreaseLiquidity(decreaseParams); + + INonfungiblePositionManager.CollectParams memory collectParams = INonfungiblePositionManager.CollectParams({ + tokenId: TOKEN_ID, + recipient: address(this), + amount0Max: uint128(amount0), + amount1Max: uint128(amount1) + }); + + (uint256 amount0Collected, uint256 amount1Collected) = positionManager.collect(collectParams); + + if (amount0Collected != amount0 || amount1Collected != amount1) { + revert WithdrawFailed(); + } + + token0.transfer(owner, amount0); + token1.transfer(owner, amount1); + + emit InsuranceClaimed(owner, amount0, amount1); + } +} diff --git a/src/FoldCaptiveStaking.sol b/src/FoldCaptiveStaking.sol index 855e702..c7f5902 100644 --- a/src/FoldCaptiveStaking.sol +++ b/src/FoldCaptiveStaking.sol @@ -1,5 +1,5 @@ /// SPDX-License-Identifier: SSPL-1.0 -pragma solidity 0.8.25; +pragma solidity ^0.8.26; /// Interfaces import {INonfungiblePositionManager} from "./interfaces/INonfungiblePositionManager.sol"; diff --git a/src/interfaces/IERC20.sol b/src/interfaces/IERC20.sol new file mode 100644 index 0000000..568e503 --- /dev/null +++ b/src/interfaces/IERC20.sol @@ -0,0 +1,76 @@ +pragma solidity ^0.8.20; + +/** + * @dev Interface of the ERC-20 standard as defined in the ERC. + */ +interface IERC20 { + /** + * @dev Emitted when `value` tokens are moved from one account (`from`) to + * another (`to`). + * + * Note that `value` may be zero. + */ + event Transfer(address indexed from, address indexed to, uint256 value); + + /** + * @dev Emitted when the allowance of a `spender` for an `owner` is set by + * a call to {approve}. `value` is the new allowance. + */ + event Approval(address indexed owner, address indexed spender, uint256 value); + + /** + * @dev Returns the value of tokens in existence. + */ + function totalSupply() external view returns (uint256); + + /** + * @dev Returns the value of tokens owned by `account`. + */ + function balanceOf(address account) external view returns (uint256); + + /** + * @dev Moves a `value` amount of tokens from the caller's account to `to`. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transfer(address to, uint256 value) external returns (bool); + + /** + * @dev Returns the remaining number of tokens that `spender` will be + * allowed to spend on behalf of `owner` through {transferFrom}. This is + * zero by default. + * + * This value changes when {approve} or {transferFrom} are called. + */ + function allowance(address owner, address spender) external view returns (uint256); + + /** + * @dev Sets a `value` amount of tokens as the allowance of `spender` over the + * caller's tokens. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * IMPORTANT: Beware that changing an allowance with this method brings the risk + * that someone may use both the old and the new allowance by unfortunate + * transaction ordering. One possible solution to mitigate this race + * condition is to first reduce the spender's allowance to 0 and set the + * desired value afterwards: + * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + * + * Emits an {Approval} event. + */ + function approve(address spender, uint256 value) external returns (bool); + + /** + * @dev Moves a `value` amount of tokens from `from` to `to` using the + * allowance mechanism. `value` is then deducted from the caller's + * allowance. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transferFrom(address from, address to, uint256 value) external returns (bool); +} \ No newline at end of file diff --git a/test/BaseCaptiveTest.sol b/test/BaseCaptiveTest.sol index 2892a66..e2aa818 100644 --- a/test/BaseCaptiveTest.sol +++ b/test/BaseCaptiveTest.sol @@ -1,5 +1,5 @@ /// SPDX-License-Identifier: SSPL-1.-0 -pragma solidity 0.8.25; +pragma solidity ^0.8.26; import "src/FoldCaptiveStaking.sol"; import {Test} from "forge-std/Test.sol"; diff --git a/test/FoldCaptiveStakingTest.t.sol b/test/FoldCaptiveStakingTest.t.sol new file mode 100644 index 0000000..b93eb64 --- /dev/null +++ b/test/FoldCaptiveStakingTest.t.sol @@ -0,0 +1,78 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import "forge-std/Test.sol"; +import "../src/FoldCaptiveStaking.sol"; +import {ERC20} from "lib/solmate/src/tokens/ERC20.sol"; +import {IERC20} from "../src/interfaces/IERC20.sol"; +import {INonfungiblePositionManager} from "../src/interfaces/INonfungiblePositionManager.sol"; + +contract FoldCaptiveStakingTest is Test { + FoldCaptiveStaking public staking; + IERC20 public token0; + IERC20 public token1; + INonfungiblePositionManager public positionManager; + + address public owner = address(1); + + function setUp() public { + vm.startPrank(owner); + token0 = IERC20(address(new ERC20Mock())); + token1 = IERC20(address(new ERC20Mock())); + positionManager = INonfungiblePositionManager(address(new PositionManagerMock())); + staking = new FoldCaptiveStaking(address(token0), address(token1), address(positionManager), owner); + vm.stopPrank(); + } + + function testInitialize() public { + vm.startPrank(owner); + staking.initialize(); + assertTrue(staking.initialized()); + assertEq(staking.TOKEN_ID(), 1); + assertGt(staking.liquidityUnderManagement(), 0); + vm.stopPrank(); + } + + function testInitializeRevertOnSecondCall() public { + vm.startPrank(owner); + staking.initialize(); + vm.expectRevert(FoldCaptiveStaking.AlreadyInitialized.selector); + staking.initialize(); + vm.stopPrank(); + } + + function testInitializeRevertOnZeroLiquidity() public { + vm.startPrank(owner); + PositionManagerMock(address(positionManager)).setMintLiquidity(0); + vm.expectRevert(FoldCaptiveStaking.ZeroLiquidity.selector); + staking.initialize(); + vm.stopPrank(); + } + + function testInitializeOnlyOwner() public { + vm.prank(address(2)); + vm.expectRevert("Ownable: caller is not the owner"); + staking.initialize(); + } +} + +contract ERC20Mock is ERC20 { + constructor() ERC20("Mock Token", "MTK", 18) { + _mint(msg.sender, 1000000 * 10**uint256(decimals)); + } +} + +contract PositionManagerMock { + uint256 public tokenIdCounter = 1; + uint128 public liquidityToMint = 1000; + + function mint(INonfungiblePositionManager.MintParams memory) external returns (uint256 tokenId, uint128 liquidity, uint256, uint256) { + tokenId = tokenIdCounter++; + liquidity = liquidityToMint; + return (tokenId, liquidity, 0, 0); + } + + function setMintLiquidity(uint128 _liquidity) external { + liquidityToMint = _liquidity; + } +} diff --git a/test/UnitTests.t.sol b/test/UnitTests.t.sol index 936718d..8bb65e5 100644 --- a/test/UnitTests.t.sol +++ b/test/UnitTests.t.sol @@ -1,4 +1,5 @@ -pragma solidity 0.8.25; +// SPDX-License-Identifier: UNLICESED +pragma solidity ^0.8.25; import "test/BaseCaptiveTest.sol"; import "test/interfaces/ISwapRouter.sol"; diff --git a/test/mock/MockERC20.sol b/test/mock/MockERC20.sol index 2aaa5a1..ea7a2bb 100644 --- a/test/mock/MockERC20.sol +++ b/test/mock/MockERC20.sol @@ -1,5 +1,5 @@ /// SPDX-License-Identifier: SSPL-1.-0 -pragma solidity 0.8.25; +pragma solidity ^0.8.26; import {ERC20} from "lib/solmate/src/tokens/ERC20.sol"; From 677fa8d741b07aa9b89ead30568929f516bca5b2 Mon Sep 17 00:00:00 2001 From: sam bacha Date: Fri, 9 Aug 2024 06:17:59 -0700 Subject: [PATCH 4/4] ci(workflows): add slither and rpc fork testing --- .github/workflows/test.yml | 93 +++++++++++++++++++++++++++++-- .vscode/extensions.json | 9 +++ foundry.toml | 6 +- slither.db.json | 1 + test/FoldCaptiveStakingTest.t.sol | 78 -------------------------- 5 files changed, 104 insertions(+), 83 deletions(-) create mode 100644 .vscode/extensions.json create mode 100644 slither.db.json delete mode 100644 test/FoldCaptiveStakingTest.t.sol diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 9ef660d..c169bb4 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,17 +1,27 @@ name: test -on: push +on: + push: + paths: + - "**.sol" + - "**.toml" + - "**.json" + pull_request: + types: [opened, reopened, synchronize, ready_for_review] + # On-demand + workflow_dispatch: {} + -env: - FOUNDRY_PROFILE: ci jobs: check: strategy: fail-fast: true + matrix: + os: [ubuntu-latest] name: Foundry project - runs-on: ubuntu-latest + runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v4 with: @@ -32,3 +42,78 @@ jobs: run: | forge test -vvv id: test + + - name: Run Forge snapshot + run: forge snapshot + id: snapshot + + - name: Run Forge coverage + run: forge coverage --report lcov + id: coverage + + - name: Run Gas report + run: forge test --gas-report --isolate + id: gas-report + + - name: Run Forge Snapshot Diff + run: forge snapshot --diff + id: snapshot_diff + + - name: Run Slither + uses: crytic/slither-action@v0.4.0 + id: slither + with: + slither-args: --compile-force-framework foundry --exclude-dependencies --checklist + sarif: results.sarif + fail-on: none + + - name: Upload SARIF file + uses: github/codeql-action/upload-sarif@v3 + with: + sarif_file: ${{ steps.slither.outputs.sarif }} + + fork: + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest] + + name: Foundry project + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v4 + with: + submodules: false + + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + with: + version: nightly + + - name: Run Forge build + run: | + forge --version + forge install + forge build --sizes + id: build + + - name: Run Forge tests + run: | + forge test -vvv --rpc-url phalcon + id: test + + - name: Run Forge snapshot + run: forge snapshot --rpc-url phalcon + id: snapshot + + - name: Run Forge coverage + run: forge coverage --report lcov --rpc-url phalcon + id: coverage + + - name: Run Gas report + run: forge test --gas-report --isolate --rpc-url phalcon + id: gas-report + + - name: Run Forge Snapshot Diff + run: forge snapshot --diff --rpc-url phalcon + id: snapshot_diff \ No newline at end of file diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..8ed73a1 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,9 @@ +{ + "recommendations": [ + "trailofbits.sarif-explorer", + "usernamehw.errorlens", + "alefragnani.separators", + "nomicfoundation.hardhat-solidity", + "tintinweb.solidity-visual-auditor" + ] +} \ No newline at end of file diff --git a/foundry.toml b/foundry.toml index 408ccf0..fc8189a 100644 --- a/foundry.toml +++ b/foundry.toml @@ -171,4 +171,8 @@ optimizerSteps = 'jmul[jul] VcTOcul jmul' [bind_json] out = "utils/JsonBindings.sol" include = [] -exclude = [] \ No newline at end of file +exclude = [] + + +[rpc_endpoints] +phalcon = "https://rpc.phalcon.blocksec.com/rpc_d03456ef902047418a8bb566ef81c095" \ No newline at end of file diff --git a/slither.db.json b/slither.db.json new file mode 100644 index 0000000..5b00b7a --- /dev/null +++ b/slither.db.json @@ -0,0 +1 @@ +[{"elements": [{"type": "function", "name": "totalSupply", "source_mapping": {"start": 6287, "length": 195, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [136, 137, 138, 139, 140, 141], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "totalSupply()"}}, {"type": "node", "name": "", "source_mapping": {"start": 6408, "length": 68, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [138, 139, 140], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "totalSupply", "source_mapping": {"start": 6287, "length": 195, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [136, 137, 138, 139, 140, 141], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "totalSupply()"}}}}], "description": "ERC20.totalSupply() (lib/solady/src/tokens/ERC20.sol#136-141) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#138-140)\n", "markdown": "[ERC20.totalSupply()](lib/solady/src/tokens/ERC20.sol#L136-L141) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L138-L140)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L136-L141", "id": "695360efc46cfb11a43dd7da753cf1d04965f77a2ebff4ead28abe0adb6142af", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "balanceOf", "source_mapping": {"start": 6548, "length": 286, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [144, 145, 146, 147, 148, 149, 150, 151], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "balanceOf(address)"}}, {"type": "node", "name": "", "source_mapping": {"start": 6680, "length": 148, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [146, 147, 148, 149, 150], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "balanceOf", "source_mapping": {"start": 6548, "length": 286, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [144, 145, 146, 147, 148, 149, 150, 151], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "balanceOf(address)"}}}}], "description": "ERC20.balanceOf(address) (lib/solady/src/tokens/ERC20.sol#144-151) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#146-150)\n", "markdown": "[ERC20.balanceOf(address)](lib/solady/src/tokens/ERC20.sol#L144-L151) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L146-L150)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L144-L151", "id": "7e5a6d3b7a60dfecd4c8b6370b79336f00a6396e535428c5a14e905f36649578", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "allowance", "source_mapping": {"start": 6929, "length": 375, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "allowance(address,address)"}}, {"type": "node", "name": "", "source_mapping": {"start": 7114, "length": 184, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [161, 162, 163, 164, 165, 166], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "allowance", "source_mapping": {"start": 6929, "length": 375, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "allowance(address,address)"}}}}], "description": "ERC20.allowance(address,address) (lib/solady/src/tokens/ERC20.sol#154-167) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#161-166)\n", "markdown": "[ERC20.allowance(address,address)](lib/solady/src/tokens/ERC20.sol#L154-L167) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L161-L166)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L154-L167", "id": "b50f6be7930356bc340afc7a3aa3682a0a5fe96e195a8af0b350f17ab2c38c39", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "approve", "source_mapping": {"start": 7435, "length": 573, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "approve(address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 7568, "length": 413, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [174, 175, 176, 177, 178, 179, 180, 181, 182, 183], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "approve", "source_mapping": {"start": 7435, "length": 573, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "approve(address,uint256)"}}}}], "description": "ERC20.approve(address,uint256) (lib/solady/src/tokens/ERC20.sol#172-185) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#174-183)\n", "markdown": "[ERC20.approve(address,uint256)](lib/solady/src/tokens/ERC20.sol#L172-L185) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L174-L183)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L172-L185", "id": "3a027919a80d4cc4a84c4d4ba466900fa0259e9d53ea361f42bcdbe813db4527", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "transfer", "source_mapping": {"start": 8195, "length": 1406, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "transfer(address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 8378, "length": 1143, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "transfer", "source_mapping": {"start": 8195, "length": 1406, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "transfer(address,uint256)"}}}}], "description": "ERC20.transfer(address,uint256) (lib/solady/src/tokens/ERC20.sol#193-222) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#196-219)\n", "markdown": "[ERC20.transfer(address,uint256)](lib/solady/src/tokens/ERC20.sol#L193-L222) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L196-L219)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L193-L222", "id": "6a5f2759a9510f3065e0fa549dbccbb1438175289162d3521fdb8bd528c8dfb5", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "transferFrom", "source_mapping": {"start": 9969, "length": 2191, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "transferFrom(address,address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 10164, "length": 1922, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "transferFrom", "source_mapping": {"start": 9969, "length": 2191, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "transferFrom(address,address,uint256)"}}}}], "description": "ERC20.transferFrom(address,address,uint256) (lib/solady/src/tokens/ERC20.sol#233-277) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#236-274)\n", "markdown": "[ERC20.transferFrom(address,address,uint256)](lib/solady/src/tokens/ERC20.sol#L233-L277) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L236-L274)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L233-L277", "id": "819bdc6234a3cb9cb0f38d2124061b78fa3d6642db3e73d80295600994d8c418", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "nonces", "source_mapping": {"start": 12800, "length": 340, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [289, 290, 291, 292, 293, 294, 295, 296, 297], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "nonces(address)"}}, {"type": "node", "name": "", "source_mapping": {"start": 12929, "length": 205, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [291, 292, 293, 294, 295, 296], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "nonces", "source_mapping": {"start": 12800, "length": 340, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [289, 290, 291, 292, 293, 294, 295, 296, 297], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "nonces(address)"}}}}], "description": "ERC20.nonces(address) (lib/solady/src/tokens/ERC20.sol#289-297) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#291-296)\n", "markdown": "[ERC20.nonces(address)](lib/solady/src/tokens/ERC20.sol#L289-L297) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L291-L296)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L289-L297", "id": "a9307f9a683a7f332cf29529ddcf919008923f001bf957d5f25119bd4084689b", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "permit", "source_mapping": {"start": 13324, "length": 3215, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)"}}, {"type": "node", "name": "", "source_mapping": {"start": 13781, "length": 2752, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "permit", "source_mapping": {"start": 13324, "length": 3215, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)"}}}}], "description": "ERC20.permit(address,address,uint256,uint256,uint8,bytes32,bytes32) (lib/solady/src/tokens/ERC20.sol#303-372) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#316-371)\n", "markdown": "[ERC20.permit(address,address,uint256,uint256,uint8,bytes32,bytes32)](lib/solady/src/tokens/ERC20.sol#L303-L372) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L316-L371)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L303-L372", "id": "91e74cf10dda9b83cdf421c5349b276ca08f92afc23c1772c4b6c0ea93ece005", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "DOMAIN_SEPARATOR", "source_mapping": {"start": 16620, "length": 693, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "DOMAIN_SEPARATOR()"}}, {"type": "node", "name": "", "source_mapping": {"start": 16961, "length": 346, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [380, 381, 382, 383, 384, 385, 386, 387, 388], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "DOMAIN_SEPARATOR", "source_mapping": {"start": 16620, "length": 693, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "DOMAIN_SEPARATOR()"}}}}], "description": "ERC20.DOMAIN_SEPARATOR() (lib/solady/src/tokens/ERC20.sol#375-389) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#380-388)\n", "markdown": "[ERC20.DOMAIN_SEPARATOR()](lib/solady/src/tokens/ERC20.sol#L375-L389) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L380-L388)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L375-L389", "id": "8a2bb42941acc0e0e6b8523ee4bf315c421c1f0a60da869aba5bc9e0d287fd53", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "_mint", "source_mapping": {"start": 17717, "length": 1172, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_mint(address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 17884, "length": 946, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "_mint", "source_mapping": {"start": 17717, "length": 1172, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_mint(address,uint256)"}}}}], "description": "ERC20._mint(address,uint256) (lib/solady/src/tokens/ERC20.sol#398-422) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#401-420)\n", "markdown": "[ERC20._mint(address,uint256)](lib/solady/src/tokens/ERC20.sol#L398-L422) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L401-L420)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L398-L422", "id": "f52ceab49e685fc3b48561d5a1da5b6487b06b81de568b43b7855ae4425f2f76", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "_burn", "source_mapping": {"start": 19295, "length": 1119, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_burn(address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 19466, "length": 887, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "_burn", "source_mapping": {"start": 19295, "length": 1119, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_burn(address,uint256)"}}}}], "description": "ERC20._burn(address,uint256) (lib/solady/src/tokens/ERC20.sol#431-454) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#434-452)\n", "markdown": "[ERC20._burn(address,uint256)](lib/solady/src/tokens/ERC20.sol#L431-L454) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L434-L452)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L431-L454", "id": "ffd561aded6cc2183b11fd5e4d0e96ed751aec7a4e470bee04a37bf4f818583f", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "_transfer", "source_mapping": {"start": 20762, "length": 1396, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_transfer(address,address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 20941, "length": 1164, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "_transfer", "source_mapping": {"start": 20762, "length": 1396, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_transfer(address,address,uint256)"}}}}], "description": "ERC20._transfer(address,address,uint256) (lib/solady/src/tokens/ERC20.sol#461-489) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#464-487)\n", "markdown": "[ERC20._transfer(address,address,uint256)](lib/solady/src/tokens/ERC20.sol#L461-L489) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L464-L487)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L461-L489", "id": "d26970a9a40b63efea3780306489487b695bc68bf638ca7fce1c028ad6410448", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "_spendAllowance", "source_mapping": {"start": 22532, "length": 947, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_spendAllowance(address,address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 22675, "length": 798, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "_spendAllowance", "source_mapping": {"start": 22532, "length": 947, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_spendAllowance(address,address,uint256)"}}}}], "description": "ERC20._spendAllowance(address,address,uint256) (lib/solady/src/tokens/ERC20.sol#496-516) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#498-515)\n", "markdown": "[ERC20._spendAllowance(address,address,uint256)](lib/solady/src/tokens/ERC20.sol#L496-L516) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L498-L515)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L496-L516", "id": "1a0a48094e1c340619fd19f22be6f48b182fedf63baeb0c41a7e4d04c962199b", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "_approve", "source_mapping": {"start": 23612, "length": 580, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_approve(address,address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 23748, "length": 438, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [523, 524, 525, 526, 527, 528, 529, 530, 531, 532], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "_approve", "source_mapping": {"start": 23612, "length": 580, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "ERC20", "source_mapping": {"start": 1140, "length": 23743, "filename_relative": "lib/solady/src/tokens/ERC20.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/ERC20.sol", "filename_short": "lib/solady/src/tokens/ERC20.sol", "is_dependency": true, "lines": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546], "starting_column": 1, "ending_column": 2}}, "signature": "_approve(address,address,uint256)"}}}}], "description": "ERC20._approve(address,address,uint256) (lib/solady/src/tokens/ERC20.sol#521-533) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/ERC20.sol#523-532)\n", "markdown": "[ERC20._approve(address,address,uint256)](lib/solady/src/tokens/ERC20.sol#L521-L533) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/ERC20.sol#L523-L532)\n", "first_markdown_element": "lib/solady/src/tokens/ERC20.sol#L521-L533", "id": "0acbb79557e2919ab94c81e9ab4094f739ce49d68fa0692c340548705096bb9e", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "withdraw", "source_mapping": {"start": 1947, "length": 436, "filename_relative": "lib/solady/src/tokens/WETH.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/WETH.sol", "filename_short": "lib/solady/src/tokens/WETH.sol", "is_dependency": true, "lines": [42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "WETH", "source_mapping": {"start": 418, "length": 2074, "filename_relative": "lib/solady/src/tokens/WETH.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/WETH.sol", "filename_short": "lib/solady/src/tokens/WETH.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58], "starting_column": 1, "ending_column": 2}}, "signature": "withdraw(uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 2084, "length": 293, "filename_relative": "lib/solady/src/tokens/WETH.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/WETH.sol", "filename_short": "lib/solady/src/tokens/WETH.sol", "is_dependency": true, "lines": [45, 46, 47, 48, 49, 50, 51], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "withdraw", "source_mapping": {"start": 1947, "length": 436, "filename_relative": "lib/solady/src/tokens/WETH.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/WETH.sol", "filename_short": "lib/solady/src/tokens/WETH.sol", "is_dependency": true, "lines": [42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "WETH", "source_mapping": {"start": 418, "length": 2074, "filename_relative": "lib/solady/src/tokens/WETH.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solady/src/tokens/WETH.sol", "filename_short": "lib/solady/src/tokens/WETH.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58], "starting_column": 1, "ending_column": 2}}, "signature": "withdraw(uint256)"}}}}], "description": "WETH.withdraw(uint256) (lib/solady/src/tokens/WETH.sol#42-52) uses assembly\n\t- INLINE ASM (lib/solady/src/tokens/WETH.sol#45-51)\n", "markdown": "[WETH.withdraw(uint256)](lib/solady/src/tokens/WETH.sol#L42-L52) uses assembly\n\t- [INLINE ASM](lib/solady/src/tokens/WETH.sol#L45-L51)\n", "first_markdown_element": "lib/solady/src/tokens/WETH.sol#L42-L52", "id": "f518a1ec628bae2d2e43ed9a7b170befd3598c733500dfa02a7c9905707509b4", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "safeTransferETH", "source_mapping": {"start": 799, "length": 339, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeTransferETH(address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 937, "length": 145, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [19, 20, 21, 22], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "safeTransferETH", "source_mapping": {"start": 799, "length": 339, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeTransferETH(address,uint256)"}}}}], "description": "SafeTransferLib.safeTransferETH(address,uint256) (lib/solmate/src/utils/SafeTransferLib.sol#15-25) uses assembly\n\t- INLINE ASM (lib/solmate/src/utils/SafeTransferLib.sol#19-22)\n", "markdown": "[SafeTransferLib.safeTransferETH(address,uint256)](lib/solmate/src/utils/SafeTransferLib.sol#L15-L25) uses assembly\n\t- [INLINE ASM](lib/solmate/src/utils/SafeTransferLib.sol#L19-L22)\n", "first_markdown_element": "lib/solmate/src/utils/SafeTransferLib.sol#L15-L25", "id": "3ec6feea0e9db84520fc961eaeeb57342a9ab9baf61066b4af0803e9893444e7", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "safeTransferFrom", "source_mapping": {"start": 1328, "length": 1782, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeTransferFrom(ERC20,address,address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 1532, "length": 1521, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "safeTransferFrom", "source_mapping": {"start": 1328, "length": 1782, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeTransferFrom(ERC20,address,address,uint256)"}}}}], "description": "SafeTransferLib.safeTransferFrom(ERC20,address,address,uint256) (lib/solmate/src/utils/SafeTransferLib.sol#31-63) uses assembly\n\t- INLINE ASM (lib/solmate/src/utils/SafeTransferLib.sol#40-60)\n", "markdown": "[SafeTransferLib.safeTransferFrom(ERC20,address,address,uint256)](lib/solmate/src/utils/SafeTransferLib.sol#L31-L63) uses assembly\n\t- [INLINE ASM](lib/solmate/src/utils/SafeTransferLib.sol#L40-L60)\n", "first_markdown_element": "lib/solmate/src/utils/SafeTransferLib.sol#L31-L63", "id": "d2d353dd4ac0983be7fb89d82768ea005275a365c33ddd67f2dd45ce15e2786a", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "safeTransfer", "source_mapping": {"start": 3116, "length": 1607, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeTransfer(ERC20,address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 3294, "length": 1377, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "safeTransfer", "source_mapping": {"start": 3116, "length": 1607, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeTransfer(ERC20,address,uint256)"}}}}], "description": "SafeTransferLib.safeTransfer(ERC20,address,uint256) (lib/solmate/src/utils/SafeTransferLib.sol#65-95) uses assembly\n\t- INLINE ASM (lib/solmate/src/utils/SafeTransferLib.sol#73-92)\n", "markdown": "[SafeTransferLib.safeTransfer(ERC20,address,uint256)](lib/solmate/src/utils/SafeTransferLib.sol#L65-L95) uses assembly\n\t- [INLINE ASM](lib/solmate/src/utils/SafeTransferLib.sol#L73-L92)\n", "first_markdown_element": "lib/solmate/src/utils/SafeTransferLib.sol#L65-L95", "id": "0e5d0e9ec8bbd611c9ba5bd2a91daf57c87d04cac010961ed965c08fe5c1e694", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "safeApprove", "source_mapping": {"start": 4729, "length": 1605, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeApprove(ERC20,address,uint256)"}}, {"type": "node", "name": "", "source_mapping": {"start": 4906, "length": 1377, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124], "starting_column": 9, "ending_column": 10}, "type_specific_fields": {"parent": {"type": "function", "name": "safeApprove", "source_mapping": {"start": 4729, "length": 1605, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "SafeTransferLib", "source_mapping": {"start": 586, "length": 5750, "filename_relative": "lib/solmate/src/utils/SafeTransferLib.sol", "filename_absolute": "/Users/janitor/fold-staking/lib/solmate/src/utils/SafeTransferLib.sol", "filename_short": "lib/solmate/src/utils/SafeTransferLib.sol", "is_dependency": true, "lines": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 1, "ending_column": 2}}, "signature": "safeApprove(ERC20,address,uint256)"}}}}], "description": "SafeTransferLib.safeApprove(ERC20,address,uint256) (lib/solmate/src/utils/SafeTransferLib.sol#97-127) uses assembly\n\t- INLINE ASM (lib/solmate/src/utils/SafeTransferLib.sol#105-124)\n", "markdown": "[SafeTransferLib.safeApprove(ERC20,address,uint256)](lib/solmate/src/utils/SafeTransferLib.sol#L97-L127) uses assembly\n\t- [INLINE ASM](lib/solmate/src/utils/SafeTransferLib.sol#L105-L124)\n", "first_markdown_element": "lib/solmate/src/utils/SafeTransferLib.sol#L97-L127", "id": "89ef85e5a8ccef73b3574a13ad1b3504aaced70bb4e6dfc5469b8d0b0af4e281", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "getSqrtPriceAtTick", "source_mapping": {"start": 2757, "length": 3921, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getSqrtPriceAtTick(int24)"}}, {"type": "node", "name": "", "source_mapping": {"start": 2905, "length": 399, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [53, 54, 55, 56, 57, 58, 59, 60], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getSqrtPriceAtTick", "source_mapping": {"start": 2757, "length": 3921, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getSqrtPriceAtTick(int24)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 3390, "length": 253, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [62, 63, 64, 65, 66, 67, 68], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getSqrtPriceAtTick", "source_mapping": {"start": 2757, "length": 3921, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getSqrtPriceAtTick(int24)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 3926, "length": 144, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [74, 75, 76], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getSqrtPriceAtTick", "source_mapping": {"start": 2757, "length": 3921, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getSqrtPriceAtTick(int24)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 5951, "length": 711, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getSqrtPriceAtTick", "source_mapping": {"start": 2757, "length": 3921, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getSqrtPriceAtTick(int24)"}}}}], "description": "TickMath.getSqrtPriceAtTick(int24) (src/libraries/TickMath.sol#50-109) uses assembly\n\t- INLINE ASM (src/libraries/TickMath.sol#53-60)\n\t- INLINE ASM (src/libraries/TickMath.sol#62-68)\n\t- INLINE ASM (src/libraries/TickMath.sol#74-76)\n\t- INLINE ASM (src/libraries/TickMath.sol#97-107)\n", "markdown": "[TickMath.getSqrtPriceAtTick(int24)](src/libraries/TickMath.sol#L50-L109) uses assembly\n\t- [INLINE ASM](src/libraries/TickMath.sol#L53-L60)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L62-L68)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L74-L76)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L97-L107)\n", "first_markdown_element": "src/libraries/TickMath.sol#L50-L109", "id": "4ae36ffd19d82c23700d577c51c1d5678f3c1515bad51126ece9117ae8b6498e", "check": "assembly", "impact": "Informational", "confidence": "High"}, {"elements": [{"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}, {"type": "node", "name": "", "source_mapping": {"start": 7442, "length": 534, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [120, 121, 122, 123, 124, 125, 126, 127, 128], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 8109, "length": 164, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [135, 136, 137, 138, 139], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 8286, "length": 148, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [140, 141, 142, 143, 144], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 8447, "length": 140, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [145, 146, 147, 148, 149], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 8600, "length": 136, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [150, 151, 152, 153, 154], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 8749, "length": 134, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [155, 156, 157, 158, 159], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 8896, "length": 133, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [160, 161, 162, 163, 164], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 9042, "length": 133, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [165, 166, 167, 168, 169], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 9188, "length": 94, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [170, 171, 172, 173], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 9449, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [180, 181, 182, 183, 184, 185], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 9642, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [186, 187, 188, 189, 190, 191], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 9835, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [192, 193, 194, 195, 196, 197], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 10028, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [198, 199, 200, 201, 202, 203], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 10221, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [204, 205, 206, 207, 208, 209], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 10414, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [210, 211, 212, 213, 214, 215], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 10607, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [216, 217, 218, 219, 220, 221], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 10800, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [222, 223, 224, 225, 226, 227], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 10993, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [228, 229, 230, 231, 232, 233], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 11186, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [234, 235, 236, 237, 238, 239], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 11379, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [240, 241, 242, 243, 244, 245], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 11572, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [246, 247, 248, 249, 250, 251], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 11765, "length": 180, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [252, 253, 254, 255, 256, 257], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}, {"type": "node", "name": "", "source_mapping": {"start": 11958, "length": 149, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [258, 259, 260, 261, 262], "starting_column": 13, "ending_column": 14}, "type_specific_fields": {"parent": {"type": "function", "name": "getTickAtSqrtPrice", "source_mapping": {"start": 7097, "length": 5427, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], "starting_column": 5, "ending_column": 6}, "type_specific_fields": {"parent": {"type": "contract", "name": "TickMath", "source_mapping": {"start": 305, "length": 12221, "filename_relative": "src/libraries/TickMath.sol", "filename_absolute": "/Users/janitor/fold-staking/src/libraries/TickMath.sol", "filename_short": "src/libraries/TickMath.sol", "is_dependency": false, "lines": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], "starting_column": 1, "ending_column": 0}}, "signature": "getTickAtSqrtPrice(uint160)"}}}}], "description": "TickMath.getTickAtSqrtPrice(uint160) (src/libraries/TickMath.sol#116-271) uses assembly\n\t- INLINE ASM (src/libraries/TickMath.sol#120-128)\n\t- INLINE ASM (src/libraries/TickMath.sol#135-139)\n\t- INLINE ASM (src/libraries/TickMath.sol#140-144)\n\t- INLINE ASM (src/libraries/TickMath.sol#145-149)\n\t- INLINE ASM (src/libraries/TickMath.sol#150-154)\n\t- INLINE ASM (src/libraries/TickMath.sol#155-159)\n\t- INLINE ASM (src/libraries/TickMath.sol#160-164)\n\t- INLINE ASM (src/libraries/TickMath.sol#165-169)\n\t- INLINE ASM (src/libraries/TickMath.sol#170-173)\n\t- INLINE ASM (src/libraries/TickMath.sol#180-185)\n\t- INLINE ASM (src/libraries/TickMath.sol#186-191)\n\t- INLINE ASM (src/libraries/TickMath.sol#192-197)\n\t- INLINE ASM (src/libraries/TickMath.sol#198-203)\n\t- INLINE ASM (src/libraries/TickMath.sol#204-209)\n\t- INLINE ASM (src/libraries/TickMath.sol#210-215)\n\t- INLINE ASM (src/libraries/TickMath.sol#216-221)\n\t- INLINE ASM (src/libraries/TickMath.sol#222-227)\n\t- INLINE ASM (src/libraries/TickMath.sol#228-233)\n\t- INLINE ASM (src/libraries/TickMath.sol#234-239)\n\t- INLINE ASM (src/libraries/TickMath.sol#240-245)\n\t- INLINE ASM (src/libraries/TickMath.sol#246-251)\n\t- INLINE ASM (src/libraries/TickMath.sol#252-257)\n\t- INLINE ASM (src/libraries/TickMath.sol#258-262)\n", "markdown": "[TickMath.getTickAtSqrtPrice(uint160)](src/libraries/TickMath.sol#L116-L271) uses assembly\n\t- [INLINE ASM](src/libraries/TickMath.sol#L120-L128)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L135-L139)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L140-L144)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L145-L149)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L150-L154)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L155-L159)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L160-L164)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L165-L169)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L170-L173)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L180-L185)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L186-L191)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L192-L197)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L198-L203)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L204-L209)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L210-L215)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L216-L221)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L222-L227)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L228-L233)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L234-L239)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L240-L245)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L246-L251)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L252-L257)\n\t- [INLINE ASM](src/libraries/TickMath.sol#L258-L262)\n", "first_markdown_element": "src/libraries/TickMath.sol#L116-L271", "id": "538dc7a9ed0f808acaa5e542ff65ffc37f0666fa1a8b23f56b2ca3ef56ec45e7", "check": "assembly", "impact": "Informational", "confidence": "High"}] \ No newline at end of file diff --git a/test/FoldCaptiveStakingTest.t.sol b/test/FoldCaptiveStakingTest.t.sol deleted file mode 100644 index b93eb64..0000000 --- a/test/FoldCaptiveStakingTest.t.sol +++ /dev/null @@ -1,78 +0,0 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity ^0.8.13; - -import "forge-std/Test.sol"; -import "../src/FoldCaptiveStaking.sol"; -import {ERC20} from "lib/solmate/src/tokens/ERC20.sol"; -import {IERC20} from "../src/interfaces/IERC20.sol"; -import {INonfungiblePositionManager} from "../src/interfaces/INonfungiblePositionManager.sol"; - -contract FoldCaptiveStakingTest is Test { - FoldCaptiveStaking public staking; - IERC20 public token0; - IERC20 public token1; - INonfungiblePositionManager public positionManager; - - address public owner = address(1); - - function setUp() public { - vm.startPrank(owner); - token0 = IERC20(address(new ERC20Mock())); - token1 = IERC20(address(new ERC20Mock())); - positionManager = INonfungiblePositionManager(address(new PositionManagerMock())); - staking = new FoldCaptiveStaking(address(token0), address(token1), address(positionManager), owner); - vm.stopPrank(); - } - - function testInitialize() public { - vm.startPrank(owner); - staking.initialize(); - assertTrue(staking.initialized()); - assertEq(staking.TOKEN_ID(), 1); - assertGt(staking.liquidityUnderManagement(), 0); - vm.stopPrank(); - } - - function testInitializeRevertOnSecondCall() public { - vm.startPrank(owner); - staking.initialize(); - vm.expectRevert(FoldCaptiveStaking.AlreadyInitialized.selector); - staking.initialize(); - vm.stopPrank(); - } - - function testInitializeRevertOnZeroLiquidity() public { - vm.startPrank(owner); - PositionManagerMock(address(positionManager)).setMintLiquidity(0); - vm.expectRevert(FoldCaptiveStaking.ZeroLiquidity.selector); - staking.initialize(); - vm.stopPrank(); - } - - function testInitializeOnlyOwner() public { - vm.prank(address(2)); - vm.expectRevert("Ownable: caller is not the owner"); - staking.initialize(); - } -} - -contract ERC20Mock is ERC20 { - constructor() ERC20("Mock Token", "MTK", 18) { - _mint(msg.sender, 1000000 * 10**uint256(decimals)); - } -} - -contract PositionManagerMock { - uint256 public tokenIdCounter = 1; - uint128 public liquidityToMint = 1000; - - function mint(INonfungiblePositionManager.MintParams memory) external returns (uint256 tokenId, uint128 liquidity, uint256, uint256) { - tokenId = tokenIdCounter++; - liquidity = liquidityToMint; - return (tokenId, liquidity, 0, 0); - } - - function setMintLiquidity(uint128 _liquidity) external { - liquidityToMint = _liquidity; - } -}