@pendle/core-v2 0.15.2-mainnet → 0.16.0-testnet

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveFraxUsdcPoolHelper.sol

@@ -1,127 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../../../../libraries/math/Math.sol";
-import "../../../../../interfaces/Curve/ICrvPool.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-library CurveFraxUsdcPoolHelper {
-    uint256 internal constant N_COINS = 2;
-    uint256 internal constant A_PRECISION = 100;
-    uint256 internal constant PRECISION = 10**18;
-    uint256 internal constant RATE_0 = 1000000000000000000;
-    uint256 internal constant RATE_1 = 1000000000000000000000000000000;
-    uint256 internal constant FEE_DENOMINATOR = 10**10;
-
-    address internal constant POOL = 0xDcEF968d416a41Cdac0ED8702fAC8128A64241A2;
-    address internal constant LP = 0x3175Df0976dFA876431C2E9eE6Bc45b65d3473CC;
-    address internal constant FRAX = 0x853d955aCEf822Db058eb8505911ED77F175b99e;
-    address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
-
-    using Math for uint256;
-
-    function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
-        uint256 amp = ICrvPool(POOL).A_precise();
-        uint256[N_COINS] memory _amounts = _getTokenAmounts(token, amount);
-        uint256[N_COINS] memory old_balances = _getBalances();
-        uint256[N_COINS] memory new_balances;
-        memcpy(new_balances, old_balances);
-
-        uint256 D0 = _get_D_mem(old_balances, amp);
-        uint256 total_supply = IERC20(LP).totalSupply();
-
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            // skip totalSupply = 0 check
-            new_balances[i] += _amounts[i];
-        }
-
-        uint256 D1 = _get_D_mem(new_balances, amp);
-        assert(D1 > D0);
-
-        uint256[N_COINS] memory fees;
-
-        // skip total_supply > 0 check
-        uint256 fee = (ICrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
-            uint256 difference = 0;
-            uint256 new_balance = new_balances[i];
-
-            if (ideal_balance > new_balance) {
-                difference = ideal_balance - new_balance;
-            } else {
-                difference = new_balance - ideal_balance;
-            }
-            fees[i] = (fee * difference) / FEE_DENOMINATOR;
-            new_balances[i] -= fees[i];
-        }
-        uint256 D2 = _get_D_mem(new_balances, amp);
-        return (total_supply * (D2 - D0)) / D0;
-    }
-
-    function _get_D_mem(uint256[N_COINS] memory balances, uint256 _amp)
-        internal
-        pure
-        returns (uint256)
-    {
-        uint256[N_COINS] memory _xp;
-        _xp[0] = (RATE_0 * balances[0]) / PRECISION;
-        _xp[1] = (RATE_1 * balances[1]) / PRECISION;
-
-        return _get_D(_xp, _amp);
-    }
-
-    function _get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
-        uint256 S = 0;
-        uint256 Dprev = 0;
-
-        for (uint256 k = 0; k < N_COINS; ++k) {
-            S += _xp[k];
-        }
-        if (S == 0) return 0;
-
-        uint256 D = S;
-        uint256 Ann = _amp * N_COINS;
-
-        for (uint256 _i = 0; _i < 255; ++_i) {
-            uint256 D_P = D;
-            for (uint256 k = 0; k < N_COINS; ++k) {
-                D_P = (D_P * D) / (_xp[k] * N_COINS);
-            }
-            Dprev = D;
-            D =
-                (((Ann * S) / A_PRECISION + D_P * N_COINS) * D) /
-                (((Ann - A_PRECISION) * D) / A_PRECISION + (N_COINS + 1) * D_P);
-
-            if (D > Dprev) {
-                if (D - Dprev <= 1) {
-                    return D;
-                }
-            } else {
-                if (Dprev - D <= 1) {
-                    return D;
-                }
-            }
-        }
-        assert(false);
-    }
-
-    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
-        balances[0] = ICrvPool(POOL).balances(0);
-        balances[1] = ICrvPool(POOL).balances(1);
-    }
-
-    function memcpy(uint256[N_COINS] memory a, uint256[N_COINS] memory b) internal pure {
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            a[i] = b[i];
-        }
-    }
-
-    function _getTokenAmounts(address token, uint256 amount)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        res[token == FRAX ? 0 : 1] = amount;
-    }
-}

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveUsdd3CrvPoolHelper.sol

@@ -1,152 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../../../../libraries/math/Math.sol";
-import "../../../../../interfaces/Curve/ICrvPool.sol";
-import "./Curve3CrvPoolHelper.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-library CurveUsdd3CrvPoolHelper {
-    using Math for uint256;
-
-    uint256 internal constant N_COINS = 2;
-    uint256 internal constant A_PRECISION = 100;
-    uint256 internal constant PRECISION = 10**18;
-    uint256 internal constant rate_multiplier = 10**18;
-    uint256 internal constant FEE_DENOMINATOR = 10**10;
-
-    // LP == POOL
-    address internal constant POOL = 0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea;
-    address internal constant USDD = 0x0C10bF8FcB7Bf5412187A595ab97a3609160b5c6;
-    address internal constant LP_3CRV = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
-
-    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
-        balances[0] = ICrvPool(POOL).balances(0);
-        balances[1] = ICrvPool(POOL).balances(1);
-    }
-
-    function _getTokenAmounts(address token, uint256 amount)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        res[token == USDD ? 0 : 1] = amount;
-    }
-
-    // ----------------- Forked from https://etherscan.io/address/0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea#code -----------------
-    function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
-        uint256 amp = ICrvPool(POOL).A_precise();
-
-        uint256[N_COINS] memory rates;
-
-        rates[0] = rate_multiplier;
-
-        if (token == USDD || token == LP_3CRV) {
-            rates[1] = Curve3CrvPoolHelper.get_virtual_price();
-        } else {
-            (amount, rates[1]) = Curve3CrvPoolHelper.preview3CrvDeposit(token, amount);
-            token = LP_3CRV;
-        }
-
-        uint256[N_COINS] memory amounts = _getTokenAmounts(token, amount);
-
-        uint256[N_COINS] memory old_balances = _getBalances();
-        uint256 D0 = get_D_mem(rates, old_balances, amp);
-        uint256[N_COINS] memory new_balances = arrayClone(old_balances);
-
-        uint256 total_supply = IERC20(POOL).totalSupply();
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            new_balances[i] += amounts[i];
-        }
-
-        // Invariant after change
-        uint256 D1 = get_D_mem(rates, new_balances, amp);
-        assert(D1 > D0);
-
-        // We need to recalculate the invariant accounting for fees
-        // to calculate fair user's share
-        uint256[N_COINS] memory fees;
-        uint256 mint_amount = 0;
-
-        uint256 base_fee = (ICrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
-            uint256 difference = 0;
-            uint256 new_balance = new_balances[i];
-            if (ideal_balance > new_balance) {
-                difference = ideal_balance - new_balance;
-            } else {
-                difference = new_balance - ideal_balance;
-            }
-            fees[i] = (base_fee * difference) / FEE_DENOMINATOR;
-            new_balances[i] -= fees[i];
-        }
-        uint256 D2 = get_D_mem(rates, new_balances, amp);
-        mint_amount = (total_supply * (D2 - D0)) / D0;
-        return mint_amount;
-    }
-
-    function get_D_mem(
-        uint256[N_COINS] memory _rates,
-        uint256[N_COINS] memory _balances,
-        uint256 _amp
-    ) internal pure returns (uint256) {
-        uint256[N_COINS] memory xp = _xp_mem(_rates, _balances);
-        return get_D(xp, _amp);
-    }
-
-    function _xp_mem(uint256[N_COINS] memory _rates, uint256[N_COINS] memory balances)
-        internal
-        pure
-        returns (uint256[N_COINS] memory)
-    {
-        uint256[N_COINS] memory result;
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            result[i] = balances[i] * _rates[i] / PRECISION;
-        }
-        return result;
-    }
-
-    function get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
-        uint256 S = 0;
-        uint256 Dprev = 0;
-        for (uint256 k = 0; k < N_COINS; ++k) {
-            S += _xp[k];
-        }
-        if (S == 0) return 0;
-
-        uint256 D = S;
-        uint256 Ann = _amp * N_COINS;
-        for (uint256 _i = 0; _i < 255; ++_i) {
-            uint256 D_P = D;
-            for (uint256 k = 0; k < N_COINS; ++k) {
-                D_P = (D_P * D) / (_xp[k] * N_COINS);
-            }
-            Dprev = D;
-            D =
-                (((Ann * S) / A_PRECISION + D_P * N_COINS) * D) /
-                (((Ann - A_PRECISION) * D) / A_PRECISION + (N_COINS + 1) * D_P);
-
-            if (D > Dprev) {
-                if (D - Dprev <= 1) {
-                    return D;
-                }
-            } else {
-                if (Dprev - D <= 1) {
-                    return D;
-                }
-            }
-        }
-        assert(false);
-    }
-
-    function arrayClone(uint256[N_COINS] memory a)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            res[i] = a[i];
-        }
-    }
-}

package/contracts/core/StandardizedYield/implementations/PendleLooksStakingSY.sol

@@ -1,122 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../SYBase.sol";
-import "../../../interfaces/ILooksFeeSharing.sol";
-import "../../../interfaces/ILooksStaking.sol";
-
-contract PendleLooksStakingSY is SYBase {
-    using Math for uint256;
-
-    address public immutable looks;
-    address public immutable stakingContract;
-    address public immutable feeSharingContract;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _looks,
-        address _stakingContract,
-        address _feeSharingContract
-    ) SYBase(_name, _symbol, _looks) {
-        looks = _looks;
-        stakingContract = _stakingContract;
-        feeSharingContract = _feeSharingContract;
-
-        _safeApproveInf(_looks, _stakingContract);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
-        uint256 previousShare = ILooksStaking(stakingContract).userInfo(address(this));
-        ILooksStaking(stakingContract).deposit(amountDeposited);
-        amountSharesOut = ILooksStaking(stakingContract).userInfo(address(this)) - previousShare;
-    }
-
-    function _redeem(
-        address receiver,
-        address,
-        uint256 amountSharesToRedeem
-    ) internal virtual override returns (uint256 amountTokenOut) {
-        uint256 previousBalance = _selfBalance(looks);
-        ILooksStaking(stakingContract).withdraw(amountSharesToRedeem);
-        amountTokenOut = _selfBalance(looks) - previousBalance;
-        _transferOut(looks, receiver, amountTokenOut);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    function exchangeRate() public view virtual override returns (uint256) {
-        uint256 totalShares = ILooksStaking(stakingContract).totalShares();
-        uint256 totalLooks = ILooksFeeSharing(feeSharingContract).calculateSharesValueInLOOKS(
-            stakingContract
-        );
-        return totalLooks.divDown(totalShares);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @dev LooksRare also uses 1e18 precision, so it is accurate to
-     * calculate preview results using our built-in exchangeRate function
-     */
-    function _previewDeposit(address, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
-        amountSharesOut = amountTokenToDeposit.divDown(exchangeRate());
-    }
-
-    function _previewRedeem(address, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256 amountTokenOut)
-    {
-        amountTokenOut = amountSharesToRedeem.mulDown(exchangeRate());
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](1);
-        res[0] = looks;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](1);
-        res[0] = looks;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == looks;
-    }
-
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == looks;
-    }
-
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
-        return (AssetType.TOKEN, looks, IERC20Metadata(looks).decimals());
-    }
-}

package/contracts/interfaces/Curve/ITriCrvPool.sol

@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-interface ITriCrvPool {
-    function coins(uint256 i) external view returns (address);
-
-    function get_virtual_price() external view returns (uint256);
-
-    function lp_token() external view returns (address);
-
-    function fee() external view returns (uint256);
-
-    function admin_fee() external view returns (uint256);
-
-    function exchange(
-        int128 i,
-        int128 j,
-        uint256 dx,
-        uint256 min_dy // The amount of i being exchanged.
-    ) external returns (uint256);
-
-    function add_liquidity(
-        uint256[3] memory _deposit_amount,
-        uint256 _min_amount
-    ) external;
-
-    function remove_liquidity_one_coin(
-        uint256 _burn_amount,
-        int128 i,
-        uint256 _min_amount
-    ) external;
-
-    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
-        external
-        view
-        returns (uint256);
-
-    function balances(uint256 i) external view returns (uint256);
-
-    function A() external view returns (uint256);
-}

package/contracts/interfaces/ILooksFeeSharing.sol

@@ -1,5 +0,0 @@
-pragma solidity 0.8.17;
-
-interface ILooksFeeSharing {
-    function calculateSharesValueInLOOKS(address user) external view returns (uint256);
-}

package/contracts/interfaces/ILooksStaking.sol

@@ -1,13 +0,0 @@
-pragma solidity 0.8.17;
-
-interface ILooksStaking {
-    function totalShares() external view returns (uint256);
-
-    function deposit(uint256 amount) external;
-
-    function userInfo(address user) external view returns (uint256);
-
-    function withdraw(uint256 shares) external;
-
-    function harvestAndSellAndCompound() external;
-}

package/contracts/interfaces/IPBulkSeller.sol

@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../core/BulkSeller/BulkSellerMathCore.sol";
-
-interface IPBulkSeller {
-    function swapExactSyForToken(
-        address receiver,
-        uint256 exactSyIn,
-        uint256 minTokenOut
-    ) external returns (uint256 netTokenOut);
-
-    function swapExactTokenForSy(
-        address receiver,
-        uint256 netTokenIn,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut);
-
-    function calcSwapExactTokenForSy(uint256 netTokenIn) external view returns (uint256 netSyOut);
-
-    function calcSwapExactSyForToken(uint256 netSyIn) external view returns (uint256 netTokenOut);
-
-    function SY() external view returns (address);
-
-    function token() external view returns (address);
-
-    function readState() external view returns (BulkSellerState memory);
-}

package/contracts/interfaces/IPBulkSellerFactory.sol

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-interface IPBulkSellerFactory {
-    event UpgradedBeacon(address indexed implementation);
-
-    function get(address token, address SY) external view returns (address);
-
-    function isMaintainer(address addr) external view returns (bool);
-
-    function isAdmin(address addr) external view returns (bool);
-}

package/contracts/interfaces/IPBulkSellerSYCallback.sol

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-interface IPBulkSellerCallback {
-    function swapCallback(
-        int256 ptToAccount,
-        int256 syToAccount,
-        bytes calldata data
-    ) external;
-}

package/contracts/offchain-helpers/BulkSellerOffchain.sol

@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../core/BulkSeller/BulkSellerMathCore.sol";
-import "../core/BulkSeller/BulkSeller.sol";
-import "hardhat/console.sol";
-
-// upgradable bla bla
-contract BulkSellerOffchain {
-    using BulkSellerMathCore for BulkSellerState;
-    using Math for uint256;
-
-    // rmb to add fee here
-    function calcCurrentRates(IPBulkSeller bulk)
-        external
-        view
-        returns (uint256 rateTokenToSy, uint256 rateSyToToken)
-    {
-        BulkSellerState memory state = bulk.readState();
-        address SY = bulk.SY();
-        address token = bulk.token();
-
-        {
-            uint256 hypoTotalToken = state.totalToken +
-                state.totalSy.mulDown(state.rateSyToToken);
-            uint256 netSyFromToken = IStandardizedYield(SY).previewDeposit(token, hypoTotalToken);
-
-            rateTokenToSy = netSyFromToken.divDown(hypoTotalToken);
-        }
-
-        {
-            uint256 hypoTotalSy = state.totalSy + state.totalToken.mulDown(state.rateTokenToSy);
-            uint256 netTokenFromSy = IStandardizedYield(SY).previewRedeem(token, hypoTotalSy);
-            rateSyToToken = netTokenFromSy.divDown(hypoTotalSy);
-        }
-    }
-
-    // TODO: pause contract when rate is bad compared to market
-    // TODO: Sound alarm if updates fail
-    // TODO: audit even the typescript code
-    // TODO: add a max with currentRate to guarantee no loss?
-    // TODO: pause immediately if lost enough money
-}

package/contracts/router/kyberswap/IAggregatorRouterHelper.sol

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.17;
-
-interface IAggregationRouterHelper {
-    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
-        external
-        pure
-        returns (bytes memory);
-}

package/deployments/1-core.json

@@ -1,16 +0,0 @@
-{
-    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
-    "network": 1,
-    "splitter": "0x1e56299EbC8A1010cEc26005d12e3e5c5cC2db00",
-    "celerBus": "0x4066D196A423b2b3B8B054f4F40efB47a74E200C",
-    "treasury": "0x8D407705b0a3d78167E979f71e009F5820f51C5E",
-    "PENDLE": "0x59968008a703dC13E6beaECed644bdCe4ee45d13",
-    "yieldContractFactory": "0xaD511b12F73c145Cf158EB92E4fa256937d952A4",
-    "marketFactory": "0x4d717868F4Bd14ac8B29Bb6361901e30Ae05e340",
-    "router": "0xB4205a645c7e920BD8504181B1D7f2c5C955C3e7",
-    "routerStatic": "0x96F77F24b3d17166FcaF3a9E3B8330fF38B966F9",
-    "vePendle": "0x6875e4a945e498fe1b90bbb13cfbaf0b68658c9c",
-    "senderEndpoint": "0xd5C47D2383Fddc19596489280C0A33AC42b2bB18",
-    "votingController": "0xC33B62D73cf92970e71Ce2A6162C63D4bd7AeB26",
-    "gaugeController": "0x998CF52b2585e05494BF9F2bF502351a9C7FdA8f"
-}

package/deployments/1-markets/FRAX_30_MAR_23.json

@@ -1,8 +0,0 @@
-{
-    "symbol": "SY-testFRAX-USDC",
-    "SY": "0x896f4D49916aC5cfC36d7a260a7039ba4Ea317b6",
-    "expiry": 1680134400,
-    "PT": "0xa369ba382968bE6cb95ebc666e77bA479414677C",
-    "YT": "0x16DebA598Af5c182A26eAEf0D73CB3A1d12B8372",
-    "market": "0x0e3e152673BAf2023502C7Ea38b1B792E1b12eAa"
-}

package/deployments/1-markets/LOOKS_30_MAR_23.json

@@ -1,8 +0,0 @@
-{
-    "symbol": "SY-testLOOKS",
-    "SY": "0xCE9431Ba71784819FF63BEa631E8D131a8FDBABc",
-    "expiry": 1680134400,
-    "PT": "0x84c681550Ec6C2793CE6aD2f906685F2746b5a43",
-    "YT": "0x39DE6b48ce57F2E41ddceb6977408d39a8Dc6984",
-    "market": "0xc46AE2E2b09d60A3B3F431EdCcDe63Abc5c992D2"
-}

package/deployments/1-markets/STETH_MARCH_30.json

@@ -1,8 +0,0 @@
-{
-    "symbol": "SY-testETH",
-    "SY": "0xaA7495dcbe99A8dbd0cfA8b27b95f77565a077c8",
-    "expiry": 1680134400,
-    "PT": "0xc7fCFEfB2055ba61118C93722feECDD4A72E160D",
-    "YT": "0xc4a38a6236B2BcF4f4B25690B4B5f770aD8B1195",
-    "market": "0x8967Eff7FD95491573576534ed24bD9F5E89fEB2"
-}

package/deployments/1-markets/USDD_MARCH_30.json

@@ -1,8 +0,0 @@
-{
-    "symbol": "SY-testUSDD-3CRV",
-    "SY": "0x38bB37BC4F871b1485aB5fdfa75c42bA09fb2694",
-    "expiry": 1680134400,
-    "PT": "0xbbfe183460119d201e8fa95935f12EF29E2FE1F1",
-    "YT": "0xee970d5f17cB9e8E67544676DCC4d41385b58c5B",
-    "market": "0x97b9ba585D1e218fC1F9057A7729D78D2Dc23ab1"
-}

package/deployments/1-offchain-helper.json

@@ -1,3 +0,0 @@
-{
-    "bulkSellerOffchain": "0xFc7A495389cD3454f5cC0Ecaa55D30E343A1Fc16"
-}