@pendle/core-v2 2.23.1 → 2.23.2-mantle

package/contracts/core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+import "../../../../LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol";
+import "../../../../interfaces/ILayerZeroEndpoint.sol";
+import "../../../../interfaces/IWstETH.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+
+contract PendleChainlinkRelayer {
+    uint256 private constant DST_EXECUTION_GAS = 50000;
+
+    address public immutable lzEndpoint;
+    address public immutable dstAddress;
+    uint256 public immutable dstChainId;
+    address public immutable chainlinkFeed;
+
+    constructor(
+        address _lzEndpoint,
+        address _dstAddress,
+        uint256 _dstChainId,
+        address _chainlinkFeed
+    ) {
+        lzEndpoint = _lzEndpoint;
+        dstAddress = _dstAddress;
+        dstChainId = _dstChainId;
+        chainlinkFeed = _chainlinkFeed;
+    }
+
+    function run() external payable {
+        bytes memory path = abi.encodePacked(dstAddress, address(this));
+        ILayerZeroEndpoint(lzEndpoint).send{ value: msg.value }(
+            LayerZeroHelper._getLayerZeroChainIds(dstChainId),
+            path,
+            abi.encode(IChainlinkAggregator(chainlinkFeed).latestAnswer()),
+            payable(msg.sender),
+            address(0),
+            abi.encodePacked(uint16(1), DST_EXECUTION_GAS)
+        );
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleMantleStakedEthSY.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPOracleForSy.sol";
+
+contract PendleMantleStakedEthSY is SYBase {
+    using Math for int256;
+
+    address internal immutable underlyingAssetOnEthAddr;
+    uint8 internal immutable underlyingAssetOnEthDecimals;
+    address public immutable oracleAddress;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _token,
+        address _underlyingAssetOnEthAddr,
+        uint8 _underlyingAssetOnEthDecimals,
+        address _oracleAddress
+    ) SYBase(_name, _symbol, _token) {
+        underlyingAssetOnEthAddr = _underlyingAssetOnEthAddr;
+        underlyingAssetOnEthDecimals = _underlyingAssetOnEthDecimals;
+        oracleAddress = _oracleAddress;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited)
+        internal
+        pure
+        override
+        returns (
+            uint256 /*amountSharesOut*/
+        )
+    {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    )
+        internal
+        override
+        returns (
+            uint256 /*amountTokenOut*/
+        )
+    {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPOracleForSy(oracleAddress).latestAnswer().Uint();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
+        internal
+        pure
+        override
+        returns (
+            uint256 /*amountSharesOut*/
+        )
+    {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        pure
+        override
+        returns (
+            uint256 /*amountTokenOut*/
+        )
+    {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleOracleForSyProxy.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPOracleForSy.sol";
+
+// the Owner of this will be a timelock
+contract PendleOracleForSyProxy is BoringOwnableUpgradeable, IPOracleForSy {
+    address public oracleAddress;
+
+    constructor(address _oracleAddress) initializer {
+        __BoringOwnable_init();
+        oracleAddress = _oracleAddress;
+    }
+
+    function latestAnswer() external view override returns (int256) {
+        return IPOracleForSy(oracleAddress).latestAnswer();
+    }
+
+    function setOracleAddress(address _oracleAddress) external onlyOwner {
+        oracleAddress = _oracleAddress;
+    }
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -39,6 +39,36 @@ library ArrayLib {
         }
         out[length] = element;
     }
+    /**
+     * @dev This function assumes a and b each contains unidentical elements 
+     * @param a array of addresses a
+     * @param b array of addresses b
+     * @return out Concatenation of a and b containing unidentical elements
+     */
+    function concat(
+        address[] memory a,
+        address[] memory b
+    ) internal pure returns (address[] memory out) {
+        uint256 countUnidenticalB = 0;
+        bool[] memory isUnidentical = new bool[](b.length);
+        for(uint256 i = 0; i < b.length; ++i) {
+            if (!contains(a, b[i])) {
+                countUnidenticalB++;
+                isUnidentical[i] = true;
+            }
+        }
+
+        out = new address[](a.length + countUnidenticalB);
+        for(uint256 i = 0; i < a.length; ++i) {
+            out[i] = a[i];
+        }
+        uint256 id = a.length;
+        for(uint256 i = 0; i < b.length; ++i) {
+            if (isUnidentical[i]) {
+                out[id++] = b[i];
+            }
+        }
+    }
 
     // various version of contains
     function contains(address[] memory array, address element) internal pure returns (bool) {

package/contracts/core/libraries/Errors.sol

@@ -118,6 +118,8 @@ library Errors {
 
     error SYBalancerReentrancy();
 
+    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/Balancer/IPComposableStablePreview.sol

@@ -0,0 +1,23 @@
+pragma solidity 0.8.17;
+
+import "./IBalancerStablePreview.sol";
+
+interface IPComposableStablePreview is IBalancerStablePreview {
+    struct ImmutableData {
+        address[] poolTokens;
+        address[] rateProviders;
+        uint256[] rawScalingFactors;
+        bool[] isExemptFromYieldProtocolFee;
+        //
+        address LP;
+        bool noTokensExempt;
+        bool allTokensExempt;
+        uint256 bptIndex;
+        uint256 totalTokens;
+    }
+
+    struct TokenRateCache {
+        uint256 currentRate;
+        uint256 oldRate;
+    }
+}

package/contracts/interfaces/Balancer/IVersion.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+/**
+ * @notice Simple interface to retrieve the version of a deployed contract.
+ */
+interface IVersion {
+    /**
+     * @dev Returns a JSON representation of the contract version containing name, version number and task ID.
+     */
+    function version() external view returns (string memory);
+}

package/contracts/interfaces/IPExternalRewardDistributor.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPExternalRewardDistributor {
+    struct MarketRewardData {
+        uint128 rewardPerSec;
+        uint128 accumulatedReward;
+        uint128 lastUpdated;
+        uint128 incentiveEndsAt;
+    }
+
+    event DistributeReward(address indexed market, address indexed rewardToken, uint256 amount);
+
+    event AddRewardToMarket(address indexed market, address indexed token, MarketRewardData data);
+
+    function getRewardTokens(address market) external view returns (address[] memory);
+
+    function redeemRewards() external;
+}

package/contracts/interfaces/IPMarketFactoryV2.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IPMarketFactory.sol";
+
+interface IPMarketFactoryV2 is IPMarketFactory {
+    function rewardDistributor() external view returns (address);
+}

package/contracts/interfaces/IPOracleForSy.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IPOracleForSy {
+    function latestAnswer() external view returns (int256);
+}

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -0,0 +1,149 @@
+pragma solidity 0.8.17;
+
+library SDKErrorsDirectory {
+    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkNotMaintainer();
+    error BulkNotAdmin();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
+    error BulkSellerInvalidToken(address token, address SY);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error ApproxFail();
+    error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
+    error ApproxBinarySearchInputInvalid(
+        uint256 approxGuessMin,
+        uint256 approxGuessMax,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
+    );
+    error MarketExpired();
+    error MarketZeroAmountsInput();
+    error MarketZeroAmountsOutput();
+    error MarketZeroLnImpliedRate();
+    error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
+    error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
+    error MarketExchangeRateBelowOne(int256 exchangeRate);
+    error MarketProportionMustNotEqualOne();
+    error MarketRateScalarBelowZero(int256 rateScalar);
+    error MarketScalarRootBelowZero(int256 scalarRoot);
+    error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
+    error OracleUninitialized();
+    error OracleTargetTooOld(uint32 target, uint32 oldest);
+    error OracleZeroCardinality();
+    error MarketFactoryExpiredPt();
+    error MarketFactoryInvalidPt();
+    error MarketFactoryMarketExists();
+    error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryReserveFeePercentTooHigh(
+        uint8 reserveFeePercent,
+        uint8 maxReserveFeePercent
+    );
+    error MarketFactoryZeroTreasury();
+    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
+    error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
+    error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
+    error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
+    error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
+    error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
+    error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
+    error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
+    error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
+    error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
+    error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
+    error RouterTimeRangeZero();
+    error RouterCallbackNotPendleMarket(address caller);
+    error RouterInvalidAction(bytes4 selector);
+    error RouterInvalidFacet(address facet);
+    error RouterKyberSwapDataZero();
+    error YCExpired();
+    error YCNotExpired();
+    error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
+    error YCNothingToRedeem();
+    error YCPostExpiryDataNotSet();
+    error YCNoFloatingSy();
+    error YCFactoryInvalidExpiry();
+    error YCFactoryYieldContractExisted();
+    error YCFactoryZeroExpiryDivisor();
+    error YCFactoryZeroTreasury();
+    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
+    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
+    error SYInvalidTokenIn(address token);
+    error SYInvalidTokenOut(address token);
+    error SYZeroDeposit();
+    error SYZeroRedeem();
+    error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
+    error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error SYQiTokenMintFailed(uint256 errCode);
+    error SYQiTokenRedeemFailed(uint256 errCode);
+    error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
+    error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
+    error SYCurveInvalidPid();
+    error SYCurve3crvPoolNotFound();
+    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
+    error SYBalancerInvalidPid();
+    error SYInvalidRewardToken(address token);
+    error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
+    error SYBalancerReentrancy();
+    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+    error VCInactivePool(address pool);
+    error VCPoolAlreadyActive(address pool);
+    error VCZeroVePendle(address user);
+    error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
+    error VCEpochNotFinalized(uint256 wTime);
+    error VCPoolAlreadyAddAndRemoved(address pool);
+    error VEInvalidNewExpiry(uint256 newExpiry);
+    error VEExceededMaxLockTime();
+    error VEInsufficientLockTime();
+    error VENotAllowedReduceExpiry();
+    error VEZeroAmountLocked();
+    error VEPositionNotExpired();
+    error VEZeroPosition();
+    error VEZeroSlope(uint128 bias, uint128 slope);
+    error VEReceiveOldSupply(uint256 msgTime);
+    error GCNotPendleMarket(address caller);
+    error GCNotVotingController(address caller);
+    error InvalidWTime(uint256 wTime);
+    error ExpiryInThePast(uint256 expiry);
+    error ChainNotSupported(uint256 chainId);
+    error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
+    error FDEpochLengthMismatch();
+    error FDInvalidPool(address pool);
+    error FDPoolAlreadyExists(address pool);
+    error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
+    error FDInvalidStartEpoch(uint256 startEpoch);
+    error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
+    error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
+    error BDInvalidEpoch(uint256 epoch, uint256 startTime);
+    error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
+    error MsgNotFromReceiveEndpoint(address sender);
+    error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
+    error ApproxDstExecutionGasNotSet();
+    error InvalidRetryData();
+    error ArrayLengthMismatch();
+    error ArrayEmpty();
+    error ArrayOutOfBounds();
+    error ZeroAddress();
+    error FailedToSendEther();
+    error InvalidMerkleProof();
+    error OnlyLayerZeroEndpoint();
+    error OnlyYT();
+    error OnlyYCFactory();
+    error OnlyWhitelisted();
+    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
+    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
+    error MinimumStakeAmountNotReached(uint256 amountToStake, uint256 minimumStakeAmount);
+    error MinimumRedeemAmountNotReached(uint256 amountToRedeem, uint256 minimumRedeemAmount);
+    error UnstakeCapacityTooLow(uint256 amountBondToRedeem, uint256 unstakeCapacity);
+    error InvalidTokenId(uint256 tokenId, uint256 positionId);
+    error InvalidBlockRate(uint256 blockCycleNumerator);
+    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+}

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.17;
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
 import "./kyberswap/KyberInputScalingHelper.sol";
-import "./1inch/OneInchAggregationRouterHelper.sol";
+import "./oneinch/OneInchAggregationRouterHelper.sol";
 
 contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, OneInchAggregationRouterHelper {
     using Address for address;

package/deployments/5000-core.json

@@ -0,0 +1,30 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 5000,
+        "treasury": "0x5C30d3578A4D07a340650a76B9Ae5dF20D5bdF55",
+        "governance": "0x9F72a06084EdD040E973C32Bf026b1ACf65db9aB",
+        "pendle": "0xd27B18915e7acc8FD6Ac75DB6766a80f8D2f5729",
+        "lzEndpoint": "0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7",
+        "wrappedNative": "0x78c1b0c915c4faa5fffa6cabf0219da63d7f4cb8",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialFeeRateRoot": "999500333083533",
+        "initialReserveFeePercent": "80",
+        "safeWaitTime": 15000,
+        "sySwapper": ""
+    },
+    "baseCodeSplitter": "0x872c9d71a5B64A9611b08F0956A3cc3deB77A317",
+    "PENDLE": "0xd27B18915e7acc8FD6Ac75DB6766a80f8D2f5729",
+    "yieldContractFactory": "0x1e9FF49352E7155D0AF658fd88a1B3d44ed60B20",
+    "marketFactory": "0x5E9a7E1A15ab0eAaBD2D78fa36A87158752A1346",
+    "router": "0xFc7A495389cD3454f5cC0Ecaa55D30E343A1Fc16",
+    "routerStatic": "0x3B5ae552310638a69863f6E348B41912deFA0e3f",
+    "pendleSwap": "0x9d9874e867b877dD0a3F1EafB8bb1Bc54eeCc682",
+    "routerHelper": "0x09D65812dCD0f276e052583d41885cA5C7Dd0086",
+    "ptOracle": "0x9D6d509C0354ACA187aAC6beA7d063D3Ef68e2A0",
+    "externalRewardDistributor": "0xB4205a645c7e920BD8504181B1D7f2c5C955C3e7",
+    "receiverEndpoint": "0x96F77F24b3d17166FcaF3a9E3B8330fF38B966F9",
+    "vePendle": "0xaA7495dcbe99A8dbd0cfA8b27b95f77565a077c8",
+    "gaugeController": "0x921b10Eb4F4a2afDD1fCD0514022D18faf32fDbF"
+}

package/deployments/5000-markets/WSTETH-MANTLE-MARCH2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY wstETH",
+    "SY": "0xeC030Ca1A8bc0084271d5CC3E0bd3184B1DDFC27",
+    "YT": "0x6B212804b510c1140d8a968888F0B3b8b2FB71E0",
+    "PT": "0xbFDc43Fd918586673f308D898f10e9B87dc8dB5B",
+    "market": "0x3ae145cc22cd07a8de7eae7d83fb5b6b2363673a",
+    "expiry": 1711584000,
+    "scalarRoot": "197848855033000000000",
+    "initAnchor": "1025391787000000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.23.1",
+  "version": "2.23.2-mantle",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,15 +25,15 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.13.1",
-    "hardhat-contract-sizer": "^2.8.0",
-    "prettier": "^2.8.7",
+    "hardhat": "^2.17.0",
+    "hardhat-contract-sizer": "^2.10.0",
+    "prettier": "^3.0.0",
     "prettier-plugin-solidity": "^1.1.3",
-    "solc": "^0.8.19",
+    "solc": "^0.8.21",
     "solhint": "^3.4.1",
     "ts-node": "^10.9.1",
-    "typechain": "^8.1.1",
-    "typescript": "^4.9.5"
+    "typechain": "^8.3.1",
+    "typescript": "^5.1.6"
   },
   "scripts": {
     "compile": "yarn hardhat compile",

package/typechain-types/AllErrorsDirectory.ts

@@ -0,0 +1,57 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { BaseContract, Signer, utils } from "ethers";
+
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface AllErrorsDirectoryInterface extends utils.Interface {
+  contractName: "AllErrorsDirectory";
+  functions: {};
+
+  events: {};
+}
+
+export interface AllErrorsDirectory extends BaseContract {
+  contractName: "AllErrorsDirectory";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: AllErrorsDirectoryInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {};
+
+  callStatic: {};
+
+  filters: {};
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}