@pendle/core-v2 2.29.1 → 2.29.2

package/contracts/interfaces/Kyber/IKyberElasticFactory.sol

@@ -0,0 +1,165 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/// @title KyberSwap v2 factory
+/// @notice Deploys KyberSwap v2 pools and manages control over government fees
+interface IKyberElasticFactory {
+  /// @notice Emitted when a pool is created
+  /// @param token0 First pool token by address sort order
+  /// @param token1 Second pool token by address sort order
+  /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+  /// @param tickDistance Minimum number of ticks between initialized ticks
+  /// @param pool The address of the created pool
+  event PoolCreated(
+    address indexed token0,
+    address indexed token1,
+    uint24 indexed swapFeeUnits,
+    int24 tickDistance,
+    address pool
+  );
+
+  /// @notice Emitted when a new fee is enabled for pool creation via the factory
+  /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+  /// @param tickDistance Minimum number of ticks between initialized ticks for pools created with the given fee
+  event SwapFeeEnabled(uint24 indexed swapFeeUnits, int24 indexed tickDistance);
+
+  /// @notice Emitted when vesting period changes
+  /// @param vestingPeriod The maximum time duration for which LP fees
+  /// are proportionally burnt upon LP removals
+  event VestingPeriodUpdated(uint32 vestingPeriod);
+
+  /// @notice Emitted when configMaster changes
+  /// @param oldConfigMaster configMaster before the update
+  /// @param newConfigMaster configMaster after the update
+  event ConfigMasterUpdated(address oldConfigMaster, address newConfigMaster);
+
+  /// @notice Emitted when fee configuration changes
+  /// @param feeTo Recipient of government fees
+  /// @param governmentFeeUnits Fee amount, in fee units,
+  /// to be collected out of the fee charged for a pool swap
+  event FeeConfigurationUpdated(address feeTo, uint24 governmentFeeUnits);
+
+  /// @notice Emitted when whitelist feature is enabled
+  event WhitelistEnabled();
+
+  /// @notice Emitted when whitelist feature is disabled
+  event WhitelistDisabled();
+
+  /// @notice Returns the maximum time duration for which LP fees
+  /// are proportionally burnt upon LP removals
+  function vestingPeriod() external view returns (uint32);
+
+  /// @notice Returns the tick distance for a specified fee.
+  /// @dev Once added, cannot be updated or removed.
+  /// @param swapFeeUnits Swap fee, in fee units.
+  /// @return The tick distance. Returns 0 if fee has not been added.
+  function feeAmountTickDistance(uint24 swapFeeUnits) external view returns (int24);
+
+  /// @notice Returns the address which can update the fee configuration
+  function configMaster() external view returns (address);
+
+  /// @notice Returns the keccak256 hash of the Pool creation code
+  /// This is used for pre-computation of pool addresses
+  function poolInitHash() external view returns (bytes32);
+
+  /// @notice Returns the pool oracle contract for twap
+  function poolOracle() external view returns (address);
+
+  /// @notice Fetches the recipient of government fees
+  /// and current government fee charged in fee units
+  function feeConfiguration() external view returns (address _feeTo, uint24 _governmentFeeUnits);
+
+  /// @notice Returns the status of whitelisting feature of NFT managers
+  /// If true, anyone can mint liquidity tokens
+  /// Otherwise, only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+  function whitelistDisabled() external view returns (bool);
+
+  //// @notice Returns all whitelisted NFT managers
+  /// If the whitelisting feature is turned on,
+  /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+  function getWhitelistedNFTManagers() external view returns (address[] memory);
+
+  /// @notice Checks if sender is a whitelisted NFT manager
+  /// If the whitelisting feature is turned on,
+  /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+  /// @param sender address to be checked
+  /// @return true if sender is a whistelisted NFT manager, false otherwise
+  function isWhitelistedNFTManager(address sender) external view returns (bool);
+
+  /// @notice Returns the pool address for a given pair of tokens and a swap fee
+  /// @dev Token order does not matter
+  /// @param tokenA Contract address of either token0 or token1
+  /// @param tokenB Contract address of the other token
+  /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+  /// @return pool The pool address. Returns null address if it does not exist
+  function getPool(
+    address tokenA,
+    address tokenB,
+    uint24 swapFeeUnits
+  ) external view returns (address pool);
+
+  /// @notice Fetch parameters to be used for pool creation
+  /// @dev Called by the pool constructor to fetch the parameters of the pool
+  /// @return factory The factory address
+  /// @return poolOracle The pool oracle for twap
+  /// @return token0 First pool token by address sort order
+  /// @return token1 Second pool token by address sort order
+  /// @return swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+  /// @return tickDistance Minimum number of ticks between initialized ticks
+  function parameters()
+    external
+    view
+    returns (
+      address factory,
+      address poolOracle,
+      address token0,
+      address token1,
+      uint24 swapFeeUnits,
+      int24 tickDistance
+    );
+
+  /// @notice Creates a pool for the given two tokens and fee
+  /// @param tokenA One of the two tokens in the desired pool
+  /// @param tokenB The other of the two tokens in the desired pool
+  /// @param swapFeeUnits Desired swap fee for the pool, in fee units
+  /// @dev Token order does not matter. tickDistance is determined from the fee.
+  /// Call will revert under any of these conditions:
+  ///     1) pool already exists
+  ///     2) invalid swap fee
+  ///     3) invalid token arguments
+  /// @return pool The address of the newly created pool
+  function createPool(
+    address tokenA,
+    address tokenB,
+    uint24 swapFeeUnits
+  ) external returns (address pool);
+
+  /// @notice Enables a fee amount with the given tickDistance
+  /// @dev Fee amounts may never be removed once enabled
+  /// @param swapFeeUnits The fee amount to enable, in fee units
+  /// @param tickDistance The distance between ticks to be enforced for all pools created with the given fee amount
+  function enableSwapFee(uint24 swapFeeUnits, int24 tickDistance) external;
+
+  /// @notice Updates the address which can update the fee configuration
+  /// @dev Must be called by the current configMaster
+  function updateConfigMaster(address) external;
+
+  /// @notice Updates the vesting period
+  /// @dev Must be called by the current configMaster
+  function updateVestingPeriod(uint32) external;
+
+  /// @notice Updates the address receiving government fees and fee quantity
+  /// @dev Only configMaster is able to perform the update
+  /// @param feeTo Address to receive government fees collected from pools
+  /// @param governmentFeeUnits Fee amount, in fee units,
+  /// to be collected out of the fee charged for a pool swap
+  function updateFeeConfiguration(address feeTo, uint24 governmentFeeUnits) external;
+
+  /// @notice Enables the whitelisting feature
+  /// @dev Only configMaster is able to perform the update
+  function enableWhitelist() external;
+
+  /// @notice Disables the whitelisting feature
+  /// @dev Only configMaster is able to perform the update
+  function disableWhitelist() external;
+}

package/contracts/interfaces/Kyber/IKyberElasticPool.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+interface IKyberElasticPool {
+
+  function factory() external view returns (address);
+
+  /// @notice The first of the two tokens of the pool, sorted by address
+  /// @return The token contract address
+  function token0() external view returns (address);
+
+  /// @notice The second of the two tokens of the pool, sorted by address
+  /// @return The token contract address
+  function token1() external view returns (address);
+
+  /// @notice The fee to be charged for a swap in basis points
+  /// @return The swap fee in basis points
+  function swapFeeUnits() external view returns (uint24);
+
+  function totalSupply() external view returns (uint256);
+
+  /// @notice The pool tick distance
+  /// @dev Ticks can only be initialized and used at multiples of this value
+  /// It remains an int24 to avoid casting even though it is >= 1.
+  /// e.g: a tickDistance of 5 means ticks can be initialized every 5th tick, i.e., ..., -10, -5, 0, 5, 10, ...
+  /// @return The tick distance
+  function tickDistance() external view returns (int24);
+
+  /// @notice Maximum gross liquidity that an initialized tick can have
+  /// @dev This is to prevent overflow the pool's active base liquidity (uint128)
+  /// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
+  /// @return The max amount of liquidity per tick
+  function maxTickLiquidity() external view returns (uint128);
+
+  /// @notice Look up information about a specific tick in the pool
+  /// @param tick The tick to look up
+  /// @return liquidityGross total liquidity amount from positions that uses this tick as a lower or upper tick
+  /// liquidityNet how much liquidity changes when the pool tick crosses above the tick
+  /// feeGrowthOutside the fee growth on the other side of the tick relative to the current tick
+  /// secondsPerLiquidityOutside the seconds per unit of liquidity  spent on the other side of the tick relative to the current tick
+  function ticks(int24 tick)
+    external
+    view
+    returns (
+      uint128 liquidityGross,
+      int128 liquidityNet,
+      uint256 feeGrowthOutside,
+      uint128 secondsPerLiquidityOutside
+    );
+
+  /// @notice Returns the previous and next initialized ticks of a specific tick
+  /// @dev If specified tick is uninitialized, the returned values are zero.
+  /// @param tick The tick to look up
+  function initializedTicks(int24 tick) external view returns (int24 previous, int24 next);
+
+  /// @notice Returns the information about a position by the position's key
+  /// @return liquidity the liquidity quantity of the position
+  /// @return feeGrowthInsideLast fee growth inside the tick range as of the last mint / burn action performed
+  function getPositions(
+    address owner,
+    int24 tickLower,
+    int24 tickUpper
+  ) external view returns (uint128 liquidity, uint256 feeGrowthInsideLast);
+
+  /// @notice Fetches the pool's prices, ticks and lock status
+  /// @return sqrtP sqrt of current price: sqrt(token1/token0)
+  /// @return currentTick pool's current tick
+  /// @return nearestCurrentTick pool's nearest initialized tick that is <= currentTick
+  /// @return locked true if pool is locked, false otherwise
+  function getPoolState()
+    external
+    view
+    returns (
+      uint160 sqrtP,
+      int24 currentTick,
+      int24 nearestCurrentTick,
+      bool locked
+    );
+
+  /// @notice Fetches the pool's liquidity values
+  /// @return baseL pool's base liquidity without reinvest liqudity
+  /// @return reinvestL the liquidity is reinvested into the pool
+  /// @return reinvestLLast last cached value of reinvestL, used for calculating reinvestment token qty
+  function getLiquidityState()
+    external
+    view
+    returns (
+      uint128 baseL,
+      uint128 reinvestL,
+      uint128 reinvestLLast
+    );
+
+  /// @return feeGrowthGlobal All-time fee growth per unit of liquidity of the pool
+  function getFeeGrowthGlobal() external view returns (uint256);
+
+  /// @return secondsPerLiquidityGlobal All-time seconds per unit of liquidity of the pool
+  /// @return lastUpdateTime The timestamp in which secondsPerLiquidityGlobal was last updated
+  function getSecondsPerLiquidityData()
+    external
+    view
+    returns (uint128 secondsPerLiquidityGlobal, uint32 lastUpdateTime);
+
+  /// @notice Calculates and returns the active time per unit of liquidity until current block.timestamp
+  /// @param tickLower The lower tick (of a position)
+  /// @param tickUpper The upper tick (of a position)
+  /// @return secondsPerLiquidityInside active time (multiplied by 2^96)
+  /// between the 2 ticks, per unit of liquidity.
+  function getSecondsPerLiquidityInside(int24 tickLower, int24 tickUpper)
+    external
+    view
+    returns (uint128 secondsPerLiquidityInside);
+}

package/contracts/interfaces/Kyber/IKyberElasticRouter.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+/// @notice Functions for swapping tokens via KyberSwap v2
+/// - Support swap with exact input or exact output
+/// - Support swap with a price limit
+/// - Support swap within a single pool and between multiple pools
+interface IKyberElasticRouter {
+  /// @dev Params for swapping exact input amount
+  /// @param tokenIn the token to swap
+  /// @param tokenOut the token to receive
+  /// @param fee the pool's fee
+  /// @param recipient address to receive tokenOut
+  /// @param deadline time that the transaction will be expired
+  /// @param amountIn the tokenIn amount to swap
+  /// @param amountOutMinimum the minimum receive amount
+  /// @param limitSqrtP the price limit, if reached, stop swapping
+  struct ExactInputSingleParams {
+    address tokenIn;
+    address tokenOut;
+    uint24 fee;
+    address recipient;
+    uint256 deadline;
+    uint256 amountIn;
+    uint256 minAmountOut;
+    uint160 limitSqrtP;
+  }
+
+  /// @notice Swaps `amountIn` of one token for as much as possible of another token
+  /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
+  /// @return amountOut The amount of the received token
+  function swapExactInputSingle(ExactInputSingleParams calldata params)
+    external
+    payable
+    returns (uint256 amountOut);
+
+  /// @dev Params for swapping exact input using multiple pools
+  /// @param path the encoded path to swap from tokenIn to tokenOut
+  ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token0, fee01, token1, fee12, token2]
+  /// @param recipient address to receive tokenOut
+  /// @param deadline time that the transaction will be expired
+  /// @param amountIn the tokenIn amount to swap
+  /// @param amountOutMinimum the minimum receive amount
+  struct ExactInputParams {
+    bytes path;
+    address recipient;
+    uint256 deadline;
+    uint256 amountIn;
+    uint256 minAmountOut;
+  }
+
+  /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
+  /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
+  /// @return amountOut The amount of the received token
+  function swapExactInput(ExactInputParams calldata params)
+    external
+    payable
+    returns (uint256 amountOut);
+
+  /// @dev Params for swapping exact output amount
+  /// @param tokenIn the token to swap
+  /// @param tokenOut the token to receive
+  /// @param fee the pool's fee
+  /// @param recipient address to receive tokenOut
+  /// @param deadline time that the transaction will be expired
+  /// @param amountOut the tokenOut amount of tokenOut
+  /// @param amountInMaximum the minimum input amount
+  /// @param limitSqrtP the price limit, if reached, stop swapping
+  struct ExactOutputSingleParams {
+    address tokenIn;
+    address tokenOut;
+    uint24 fee;
+    address recipient;
+    uint256 deadline;
+    uint256 amountOut;
+    uint256 maxAmountIn;
+    uint160 limitSqrtP;
+  }
+
+  /// @notice Swaps as little as possible of one token for `amountOut` of another token
+  /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
+  /// @return amountIn The amount of the input token
+  function swapExactOutputSingle(ExactOutputSingleParams calldata params)
+    external
+    payable
+    returns (uint256 amountIn);
+
+  /// @dev Params for swapping exact output using multiple pools
+  /// @param path the encoded path to swap from tokenIn to tokenOut
+  ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token2, fee12, token1, fee01, token0]
+  /// @param recipient address to receive tokenOut
+  /// @param deadline time that the transaction will be expired
+  /// @param amountOut the tokenOut amount of tokenOut
+  /// @param amountInMaximum the minimum input amount
+  struct ExactOutputParams {
+    bytes path;
+    address recipient;
+    uint256 deadline;
+    uint256 amountOut;
+    uint256 maxAmountIn;
+  }
+
+  /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
+  /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
+  /// @return amountIn The amount of the input token
+  function swapExactOutput(ExactOutputParams calldata params)
+    external
+    payable
+    returns (uint256 amountIn);
+}

package/contracts/interfaces/Kyber/IKyberLiquidityMining.sol

@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+interface IKyberLiquidityMining {
+    error Forbidden();
+    error EmergencyEnabled();
+
+    error InvalidRange();
+    error InvalidTime();
+    error InvalidReward();
+
+    error PositionNotEligible();
+    error FarmNotFound();
+    error InvalidFarm();
+    error NotOwner();
+    error StakeNotFound();
+    error RangeNotMatch();
+    error RangeNotFound();
+    error PhaseSettled();
+    error InvalidInput();
+    error LiquidityNotMatch();
+    error FailToAdd();
+    error FailToRemove();
+    error Expired();
+
+    event UpdateEmergency(bool enableOrDisable);
+    event UpdateTokenCode(bytes farmingTokenCode);
+    event WithdrawUnusedRewards(address token, uint256 amount, address receiver);
+
+    event AddFarm(
+        uint256 indexed fId,
+        address poolAddress,
+        RangeInput[] ranges,
+        PhaseInput phase,
+        address farmingToken
+    );
+    event AddPhase(uint256 indexed fId, PhaseInput phase);
+    event ForceClosePhase(uint256 indexed fId);
+    event AddRange(uint256 indexed fId, RangeInput range);
+    event RemoveRange(uint256 indexed fId, uint256 rangeId);
+    event ActivateRange(uint256 indexed fId, uint256 rangeId);
+    event ExpandEndTimeAndRewards(uint256 indexed fId, uint256 duration, uint256[] rewardAmounts);
+
+    event Deposit(
+        uint256 indexed fId,
+        uint256 rangeId,
+        uint256[] nftIds,
+        address indexed depositer,
+        address receiver
+    );
+    event UpdateLiquidity(uint256 indexed fId, uint256 nftId, uint256 liquidity);
+    event Withdraw(uint256[] nftIds, address receiver);
+    event WithdrawEmergency(uint256 nftId, address receiver);
+    event ClaimReward(
+        uint256 fId,
+        uint256[] nftIds,
+        address token,
+        uint256 amount,
+        address receiver
+    );
+
+    struct RangeInput {
+        int24 tickLower;
+        int24 tickUpper;
+        uint32 weight;
+    }
+
+    struct RewardInput {
+        address rewardToken;
+        uint256 rewardAmount;
+    }
+
+    struct PhaseInput {
+        uint32 startTime;
+        uint32 endTime;
+        RewardInput[] rewards;
+    }
+
+    struct RemoveLiquidityInput {
+        uint256 nftId;
+        uint128 liquidity;
+    }
+
+    struct RangeInfo {
+        int24 tickLower;
+        int24 tickUpper;
+        uint32 weight;
+        bool isRemoved;
+    }
+
+    struct PhaseInfo {
+        uint32 startTime;
+        uint32 endTime;
+        bool isSettled;
+        RewardInput[] rewards;
+    }
+
+    struct FarmInfo {
+        address poolAddress;
+        RangeInfo[] ranges;
+        PhaseInfo phase;
+        uint256 liquidity;
+        address farmingToken;
+        uint256[] sumRewardPerLiquidity;
+        uint32 lastTouchedTime;
+    }
+
+    struct StakeInfo {
+        address owner;
+        uint256 fId;
+        uint256 rangeId;
+        uint256 liquidity;
+        uint256[] lastSumRewardPerLiquidity;
+        uint256[] rewardUnclaimed;
+    }
+
+    // ======== user ============
+    /// @dev deposit nfts to farm
+    /// @dev store curRewardPerLiq now to stake info, mint an amount of farmingToken (if needed) to msg.sender
+    /// @param fId farm's id
+    /// @param rangeId rangeId to add, should use quoter to get best APR rangeId
+    /// @param nftIds nfts to deposit
+    function deposit(
+        uint256 fId,
+        uint256 rangeId,
+        uint256[] memory nftIds,
+        address receiver
+    ) external;
+
+    /// @dev claim reward earned for nfts
+    /// @param fId farm's id
+    /// @param nftIds nfts to claim
+    function claimReward(uint256 fId, uint256[] memory nftIds) external;
+
+    /// @dev withdraw nfts from farm
+    /// @dev only can call by nfts's owner, also claim reward earned
+    /// @dev burn an amount of farmingToken (if needed) from msg.sender
+    /// @param fId farm's id
+    /// @param nftIds nfts to withdraw
+    function withdraw(uint256 fId, uint256[] memory nftIds) external;
+
+    /// @dev add liquidity of nfts when liquidity already added on Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @dev calculate reward earned, update stakeInfo, mint an amount of farmingToken to msg.sender
+    /// @param fId farm's id
+    /// @param rangeId rangeId of deposited nfts
+    /// @param nftIds nfts to add liquidity
+    function addLiquidity(uint256 fId, uint256 rangeId, uint256[] calldata nftIds) external;
+
+    /// @dev remove liquidity of nfts from Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @dev calculate reward earned, update stakeInfo, mint/burn an amount of farmingToken
+    /// @param nftId id of nft to remove liquidity
+    /// @param liquidity amount to remove from nft
+    /// @param amount0Min min amount of token0 should receive
+    /// @param amount1Min min amount of token1 should receive
+    /// @param deadline deadline of remove liquidity tx
+    /// @param isClaimFee is also burnRTokens or not
+    function removeLiquidity(
+        uint256 nftId,
+        uint128 liquidity,
+        uint256 amount0Min,
+        uint256 amount1Min,
+        uint256 deadline,
+        bool isClaimFee,
+        bool isReceiveNative
+    ) external;
+
+    /// @dev claim fee from Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @param fId farm's id
+    /// @param nftIds nfts to claim
+    /// @param amount0Min min amount of token0 should receive
+    /// @param amount1Min min amount of token1 should receive
+    /// @param deadline deadline of remove liquidity tx
+    function claimFee(
+        uint256 fId,
+        uint256[] calldata nftIds,
+        uint256 amount0Min,
+        uint256 amount1Min,
+        uint256 deadline,
+        bool isReceiveNative
+    ) external;
+
+    /// @dev withdraw nfts in case emergency
+    /// @dev only can call by nfts's owner
+    /// @dev in normal case, abandon all rewards, must return farmingToken
+    /// @dev incase emergencyEnabled, bypass all calculation
+    /// @param nftIds nfts to withdraw
+    function withdrawEmergency(uint256[] calldata nftIds) external;
+
+    function emergencyEnabled() external view returns (bool);
+
+
+    // ======== view ============
+
+    function getFarm(
+        uint256 fId
+    )
+        external
+        view
+        returns (
+            address poolAddress,
+            RangeInfo[] memory ranges,
+            PhaseInfo memory phase,
+            uint256 liquidity,
+            address farmingToken,
+            uint256[] memory sumRewardPerLiquidity,
+            uint32 lastTouchedTime
+        );
+
+    function getDepositedNFTs(address user) external view returns (uint256[] memory listNFTs);
+
+    function getStake(
+        uint256 nftId
+    )
+        external
+        view
+        returns (
+            address owner,
+            uint256 fId,
+            uint256 rangeId,
+            uint256 liquidity,
+            uint256[] memory lastSumRewardPerLiquidity,
+            uint256[] memory rewardUnclaimeds
+        );
+}

package/contracts/interfaces/Kyber/IKyberMathHelper.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+interface IKyberMathHelper {
+    function getSingleSidedSwapAmount(
+        address kyberPool,
+        uint256 startAmount,
+        bool isToken0,
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (uint256 amountToSwap);
+
+    function previewDeposit(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountIn
+    ) external view returns (uint256);
+
+    function previewRedeem(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountShares
+    ) external view returns (uint256);
+}